Confusing Number

Confusing Number - Problem

Math Easy

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 true if it is a confusing number, or false otherwise.

Input & Output

Example 1 — Single Confusing Digit

$ Input: n = 6

› Output: true

💡 Note: When rotated 180°, digit 6 becomes 9. Since 6 ≠ 9, it's a confusing number.

Example 2 — Two-Digit Confusing Number

$ Input: n = 89

› Output: true

💡 Note: 8 rotates to 8, 9 rotates to 6. Rotated number is 68. Since 89 ≠ 68, it's confusing.

Example 3 — Invalid Digit

$ Input: n = 11

› Output: false

💡 Note: Both 1s rotate to 1s, giving 11. Since 11 = 11, it's not confusing (same number).

Constraints

0 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is that a confusing number must contain only rotatable digits (0,1,6,8,9) AND look different when rotated 180°. Best approach uses single-pass mathematical processing to build the rotated number while checking validity. Time: O(log n), Space: O(1)

Common Approaches

✓ Digit-by-Digit Rotation

⏱️ Time: O(log n) Space: O(1)

Extract each digit from right to left, check if it's rotatable, map it to its rotated version, build the new number, and compare with original.

Single Pass with Direct Mapping

⏱️ Time: O(log n) Space: O(1)

Process digits from right to left, check validity and build rotated number simultaneously using mathematical operations instead of string manipulation.

Digit-by-Digit Rotation — Algorithm Steps

Extract each digit from the number
Check if all digits are rotatable (0,1,6,8,9)
Build rotated number by mapping each digit
Compare rotated number with original

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Validity

Verify each digit can be rotated (0,1,6,8,9)

Apply Rotation

Map each digit: 0→0, 1→1, 6→9, 8→8, 9→6

Compare Result

Check if rotated number differs from original

Code -

solution.c — C

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

int solution(int n) {
    // Convert to string
    char s[20];
    sprintf(s, "%d", n);
    int len = strlen(s);
    
    // Rotation mapping function
    char rotate(char c) {
        switch(c) {
            case '0': return '0';
            case '1': return '1';
            case '6': return '9';
            case '8': return '8';
            case '9': return '6';
            default: return '?'; // Invalid
        }
    }
    
    // Check if all digits are rotatable and build rotated
    char rotated[20];
    for (int i = 0; i < len; i++) {
        char rotatedDigit = rotate(s[i]);
        if (rotatedDigit == '?') {
            return 0; // false
        }
        rotated[len - 1 - i] = rotatedDigit;
    }
    rotated[len] = '\0';
    
    // Convert back to integer
    int rotatedNum = atoi(rotated);
    
    // Check if different
    return rotatedNum != n;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Need to process each digit of the number, and there are log₁₀(n) digits

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to store the rotated number and current digit

✓ Linear Space

12.0K Views

Medium Frequency

~15 min Avg. Time

430 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

Digit-by-Digit Rotation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler