Confusing Number II

Confusing Number II - Problem

Math Backtracking Hard

A confusing number is a number that when rotated 180 degrees becomes a different number with each digit valid.

We can rotate digits of a number by 180 degrees to form new digits:

When 0, 1, 6, 8, 9 are rotated 180 degrees, they become 0, 1, 9, 8, 6 respectively
When 2, 3, 4, 5, 7 are rotated 180 degrees, they become invalid

Note: After rotating a number, we can ignore leading zeros. For example, after rotating 8000, we have 0008 which is considered as just 8.

Given an integer n, return the number of confusing numbers in the inclusive range [1, n].

Input & Output

Example 1 — Small Range

$ Input: n = 20

› Output: 6

💡 Note: Confusing numbers in [1,20]: 6→9, 9→6, 10→01=1, 16→91, 18→81, 19→61. Count = 6.

Example 2 — Single Digit

$ Input: n = 9

› Output: 2

💡 Note: Only 6→9 and 9→6 are confusing in range [1,9]. Numbers 0,1,8 rotate to themselves.

Example 3 — Edge Case

$ Input: n = 1

› Output: 0

💡 Note: Number 1 rotates to 1 (same), so it's not confusing. No confusing numbers in [1,1].

Constraints

1 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is that only digits {0,1,6,8,9} can be rotated validly, and we only need to count numbers where the rotation differs from the original. The backtracking approach is optimal as it generates only valid candidates rather than checking all numbers. Time: O(5^d), Space: O(d) where d is the number of digits in n.

Common Approaches

✓ Backtracking Generation

⏱️ Time: O(5^d) Space: O(d)

Use backtracking to build numbers digit by digit using only valid rotatable digits. This avoids checking invalid numbers and scales better with the constraint that numbers can't contain {2,3,4,5,7}.

Check Every Number

⏱️ Time: O(n × d) Space: O(d)

For each number from 1 to n, check if it contains only valid digits {0,1,6,8,9}, then rotate it and see if the result is different from the original.

Backtracking Generation — Algorithm Steps

Start with empty number
Try adding each valid digit {0,1,6,8,9}
For each valid number ≤ n, check if rotation differs
Backtrack and try next digit

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty number

Add Digits

Try each valid digit {0,1,6,8,9}

Check & Count

If valid and confusing, increment count

Code -

solution.c — C

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

int solution(char* s, int k) {
    int n = strlen(s);
    if (k > n) {
        return 0;
    }
    
    // Count character frequencies (assuming ASCII characters)
    int count[256] = {0};
    for (int i = 0; i < n; i++) {
        count[(unsigned char)s[i]]++;
    }
    
    // Count characters with odd frequencies
    int odd_count = 0;
    for (int i = 0; i < 256; i++) {
        if (count[i] % 2 == 1) {
            odd_count++;
        }
    }
    
    // We need at least odd_count palindromes and at most n palindromes
    return (odd_count <= k && k <= n) ? 1 : 0;
}

int main() {
    char s[1001];  // Static allocation to avoid stack issues
    int k;
    
    // Read string and integer
    if (fgets(s, sizeof(s), stdin) == NULL) {
        return 1;
    }
    
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    if (scanf("%d", &k) != 1) {
        return 1;
    }
    
    int result = solution(s, k);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(5^d)

Generate at most 5^d numbers where d is digits in n, each using 5 valid digits

✓ Linear Growth

Space Complexity

O(d)

Recursion depth proportional to number of digits

✓ Linear Space

23.0K Views

Medium Frequency

~35 min Avg. Time

892 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

Backtracking Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler