Maximum Odd Binary Number - Practice Coding Problems

Maximum Odd Binary Number - Problem

Imagine you have a collection of binary digits (0s and 1s) that form a binary string, and you want to create the largest possible odd binary number by rearranging these digits.

Given a binary string s that contains at least one '1', your task is to rearrange the bits to form the maximum odd binary number possible.

Key Points:

A binary number is odd if and only if its last digit is '1'
To maximize the value, we want as many '1's as possible in the most significant positions
The result can have leading zeros (they don't affect the value)

Example: If you have "0011", you can rearrange it to "1101" which is the maximum odd number possible.

Input & Output

example_1.py — Basic Case

$ Input: s = "010"

› Output: "101"

💡 Note: We have one '1' and two '0's. To make the maximum odd number, we place the '1' at the front and keep one '1' at the end. Since we only have one '1' total, it must go at the end, giving us "101".

example_2.py — Multiple 1s

$ Input: s = "0101"

› Output: "1001"

💡 Note: We have two '1's and two '0's. We place (2-1)=1 '1' at the front, then all '0's in the middle, and finally one '1' at the end: '1' + '00' + '1' = "1001".

example_3.py — All 1s

$ Input: s = "111"

› Output: "111"

💡 Note: When all characters are '1', we place (3-1)=2 '1's at the front and one '1' at the end. Since there are no '0's, the result is "111".

Constraints

1 ≤ s.length ≤ 100
s consists only of '0' and '1'
s contains at least one '1'

Visualization

Tap to expand

Understanding the Visualization

Count Your Resources

Count how many 1s (valuable) and 0s (fillers) you have

Maximize Front Value

Place as many 1s as possible at the front for maximum value

Save One 1 for End

Reserve exactly one 1 for the last position to ensure oddness

Fill Middle with 0s

Place all 0s between the front 1s and the last 1

Key Takeaway

🎯 Key Insight: To maximize an odd binary number, place all 1's except one at the front for maximum value, and exactly one 1 at the end for oddness.

Asked in

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

The optimal solution uses a greedy approach to construct the maximum odd binary number directly. Key insight: place all '1's except one at the front for maximum value, then place the remaining '1' at the end to ensure oddness. This achieves O(n) time complexity with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Count 1s and 0s, then construct optimal arrangement directly
Brute Force (Generate All Permutations)	O(n! × n)	O(n!)	Generate all possible arrangements and find the maximum odd one

Greedy Approach (Optimal) — Algorithm Steps

Count the number of '1's and '0's in the input string
Place (count_of_1s - 1) '1's at the beginning
Place all '0's in the middle
Place exactly one '1' at the end to make it odd

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count the number of 1s and 0s in the input

Place Leading 1s

Put (count_1s - 1) ones at the front

Add Middle 0s

Place all zeros in the middle

End with 1

Put exactly one 1 at the end for oddness

Code -

solution.c — C

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

char* maximumOddBinaryNumber(char* s) {
    int len = strlen(s);
    int ones = 0, zeros = 0;
    
    // Count 1s and 0s
    for (int i = 0; i < len; i++) {
        if (s[i] == '1') ones++;
        else zeros++;
    }
    
    // Allocate result string
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int idx = 0;
    
    // Add (ones-1) 1's at the beginning
    for (int i = 0; i < ones - 1; i++) {
        result[idx++] = '1';
    }
    
    // Add all 0's in the middle
    for (int i = 0; i < zeros; i++) {
        result[idx++] = '0';
    }
    
    // Add one 1 at the end
    result[idx++] = '1';
    result[idx] = '\0';
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = s;
    char* end = s + strlen(s) - 1;
    while (*start == '"' || *start == ' ') start++;
    while (*end == '"' || *end == '\n' || *end == ' ') end--;
    *(end + 1) = '\0';
    
    char* result = maximumOddBinaryNumber(start);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count characters, plus O(n) to build result string

✓ Linear Growth

Space Complexity

O(1)

Only storing count variables, result string is required output

✓ Linear Space

28.0K Views

Medium Frequency

~8 min Avg. Time

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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler