Confusing Number II - Practice Coding Problems

Confusing Number II - Problem

Math Backtracking Hard

Confusing Number II is a fascinating problem about rotational symmetry in digits! 🔄

Imagine you have a digital clock that's been rotated 180 degrees - some numbers still look valid, but they might represent different values! Only the digits 0, 1, 6, 8, 9 remain valid when rotated: they become 0, 1, 9, 8, 6 respectively. Digits 2, 3, 4, 5, 7 become unreadable gibberish.

A confusing number is one that:
1. Contains only rotatable digits (0, 1, 6, 8, 9)
2. When rotated 180°, becomes a different valid number
3. Leading zeros after rotation are ignored

Examples:
• 6 → rotates to 9 (confusing! ✅)
• 89 → rotates to 68 (confusing! ✅)
• 11 → rotates to 11 (same number, not confusing ❌)
• 25 → contains invalid digits (not confusing ❌)

Goal: Count how many confusing numbers exist in the range [1, n].

Input & Output

example_1.py — Basic Case

$ Input: n = 20

› Output: 6

💡 Note: The confusing numbers in [1,20] are: 6→9, 9→6, 10→01=1, 16→91, 18→81, 19→61. Each transforms to a different valid number when rotated 180°.

example_2.py — Small Range

$ Input: n = 100

› Output: 19

💡 Note: All single-digit confusing numbers (6,9) plus valid two-digit confusing numbers like 10,16,18,19,60,61,66,68,69,80,81,86,89,90,91,96,98,99 but excluding those that rotate to themselves.

example_3.py — Edge Case

$ Input: n = 1

› Output: 0

💡 Note: No confusing numbers exist in [1,1] since 1 rotates to itself (1→1), which makes it not confusing by definition.

Visualization

Tap to expand

Screen Valid Clocks: Only process clocks with digits [0,1,6,8,9]2. Rotation Test: Virtually rotate each clock 180 degrees3. Confusion Check: Mark as 'confusing' if rotated time ≠ original time4. Count Defects: Total confusing clocks = quality control report

Understanding the Visualization

Identify Rotatable Digits

Only 0,1,6,8,9 remain valid when rotated: 0→0, 1→1, 6→9, 8→8, 9→6

Check Each Number

For numbers 1 to n, verify they contain only rotatable digits

Rotate and Compare

Rotate each valid number 180° and check if it becomes different

Count Confusing Numbers

Sum up all numbers that change when rotated (these confuse customers!)

Key Takeaway

🎯 Key Insight: Use backtracking to generate only potentially confusing numbers (containing digits 0,1,6,8,9) rather than checking every number up to n - this dramatically improves efficiency from O(n) to O(5^k) where k is the number of digits!

Time & Space Complexity

Time Complexity

⏱️

O(5^k)

We have 5 valid digits and at most k=log₁₀(n) digit positions, but pruning makes it much faster in practice

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k digits, where k=log₁₀(n)

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
Only digits 0, 1, 6, 8, 9 are valid when rotated 180°
Leading zeros are ignored after rotation (e.g., 8000 → 0008 = 8)

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses backtracking to systematically generate only valid confusing numbers instead of checking every number up to n. We build numbers digit-by-digit using only rotatable digits [0,1,6,8,9], then verify if each generated number is truly confusing (rotates to a different number). This reduces time complexity from O(n) to O(5^k) where k is the number of digits in n.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(5^k)	O(k)	Generate only valid confusing numbers using systematic digit-by-digit construction
Brute Force (Check Every Number)	O(n * k)	O(k)	Check each number from 1 to n individually for confusing property

Backtracking (Optimal) — Algorithm Steps

Define the valid rotatable digits: [0,1,6,8,9] and their rotations
Use backtracking to build numbers digit by digit
For each position, try each valid digit
When a complete number is formed, check if it's confusing and ≤ n
Prune branches early when current number exceeds n

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty

Begin with no digits, ready to build

Add first digit

Try each valid digit [1,6,8,9] as first digit (no leading 0)

Extend each branch

For each number, try adding [0,1,6,8,9] as next digit

Check and prune

Check if number is confusing and within limit n

Code -

solution.c — C

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

int validDigits[] = {0, 1, 6, 8, 9};
int limit;

int getRotatedDigit(int digit) {
    switch(digit) {
        case 0: return 0;
        case 1: return 1;
        case 6: return 9;
        case 8: return 8;
        case 9: return 6;
    }
    return -1;
}

int isConfusing(int num) {
    int original = num;
    int rotated = 0;
    
    while (num > 0) {
        int digit = num % 10;
        rotated = rotated * 10 + getRotatedDigit(digit);
        num /= 10;
    }
    return rotated != original;
}

int getDigitCount(int num) {
    int count = 0;
    if (num == 0) return 1;
    while (num > 0) {
        count++;
        num /= 10;
    }
    return count;
}

int backtrack(long long currentNum) {
    if (currentNum > limit) return 0;
    
    int count = 0;
    if (currentNum > 0 && isConfusing((int)currentNum)) {
        count++;
    }
    
    if (currentNum == 0 || getDigitCount((int)currentNum) < getDigitCount(limit)) {
        for (int i = 0; i < 5; i++) {
            int digit = validDigits[i];
            if (currentNum == 0 && digit == 0) continue;
            long long nextNum = currentNum * 10 + digit;
            if (nextNum <= limit) {
                count += backtrack(nextNum);
            }
        }
    }
    
    return count;
}

int confusingNumberII(int n) {
    limit = n;
    return backtrack(0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(5^k)

We have 5 valid digits and at most k=log₁₀(n) digit positions, but pruning makes it much faster in practice

✓ Linear Growth

Space Complexity

O(k)

Recursion depth is at most k digits, where k=log₁₀(n)

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
Only digits 0, 1, 6, 8, 9 are valid when rotated 180°
Leading zeros are ignored after rotation (e.g., 8000 → 0008 = 8)

23.5K Views

Medium Frequency

~35 min Avg. Time

847 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler