Confusing Number - Practice Coding Problems

Confusing Number - Problem

Math Easy

Ever wondered what happens when you flip a digital clock upside down? Some numbers look completely different, while others become invalid!

A confusing number is a number that transforms into a different valid number when rotated 180 degrees. Here's the magic behind the rotation:

0 rotates to 0
1 rotates to 1
6 rotates to 9
8 rotates to 8
9 rotates to 6
2, 3, 4, 5, 7 become invalid when rotated

Key Rules:

After rotation, leading zeros are ignored (e.g., 8000 → 0008 → 8)
The rotated number must be different from the original to be confusing
All digits must be valid after rotation

Goal: Given an integer n, return true if it's a confusing number, false otherwise.

Input & Output

example_1.py — Simple Confusing Number

$ Input: n = 6

› Output: true

💡 Note: When 6 is rotated 180°, it becomes 9, which is different from the original 6, making it confusing.

example_2.py — Non-Confusing Number

$ Input: n = 89

› Output: true

💡 Note: 8 rotates to 8, and 9 rotates to 6. So 89 becomes 68 when rotated, which is different from 89.

example_3.py — Invalid Digit

$ Input: n = 11

› Output: false

💡 Note: Both 1s rotate to 1s, so 11 becomes 11 when rotated. Since it's the same as the original, it's not confusing.

Visualization

Tap to expand

Understanding the Visualization

Original Number

Start with the input number displayed on a digital screen

Digit Validation

Check if each digit can be validly rotated (only 0,1,6,8,9 are valid)

Apply Rotation

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

Flip Display

Reverse the entire number (simulating 180-degree rotation)

Compare Results

Check if the rotated number differs from the original

Key Takeaway

🎯 Key Insight: Mathematical processing naturally handles the reversal while being more efficient than string manipulation!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit once, and there are log₁₀(n) digits in the number

⚡ Linearithmic

Space Complexity

O(1)

Only using a fixed-size rotation array and a few variables

✓ Linear Space

Constraints

0 ≤ n ≤ 10⁹
The input is guaranteed to be a valid integer
Edge case: Single digit numbers like 0, 1, 8 are not confusing as they remain the same

Asked in

G Google 25 f Facebook 18 a Amazon 12 ⊞ Microsoft 8

The optimal solution uses mathematical digit processing to avoid string conversions. We maintain a rotation array and process each digit using modulo arithmetic, naturally building the rotated number in reverse order. The key insight is that mathematical digit extraction automatically handles the 180-degree reversal, making this approach both elegant and efficient with O(log n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Digit Processing (Optimal)	O(log n)	O(1)	Process digits mathematically without string conversion
String Conversion Approach	O(log n)	O(log n)	Convert to string, check each digit, build rotated string, compare

Mathematical Digit Processing (Optimal) — Algorithm Steps

Create an array/map for digit rotation lookup
Extract digits using modulo and division operations
Check validity and build rotated number simultaneously
Compare the final rotated number with original

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Digit

Use modulo to get rightmost digit

Check & Rotate

Validate digit and get its rotation

Build Result

Accumulate rotated number

Code -

solution.c — C

#include <stdio.h>

int confusingNumber(int n) {
    // Rotation mapping: -1 means invalid digit
    int rotation[10] = {0, 1, -1, -1, -1, -1, 9, -1, 8, 6};
    
    int original = n;
    int rotated = 0;
    
    // Process each digit mathematically
    while (n > 0) {
        int digit = n % 10;
        
        // Check if digit is valid for rotation
        if (rotation[digit] == -1) {
            return 0;
        }
        
        // Build rotated number (naturally reversed due to math)
        rotated = rotated * 10 + rotation[digit];
        n /= 10;
    }
    
    // Return 1 if rotated number is different from original
    return rotated != original;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We process each digit once, and there are log₁₀(n) digits in the number

⚡ Linearithmic

Space Complexity

O(1)

Only using a fixed-size rotation array and a few variables

✓ Linear Space

Constraints

0 ≤ n ≤ 10⁹
The input is guaranteed to be a valid integer
Edge case: Single digit numbers like 0, 1, 8 are not confusing as they remain the same

28.5K Views

Medium Frequency

~12 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

Mathematical Digit Processing (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler