# Solving Leetcode Interviews in Seconds with AI: Next Greater Numerically Balanced Number


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2048" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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. Given an integer n, return the smallest numerically balanced number strictly greater than n.   Example 1:  Input: n = 1 Output: 22 Explanation:  22 is numerically balanced since: - The digit 2 occurs 2 times.  It is also the smallest numerically balanced number strictly greater than 1.  Example 2:  Input: n = 1000 Output: 1333 Explanation:  1333 is numerically balanced since: - The digit 1 occurs 1 time. - The digit 3 occurs 3 times.  It is also the smallest numerically balanced number strictly greater than 1000. Note that 1022 cannot be the answer because 0 appeared more than 0 times.  Example 3:  Input: n = 3000 Output: 3133 Explanation:  3133 is numerically balanced since: - The digit 1 occurs 1 time. - The digit 3 occurs 3 times. It is also the smallest numerically balanced number strictly greater than 3000.    Constraints:  0 <= n <= 106  

	# Explanation
	*   **Generate Candidates:** Generate numerically balanced numbers in increasing order.
*   **Check and Return:** Check if each generated number is greater than the input `n`. If it is, return it.
*   **Optimization:** Prune the search space by generating numbers of the same length as `n`'s length, and potentially one digit longer.

*   **Runtime Complexity:** O(1) (practically constant, though technically depends on the upper bound of numerically balanced numbers, which is limited due to the digit balance constraint). **Storage Complexity:** O(1) (constant storage for the generated number).

	
	# Code
	```python
	def is_balanced(x):
    s = str(x)
    counts = {}
    for digit in s:
        counts[digit] = counts.get(digit, 0) + 1
    for digit in s:
        if int(digit) == 0 and counts['0'] > 0:
            return False
        if str(int(digit)) not in counts or counts[digit] != int(digit):
            return False
    return True

def generate_balanced(length):
    if length > 7:  # largest possible balanced number has 7 digits (e.g. 6210001)
        return

    digits = [0] * length

    def backtrack(index):
        if index == length:
            num = int("".join(map(str, digits)))
            if is_balanced(num):
                yield num
            return

        for digit in range(length + 1):
            digits[index] = digit
            yield from backtrack(index + 1)

    yield from backtrack(0)

def next_balanced(n):
    n_str = str(n)
    length = len(n_str)
    
    candidates = []
    
    #Generate balanced numbers of the same length as n
    generated = sorted(num for num in generate_balanced(length) if num > n)
    if generated:
        candidates.extend(generated)

    #Generate balanced numbers with length + 1, which might be needed if all balanced numbers with the same length are smaller or equal to n.
    generated = sorted(generate_balanced(length + 1))
    if generated:
        candidates.extend(generated)

    
    if candidates:
        return candidates[0]
    else: #no such balanced numbers exists
        return -1


# Test Cases
# print(next_balanced(1))
# print(next_balanced(1000))
# print(next_balanced(3000))
# print(next_balanced(4325))
# print(next_balanced(0))
# print(next_balanced(59))

    return next_balanced(n)
	```