Next Greater Numerically Balanced Number - Practice Coding Problems

Next Greater Numerically Balanced Number - Problem

A numerically balanced number is a fascinating mathematical concept where each digit d appears exactly d times in the number itself. For example:

1 is balanced because digit 1 appears exactly 1 time
122 is balanced because digit 1 appears 1 time and digit 2 appears 2 times
1333 is balanced because digit 1 appears 1 time and digit 3 appears 3 times

Your task is to find the smallest numerically balanced number that is strictly greater than the given integer n. This is like finding the "next" balanced number in sequence!

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

Input & Output

example_1.py — Basic Case

$ Input: n = 1

› Output: 22

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

example_2.py — Medium Case

$ Input: n = 1000

› Output: 1333

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

example_3.py — Already Balanced

$ Input: n = 122

› Output: 212

💡 Note: Even though 122 is balanced, we need the next one strictly greater. 212 is the next balanced number where 1 appears once and 2 appears twice.

Constraints

1 ≤ n ≤ 10⁶
The answer is guaranteed to exist within reasonable bounds
Note: Numerically balanced numbers become very sparse for larger values

Visualization

Tap to expand

Understanding the Visualization

Understanding Balance

A number is balanced when digit d appears exactly d times: 1→1 time, 2→2 times, 3→3 times

Rarity Discovery

Balanced numbers are incredibly rare - only about 83 exist below 10^7

Smart Solution

Instead of checking every number, precompute all balanced numbers and use binary search

Lightning Fast

Binary search in precomputed list gives us practically O(1) performance

Key Takeaway

🎯 Key Insight: Since numerically balanced numbers are extremely rare, the most efficient approach is to precompute all of them and use binary search for instant lookup!

Asked in

G Google 15 a Amazon 8 f Meta 6 Apple 4

The optimal approach uses a precomputed list of all numerically balanced numbers combined with binary search. Since balanced numbers are extremely rare (only ~83 exist within reasonable bounds), precomputing them gives us O(1) practical performance with O(log k) theoretical complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Precomputed List (Optimal)	O(log k)	O(k)	Use precomputed list of all balanced numbers for instant lookup
Backtracking Generation	O(k)	O(d)	Generate balanced numbers systematically using backtracking
Brute Force (Increment and Check)	O(k * m)	O(1)	Increment from n+1 and check each number for balance

Precomputed List (Optimal) — Algorithm Steps

Precompute all numerically balanced numbers up to a reasonable limit
Store them in a sorted list
Use binary search to find the first number greater than n
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Precomputed List

All balanced numbers stored in sorted array

Binary Search

Find first number greater than n

Return Result

O(log k) time complexity where k is small

Code -

solution.c — C

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

int nextBeautifulNumber(int n) {
    int balanced[] = {1, 22, 122, 212, 221, 1333, 3133, 3313, 3331, 12333, 13233, 13323, 13332,
                     21333, 23133, 23313, 23331, 31233, 31323, 31332, 32133, 32313, 32331,
                     33123, 33132, 33213, 33231, 33312, 33321, 144444, 414444, 441444, 444144,
                     444414, 444441, 1224444, 1244424, 1244442, 1424444, 2124444, 2142444,
                     2144424, 2144442, 2414444, 2441444, 2444144, 2444414, 2444441, 4124444,
                     4142444, 4144424, 4144442, 4214444, 4241444, 4244144, 4244414, 4244441,
                     4412444, 4414244, 4414424, 4414442, 4421444, 4424144, 4424414, 4424441,
                     4441244, 4441424, 4441442, 4442144, 4442414, 4442441, 4444124, 4444142,
                     4444214, 4444241, 4444412, 4444421};
    
    int size = sizeof(balanced) / sizeof(balanced[0]);
    int left = 0, right = size - 1;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (balanced[mid] > n) {
            result = balanced[mid];
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log k)

k is the number of precomputed balanced numbers (very small), binary search

⚡ Linearithmic

Space Complexity

O(k)

Storage for all balanced numbers within the range

✓ Linear Space

22.8K Views

Medium Frequency

~25 min Avg. Time

950 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

Precomputed List (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler