Next Greater Numerically Balanced Number

Next Greater Numerically Balanced Number - Problem

An integer x is numerically balanced if for every digit d in the number x, there are exactly d occurrences of that digit in x.

For example:

122 is numerically balanced because digit 1 appears exactly 1 time, and digit 2 appears exactly 2 times.
1223 is not numerically balanced because digit 1 appears 1 time, digit 2 appears 2 times, but digit 3 appears 1 time (not 3 times).

Given an integer n, return the smallest numerically balanced number strictly greater than n.

Input & Output

Example 1 — Basic Case

$ Input: n = 1

› Output: 22

💡 Note: The next numerically balanced number after 1 is 22, where digit 2 appears exactly 2 times.

Example 2 — Find Next Pattern

$ Input: n = 1000

› Output: 1333

💡 Note: After 1000, the next balanced number is 1333, where digit 1 appears 1 time and digit 3 appears 3 times.

Example 3 — Already Large

$ Input: n = 3000

› Output: 3133

💡 Note: The next balanced number is 3133, which is a permutation of digits 1 and 3 maintaining the balance property.

Constraints

0 ≤ n ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18

The key insight is that numerically balanced numbers follow specific patterns where digit d appears exactly d times. The most efficient approach uses precomputed patterns with binary search. Time: O(1), Space: O(1)

Common Approaches

✓ Backtracking - Generate Valid Numbers

⏱️ Time: O(9^k) Space: O(k)

Use backtracking to systematically generate all possible numerically balanced numbers. For each digit position, try digits 1-9 while maintaining the constraint that digit d must appear exactly d times in the final number.

Brute Force - Check Every Number

⏱️ Time: O(k × log k) Space: O(1)

Starting from n+1, check each number to see if it satisfies the numerically balanced condition. For each number, count digit frequencies and verify that each digit d appears exactly d times.

Pattern-Based Generation

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

Use the insight that numerically balanced numbers follow specific patterns. Only certain digit combinations can form balanced numbers, so we can generate candidates systematically and find the first one greater than n.

Backtracking - Generate Valid Numbers — Algorithm Steps

Generate all possible balanced numbers using backtracking
Only use digits 1-9 (0 cannot be balanced)
Track digit usage and remaining positions
Return first number > n

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize digit count tracking

Build

Add digits while respecting balance constraints

Validate

Check if final number is balanced and > n

Code -

solution.c — C

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

int digitCount[10];

int backtrack(char* current, int pos, int remainingPositions, int n) {
    if (remainingPositions == 0) {
        for (int i = 1; i <= 9; i++) {
            if (digitCount[i] > 0 && digitCount[i] != i) {
                return -1;
            }
        }
        int num = atoi(current);
        return num > n ? num : -1;
    }
    
    for (int digit = 1; digit <= 9; digit++) {
        if (digitCount[digit] < digit && remainingPositions >= digit - digitCount[digit]) {
            current[pos] = '0' + digit;
            current[pos + 1] = '\0';
            digitCount[digit]++;
            
            int result = backtrack(current, pos + 1, remainingPositions - 1, n);
            if (result != -1) return result;
            
            digitCount[digit]--;
        }
    }
    return -1;
}

int solution(int n) {
    char str[20];
    sprintf(str, "%d", n);
    int startLen = strlen(str);
    
    for (int length = startLen; length <= 9; length++) {
        memset(digitCount, 0, sizeof(digitCount));
        char current[20] = {0};
        int result = backtrack(current, 0, length, n);
        if (result != -1) return result;
    }
    return 1333333;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(9^k)

Where k is number of digits, trying up to 9 digits per position

✓ Linear Growth

Space Complexity

O(k)

Recursion stack depth up to k digits

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

456 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

Backtracking - Generate Valid Numbers — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler