Maximum Possible Number by Binary Concatenation

Maximum Possible Number by Binary Concatenation - Problem

Binary Puzzle: You're given an array of exactly 3 integers, and your task is to create the largest possible number by concatenating their binary representations in any order you choose.

For example, if you have [1, 2, 3], their binary forms are ["1", "10", "11"]. You could arrange them as "11101" (binary) = 29 (decimal), or "11011" (binary) = 27 (decimal). Your goal is to find the arrangement that gives the maximum decimal value.

Key Points:

You must use all 3 numbers exactly once
Binary representations never have leading zeros
Return the final result as a decimal integer

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 3]

› Output: 30

💡 Note: Binary representations: 1→"1", 2→"10", 3→"11". Best arrangement is [1,3,2] or [3,1,2] giving "11110" = 30 in decimal.

example_2.py — Larger Numbers

$ Input: [2, 8, 16]

› Output: 1000108

💡 Note: Binary representations: 2→"10", 8→"1000", 16→"10000". Best arrangement is [16,8,2] giving "1000010001" = 529 in decimal.

example_3.py — Edge Case with Zero

$ Input: [0, 1, 2]

› Output: 102

💡 Note: Binary representations: 0→"0", 1→"1", 2→"10". Best arrangement is [1,0,2] giving "1010" = 10 in decimal.

Visualization

Tap to expand

Understanding the Visualization

Binary Conversion

Transform each decimal number into its binary LED pattern

Arrangement Testing

Try all 6 possible ways to arrange the 3 binary segments

Maximum Selection

Compare all decimal values and select the largest result

Key Takeaway

🎯 Key Insight: With only 3 elements, brute force enumeration of all 6 permutations is the optimal solution - no advanced algorithm can do better than O(1) constant time!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Since we always have exactly 3 elements, we generate exactly 6 permutations, making this constant time

✓ Linear Growth

Space Complexity

O(1)

We only store binary strings and intermediate results, with fixed size input

✓ Linear Space

Constraints

nums.length == 3
1 ≤ nums[i] ≤ 10⁷
Each number will have a valid binary representation without leading zeros

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach is to enumerate all permutations since we have exactly 3 elements (3! = 6 combinations). Convert each number to binary, try all arrangements, concatenate the binary strings, convert to decimal, and return the maximum. With constant input size, this brute force approach is actually optimal with O(1) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Enumerate All Permutations	O(1)	O(1)	Generate all 6 possible orderings and find the maximum

Enumerate All Permutations — Algorithm Steps

Convert each number to binary string representation
Generate all 6 permutations of the 3 numbers
For each permutation, concatenate the binary strings
Convert the concatenated binary string to decimal
Track and return the maximum decimal value found

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Binary

Transform each number to its binary representation

Generate Permutations

Create all 6 possible arrangements of the 3 numbers

Concatenate & Convert

Join binary strings and convert to decimal for comparison

Code -

solution.c — C

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

void toBinary(int n, char* binary) {
    int index = 0;
    if (n == 0) {
        strcpy(binary, "0");
        return;
    }
    
    char temp[64];
    while (n > 0) {
        temp[index++] = (n % 2) + '0';
        n /= 2;
    }
    
    // Reverse the string
    for (int i = 0; i < index; i++) {
        binary[i] = temp[index - 1 - i];
    }
    binary[index] = '\0';
}

long long binaryToDecimal(char* binary) {
    long long decimal = 0;
    int len = strlen(binary);
    for (int i = 0; i < len; i++) {
        if (binary[i] == '1') {
            decimal += (long long)pow(2, len - 1 - i);
        }
    }
    return decimal;
}

int maxGoodNumber(int nums[3]) {
    int permutations[6][3] = {
        {0, 1, 2}, {0, 2, 1}, {1, 0, 2},
        {1, 2, 0}, {2, 0, 1}, {2, 1, 0}
    };
    
    long long maxVal = 0;
    
    for (int p = 0; p < 6; p++) {
        char binaryConcat[200] = "";
        
        for (int i = 0; i < 3; i++) {
            char binary[64];
            toBinary(nums[permutations[p][i]], binary);
            strcat(binaryConcat, binary);
        }
        
        long long decimalVal = binaryToDecimal(binaryConcat);
        if (decimalVal > maxVal) {
            maxVal = decimalVal;
        }
    }
    
    return (int)maxVal;
}

int main() {
    int nums[3];
    char input[100];
    fgets(input, 100, stdin);
    
    // Parse [a,b,c] format
    sscanf(input, "[%d,%d,%d]", &nums[0], &nums[1], &nums[2]);
    
    printf("%d\n", maxGoodNumber(nums));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Since we always have exactly 3 elements, we generate exactly 6 permutations, making this constant time

✓ Linear Growth

Space Complexity

O(1)

We only store binary strings and intermediate results, with fixed size input

✓ Linear Space

Constraints

nums.length == 3
1 ≤ nums[i] ≤ 10⁷
Each number will have a valid binary representation without leading zeros

38.2K Views

Medium Frequency

~12 min Avg. Time

1.5K 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

Enumerate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler