Reordered Power of 2

Reordered Power of 2 - Problem

You are given an integer n. We can reorder the digits of n in any order (including the original order) such that the leading digit is not zero.

Return true if and only if we can do this so that the resulting number is a power of two.

Input & Output

Example 1 — Basic Case

$ Input: n = 1

› Output: true

💡 Note: 1 is already a power of 2 (2⁰ = 1), so no reordering needed

Example 2 — Reordering Required

$ Input: n = 46

› Output: true

💡 Note: We can reorder 46 to get 64, which is 2⁶ = 64

Example 3 — No Valid Arrangement

$ Input: n = 24

› Output: false

💡 Note: No arrangement of digits 2,4 can form a power of 2 (42 and 24 are both not powers of 2)

Constraints

1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 M Microsoft 6

The key insight is that two numbers can be rearranged into each other if and only if they have identical digit frequency patterns. Best approach is to count input digits and compare with pre-computed power-of-2 patterns. Time: O(log n), Space: O(1)

Common Approaches

✓ Digit Frequency Comparison

⏱️ Time: O(log n) Space: O(1)

Count the frequency of each digit in the input number, then check if this frequency pattern matches any known power of 2. Two numbers can be rearranged into each other if they have identical digit frequency distributions.

Generate All Permutations

⏱️ Time: O(k! × k) Space: O(k!)

Convert number to string, generate all possible permutations of its digits, then check if any permutation represents a power of 2. This approach explores every possible arrangement.

Pre-computed Powers Lookup

⏱️ Time: O(log n) Space: O(1)

Pre-compute the digit frequency patterns for all powers of 2 within the valid range and store them in a set. Then simply count the input digits and check if this pattern exists in the pre-computed set.

Digit Frequency Comparison — Algorithm Steps

Count digit frequencies of input number
Generate frequency patterns for all valid powers of 2
Compare input frequency with each power of 2 frequency
Return true if any match found

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Input Digits

46 → [0,0,0,0,1,0,1,0,0,0] (one 4, one 6)

Check Powers of 2

Compare with 1,2,4,8,16,32,64...

Find Match

64 → [0,0,0,0,1,0,1,0,0,0] matches!

Code -

solution.c — C

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

void countDigits(int num, int* count) {
    for (int i = 0; i < 10; i++) count[i] = 0;
    
    char str[12];
    sprintf(str, "%d", num);
    
    for (int i = 0; str[i]; i++) {
        count[str[i] - '0']++;
    }
}

bool arraysEqual(int* a, int* b) {
    for (int i = 0; i < 10; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

bool solution(int n) {
    int targetCount[10];
    countDigits(n, targetCount);
    
    long long power = 1;
    while (power <= 1000000000LL) {
        int powerCount[10];
        countDigits(power, powerCount);
        
        if (arraysEqual(targetCount, powerCount)) {
            return true;
        }
        power *= 2;
    }
    
    return false;
}

int main() {
    int n;
    scanf("%d", &n);
    bool result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Counting digits takes O(log n), comparing with ~30 powers of 2 is constant

✓ Linear Growth

Space Complexity

O(1)

Only need arrays of size 10 for digit counts

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Digit Frequency Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler