Closest Fair Integer

Closest Fair Integer - Problem

Math Enumeration Medium

You are given a positive integer n. We call an integer k fair if the number of even digits in k is equal to the number of odd digits in it.

Return the smallest fair integer that is greater than or equal to n.

Example:

For n = 1, return 10 (1 even digit: 0, 1 odd digit: 1)
For n = 123, return 1230 (2 even digits: 2,0, 2 odd digits: 1,3)

Input & Output

Example 1 — Single Digit

$ Input: n = 1

› Output: 10

💡 Note: 1 has 1 odd digit (1) and 0 even digits, so it's not fair. The smallest fair number ≥ 1 is 10: 1 odd digit (1) and 1 even digit (0).

Example 2 — Already Fair

$ Input: n = 32

› Output: 32

💡 Note: 32 has 1 odd digit (3) and 1 even digit (2), so equal counts. It's already fair, return 32.

Example 3 — Need More Digits

$ Input: n = 123

› Output: 1023

💡 Note: 123 has 2 odd digits (1,3) and 1 even digit (2). Need equal counts. The next fair number is 1023: 2 odd digits (1,3) and 2 even digits (0,2).

Constraints

1 ≤ n ≤ 10⁹
n is a positive integer

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that fair numbers must have equal counts of even and odd digits. The brute force approach checks each number sequentially, while the optimized approach constructs fair number candidates systematically. Best approach is smart construction for better performance. Time: O(k×d) brute force, O(d²) optimized, Space: O(1) to O(d)

Common Approaches

✓ Brute Force Iteration

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

Start from the given number n and increment by 1, checking each number to see if it has equal counts of even and odd digits. Return the first fair number found.

Smart Construction

⏱️ Time: O(d²) Space: O(d)

Instead of checking every number, analyze the structure of fair numbers and construct candidates by manipulating digits. Use mathematical properties to generate potential fair numbers more efficiently.

Brute Force Iteration — Algorithm Steps

Step 1: Start with current number = n
Step 2: Count even and odd digits in current number
Step 3: If counts are equal, return current number
Step 4: Otherwise increment and repeat

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin checking from n

Count

Count even/odd digits in current number

Check

If equal counts, return; else increment

Code -

solution.c — C

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

int* cheapestJump(int* coins, int coinsSize, int maxJump, int* returnSize) {
    if (coinsSize == 0 || coins[0] == -1 || coins[coinsSize-1] == -1) {
        *returnSize = 0;
        return NULL;
    }
    
    // DP to find minimum cost to reach each position
    int* dp = (int*)malloc(coinsSize * sizeof(int));
    for (int i = 0; i < coinsSize; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = coins[0];
    
    for (int i = 0; i < coinsSize; i++) {
        if (dp[i] == INT_MAX || coins[i] == -1) {
            continue;
        }
        
        int maxReach = (i + maxJump + 1 < coinsSize) ? i + maxJump + 1 : coinsSize;
        
        for (int j = i + 1; j < maxReach; j++) {
            if (coins[j] != -1) {
                if (dp[i] + coins[j] < dp[j]) {
                    dp[j] = dp[i] + coins[j];
                }
            }
        }
    }
    
    // If destination is unreachable
    if (dp[coinsSize-1] == INT_MAX) {
        free(dp);
        *returnSize = 0;
        return NULL;
    }
    
    // Reconstruct lexicographically smallest path
    int* path = (int*)malloc(coinsSize * sizeof(int));
    int pathSize = 0;
    int pos = coinsSize - 1;
    
    while (pos >= 0) {
        path[pathSize++] = pos + 1; // Convert to 1-indexed
        if (pos == 0) break;
        
        // Find the smallest index that can reach current position optimally
        int start = (pos - maxJump > 0) ? pos - maxJump : 0;
        
        for (int prev = start; prev < pos; prev++) {
            if (coins[prev] != -1 && dp[prev] != INT_MAX &&
                dp[prev] + coins[pos] == dp[pos]) {
                pos = prev;
                break;
            }
        }
    }
    
    // Reverse the path
    for (int i = 0; i < pathSize / 2; i++) {
        int temp = path[i];
        path[i] = path[pathSize - 1 - i];
        path[pathSize - 1 - i] = temp;
    }
    
    free(dp);
    *returnSize = pathSize;
    return path;
}

int main() {
    // Test functionality - can be customized as needed
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × d)

k is the difference between n and next fair number, d is digits per number to check

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to count digits

✓ Linear Space

12.4K Views

Medium Frequency

~25 min Avg. Time

234 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 Iteration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler