Remove 9 - Practice Coding Problems

Remove 9 - Problem

Math Hard

Imagine a world where the number 9 is considered unlucky and must be completely avoided! Starting from 1, we need to create a new sequence by removing any integer that contains the digit 9.

For example, numbers like 9, 19, 29, 90, 91, 99, 190, 291 would all be banned from our sequence.

This gives us a new sequence: [1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20, 21, ...]

Goal: Given a positive integer n, return the nth number (1-indexed) in this "9-free" sequence.

Key insight: This is essentially working with a base-9 numbering system using digits 0-8, but we need to map it to digits 1-8, 10 (skipping 9)!

Input & Output

example_1.py — Basic Case

$ Input: n = 8

› Output: 10

💡 Note: The sequence without 9s is [1,2,3,4,5,6,7,8,10,11,...]. The 8th number is 10 because we skip 9.

example_2.py — Early Number

$ Input: n = 5

› Output: 6

💡 Note: The first 5 numbers without 9 are [1,2,3,4,5]. The 5th number is 6.

example_3.py — Larger Number

$ Input: n = 18

› Output: 20

💡 Note: Sequence: [1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,20,...]. We skip 9,19 so the 18th valid number is 20.

Constraints

1 ≤ n ≤ 8 × 10⁸
n is guaranteed to be a positive integer
The answer will fit in a 32-bit signed integer

Visualization

Tap to expand

Understanding the Visualization

Forbidden Numbers

Any number containing digit 9 is removed: 9, 19, 29, 90-99, etc.

Remaining Sequence

Valid numbers: 1,2,3,4,5,6,7,8,10,11,12,13,14,15,16,17,18,20...

Pattern Recognition

This is exactly like base-9, but using digits 1-8,10 instead of 0-8

Direct Conversion

Convert (n-1) to base-9, then add 1 to each digit

Key Takeaway

🎯 Key Insight: Numbers without digit 9 form a bijection with base-9 numbers, enabling O(log n) conversion instead of O(n) counting!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses base-9 conversion insight: numbers without digit 9 form a sequence equivalent to base-9 numbers using digits 1-8,10. Convert (n-1) to base-9, then map each digit by adding 1. Time: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Math Optimization	O(log²(n))	O(1)	Binary search on the answer space with mathematical counting
Base-9 Conversion (Optimal)	O(log n)	O(log n)	Convert (n-1) to base-9, then map digits to skip 9
Brute Force (Linear Counting)	O(n * log(result))	O(1)	Count valid numbers one by one until reaching the nth number

Binary Search + Math Optimization — Algorithm Steps

Set binary search bounds: left = 1, right = n * 2 (upper estimate)
For mid value, count how many numbers ≤ mid don't contain digit 9
If count >= n, search left half; otherwise search right half
Use base-9 conversion logic to count valid numbers efficiently
Continue until we find the exact nth number

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Search Space

left=1, right=n*2 (estimate upper bound)

Calculate Mid

Find middle point and count valid numbers ≤ mid

Adjust Range

If count ≥ n, search left; else search right

Converge

Continue until left meets right

Code -

solution.c — C

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

int countValidNumbers(int limit) {
    if (limit <= 0) return 0;
    
    char s[20];
    sprintf(s, "%d", limit);
    int count = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        int digit = s[i] - '0';
        if (digit == 9) break;
        
        int smallerDigits = digit - (i == 0 ? 1 : 0);
        if (smallerDigits > 0) {
            count += smallerDigits * (int)pow(9, len - i - 1);
        }
    }
    
    if (strchr(s, '9') == NULL) {
        count += 1;
    }
    
    return count;
}

int removeNine(int n) {
    int left = 1, right = n * 2;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        int validCount = countValidNumbers(mid);
        
        if (validCount >= n) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log²(n))

Binary search takes O(log(n*2)) iterations, and each counting operation takes O(log(mid)) time to process digits

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search bounds and digit processing

✓ Linear Space

34.2K Views

Medium-High Frequency

~25 min Avg. Time

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

Binary Search + Math Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler