Reordered Power of 2 - Practice Coding Problems

Reordered Power of 2 - Problem

Given an integer n, your task is to determine if we can rearrange its digits to form a power of 2.

You can reorder the digits in any order (including keeping the original order), but the resulting number cannot have leading zeros. Return true if such a rearrangement is possible, false otherwise.

Examples:

n = 1 → true (1 is 2⁰)
n = 10 → false (digits 1,0 cannot form any power of 2)
n = 16 → true (16 is 2⁴)
n = 24 → false (digits 2,4 cannot form any power of 2)

The challenge is to efficiently check if any permutation of the digits can create a power of 2 without generating all possible permutations.

Input & Output

example_1.py — Basic Power of 2

$ Input: n = 1

› Output: true

💡 Note: 1 is already a power of 2 (2^0 = 1), so no rearrangement is needed.

example_2.py — Simple Rearrangement

$ Input: n = 46

› Output: true

💡 Note: We can rearrange 46 to get 64, which is 2^6. The digits 4 and 6 can form the power of 2: 64.

example_3.py — Impossible Case

$ Input: n = 24

› Output: false

💡 Note: No rearrangement of digits 2 and 4 can form a power of 2. The only possibilities are 24 and 42, neither of which is a power of 2.

Visualization

Tap to expand

Understanding the Visualization

Count Your Tiles

Count how many of each digit you have in the input number

Check Dictionary

Go through powers of 2 and count their digits

Compare Counts

If any power of 2 has the same digit counts, we found a match

Return Result

Return true if match found, false otherwise

Key Takeaway

🎯 Key Insight: Instead of generating O(n!) permutations, we use digit frequency counting which reduces the problem to comparing O(1) sized arrays for O(log n) powers of 2.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Only need to check powers of 2 with same digit count, which is logarithmic

⚡ Linearithmic

Space Complexity

O(1)

Fixed-size frequency arrays (10 elements for digits 0-9)

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
The input number can have up to 10 digits
No leading zeros allowed in the rearranged number

Asked in

G Google 35 f Facebook 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses digit frequency counting instead of generating permutations. Count the frequency of each digit (0-9) in the input number, then compare with the digit frequencies of all powers of 2 within the constraint range. Two numbers are anagrams if they have identical digit frequency distributions, making this approach O(log n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n! × n)	O(n!)	Generate all permutations of digits and check if any is a power of 2
Digit Frequency Counting (Optimal)	O(log n)	O(1)	Count digit frequencies and compare with powers of 2 having same digit count

Generate All Permutations — Algorithm Steps

Convert the number to a string to work with individual digits
Generate all permutations of the digits
For each permutation, check if it has leading zeros (skip if so)
Convert valid permutations to integers and check if they're powers of 2
Return true if any permutation is a power of 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digits

Convert number to individual digits

Generate All Permutations

Create every possible arrangement

Filter Valid Numbers

Remove those with leading zeros

Check Powers of 2

Test each valid number

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

bool isPowerOfTwo(int num) {
    return num > 0 && (num & (num - 1)) == 0;
}

void swap(char* a, char* b) {
    char temp = *a;
    *a = *b;
    *b = temp;
}

bool checkPermutations(char* str, int start, int end) {
    if (start == end) {
        if (str[0] == '0') return false;
        int num = atoi(str);
        return isPowerOfTwo(num);
    }
    
    for (int i = start; i <= end; i++) {
        swap(&str[start], &str[i]);
        if (checkPermutations(str, start + 1, end)) {
            return true;
        }
        swap(&str[start], &str[i]);
    }
    
    return false;
}

bool reorderedPowerOf2(int n) {
    char str[20];
    sprintf(str, "%d", n);
    int len = strlen(str);
    return checkPermutations(str, 0, len - 1);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%s\n", reorderedPowerOf2(n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to check if it's a power of 2

⚠ Quadratic Growth

Space Complexity

O(n!)

Need to store all permutations in memory

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 10⁹
The input number can have up to 10 digits
No leading zeros allowed in the rearranged number

52.0K Views

Medium Frequency

~15 min Avg. Time

1.4K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler