Partitioning Into Minimum Number Of Deci-Binary Numbers

Partitioning Into Minimum Number Of Deci-Binary Numbers - Problem

String Greedy Medium

A decimal number is called deci-binary if each of its digits is either 0 or 1 without any leading zeros. For example, 101 and 1100 are deci-binary, while 112 and 3001 are not.

Given a string n that represents a positive decimal integer, return the minimum number of positive deci-binary numbers needed so that they sum up to n.

Input & Output

Example 1 — Basic Case

$ Input: n = "32"

› Output: 3

💡 Note: We can decompose 32 into three deci-binary numbers: 10 + 11 + 11 = 32. The maximum digit is 3, so we need at least 3 deci-binary numbers.

Example 2 — Single Digit

$ Input: n = "82734"

› Output: 8

💡 Note: The maximum digit in 82734 is 8, so we need exactly 8 deci-binary numbers to sum up to this value.

Example 3 — All Same Digits

$ Input: n = "27346209830709182346"

› Output: 9

💡 Note: Despite being a very large number, we only need 9 deci-binary numbers because the maximum digit is 9.

Constraints

1 ≤ n.length ≤ 10⁵
n consists of only digits
n does not contain any leading zeros and represents a positive integer

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that each deci-binary number can contribute at most 1 to any digit position. Therefore, if we have a digit d in our target number, we need at least d deci-binary numbers. The maximum digit determines the minimum count needed. Best approach is greedy maximum digit finding. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Combinations

⏱️ Time: O(2^(n×k)) Space: O(2^n)

Generate all possible deci-binary numbers up to the length of input, then try all combinations to see which ones sum to the target with minimum count.

Greedy - Maximum Digit Approach

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

Key insight: Since each deci-binary number can contribute at most 1 to any digit position, we need at least as many deci-binary numbers as the largest digit in our target number.

Brute Force - Generate All Combinations — Algorithm Steps

Generate all possible deci-binary numbers
Try all combinations
Find minimum count that sums to target

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Digits

Check each digit in the string

Track Maximum

Keep track of the largest digit seen

Return Max

The maximum digit is our answer

Code -

solution.c — C

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

int solution(char* n) {
    int maxDigit = 0;
    int len = strlen(n);
    for (int i = 0; i < len; i++) {
        int digit = n[i] - '0';
        if (digit > maxDigit) {
            maxDigit = digit;
        }
    }
    return maxDigit;
}

int main() {
    char n[100001];
    fgets(n, sizeof(n), stdin);
    n[strcspn(n, "\n")] = 0;
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n×k))

Exponential combinations of deci-binary numbers where n is string length and k is the result

✓ Linear Growth

Space Complexity

O(2^n)

Storing all possible deci-binary number combinations

✓ Linear Space

125.0K Views

Medium Frequency

~10 min Avg. Time

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

Brute Force - Generate All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler