Rotated Digits - Practice Coding Problems

Rotated Digits - Problem

Rotated Digits is a fascinating number manipulation problem that explores what happens when we rotate each digit by 180 degrees.

Imagine holding a calculator upside down - some digits still look like valid numbers, while others become unreadable! A number is considered "good" if:

1. After rotating each digit 180°, we get a valid number
2. The rotated number is different from the original

The rotation rules are:
• 0, 1, 8 → rotate to themselves
• 2 ↔ 5 rotate to each other
• 6 ↔ 9 rotate to each other
• 3, 4, 7 → become invalid when rotated

For example, 25 becomes 52 (different and valid), so it's good. But 11 becomes 11 (same number), so it's not good.

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

Input & Output

example_1.py — Basic Case

$ Input: n = 10

› Output: 4

💡 Note: Good numbers from 1 to 10 are: 2 (→5), 5 (→2), 6 (→9), 9 (→6). Numbers like 1, 8 stay the same when rotated, and 3, 4, 7 become invalid.

example_2.py — Larger Range

$ Input: n = 857

› Output: 247

💡 Note: Count all good numbers from 1 to 857. This includes multi-digit numbers like 25 (→52), 69 (→96), etc., as long as they contain at least one changing digit and no invalid digits.

example_3.py — Edge Case

$ Input: n = 2

› Output: 1

💡 Note: Only number 2 is good (rotates to 5). Number 1 rotates to itself, so it's not good.

Constraints

1 ≤ n ≤ 10⁴
All inputs are positive integers
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Identify Digit Types

Categorize each digit: Invalid (3,4,7), Changing (2,5,6,9), or Same (0,1,8)

Check Validity

If any digit is invalid (3,4,7), the number can't be good

Ensure Difference

The number must contain at least one changing digit (2,5,6,9) to be different when rotated

Count Good Numbers

Increment counter for each number that passes both validity and difference checks

Key Takeaway

🎯 Key Insight: A number is good if it has at least one changing digit (2,5,6,9) and no invalid digits (3,4,7) - no need to actually construct the rotated number!

Asked in

G Google 15 a Amazon 8 ⊞ Microsoft 5 Apple 3

The optimal approach uses mathematical digit analysis to determine if a number is good. Instead of constructing rotated strings, we check each digit: if any digit is invalid (3,4,7), the number isn't good. If the number contains at least one changing digit (2,5,6,9) and no invalid digits, it's good. This approach is more efficient with O(1) space complexity while maintaining the same time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Number)	O(n * log n)	O(log n)	Iterate through each number from 1 to n and check if it's good by rotating each digit
Optimized Digit Analysis (Optimal)	O(n * log n)	O(1)	Use mathematical analysis to determine if a number is good without string manipulation

Brute Force (Check Every Number) — Algorithm Steps

Iterate through numbers 1 to n
For each number, extract individual digits
Rotate each digit according to the rules (0→0, 1→1, 2→5, etc.)
Check if any digit becomes invalid (3,4,7)
Check if the rotated number is different from original
Count valid good numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Number

Take the current number and examine each digit

Rotate Digits

Apply rotation rules to each digit

Validate

Check if result is valid and different

Count

Increment counter if number is good

Code -

solution.c — C

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

char getRotated(char digit) {
    switch (digit) {
        case '0': return '0';
        case '1': return '1';
        case '2': return '5';
        case '5': return '2';
        case '6': return '9';
        case '8': return '8';
        case '9': return '6';
        default: return 'X'; // Invalid
    }
}

int isGood(int num) {
    char original[20], rotated[20];
    sprintf(original, "%d", num);
    
    int len = strlen(original);
    for (int i = 0; i < len; i++) {
        char rot = getRotated(original[i]);
        if (rot == 'X') return 0;
        rotated[i] = rot;
    }
    rotated[len] = '\0';
    
    return strcmp(rotated, original) != 0;
}

int rotatedDigits(int n) {
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (isGood(i)) {
            count++;
        }
    }
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * log n)

We check n numbers, and for each number we examine log n digits

⚡ Linearithmic

Space Complexity

O(log n)

Space needed to store the rotated number string

⚡ Linearithmic Space

28.9K Views

Medium Frequency

~15 min Avg. Time

845 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

Brute Force (Check Every Number) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler