Rotated Digits

Rotated Digits - Problem

An integer x is a good number if after rotating each digit individually by 180 degrees, we get a valid number that is different from x.

Each digit must be rotated - we cannot choose to leave it alone. A number is valid if each digit remains a digit after rotation:

0, 1, and 8 rotate to themselves
2 and 5 rotate to each other
6 and 9 rotate to each other
The rest of the numbers (3, 4, 7) do not rotate to any other number and become invalid

Given an integer n, return the number of good integers in the range [1, n].

Input & Output

Example 1 — Basic Case

$ Input: n = 10

› Output: 4

💡 Note: Numbers 1-10: Good numbers are 2 (→5), 5 (→2), 6 (→9), 9 (→6). Numbers like 1 (→1) and 8 (→8) are same after rotation, so not good.

Example 2 — Smaller Range

$ Input: n = 1

› Output: 0

💡 Note: Only number 1, which rotates to itself (1→1), so it's not different. No good numbers.

Example 3 — Larger Range

$ Input: n = 25

› Output: 9

💡 Note: Good numbers are: 2, 5, 6, 9, 12, 15, 16, 19, 20. Numbers like 25 (→52) are good, but 22 (→55) contains invalid digits after 10.

Constraints

1 ≤ n ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 8

The key insight is that only digits 0,1,2,5,6,8,9 can be rotated 180°, and a good number must contain at least one of 2,5,6,9 to be different after rotation. Best approach depends on n size: brute force for small n, digit DP for large n. Time: O(n log n) to O(log n), Space: O(1) to O(log n).

Common Approaches

✓ Brute Force Check Each Number

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

For each number from 1 to n, convert it to string, check if all digits can be rotated (no 3,4,7), rotate them, and verify the result is different from original.

Digit DP with Memoization

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

Build numbers digit by digit using recursion with memoization, tracking whether we have a 'different' digit (2,5,6,9) and staying within bounds.

Optimized Digit Classification

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

Create lookup tables for digit rotation and validity, then process each number using mathematical operations instead of string conversion.

Brute Force Check Each Number — Algorithm Steps

Step 1: Iterate through each number from 1 to n
Step 2: For each number, check if all digits are rotatable (0,1,2,5,6,8,9)
Step 3: Rotate all digits and check if result differs from original
Step 4: Count numbers that satisfy both conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Range

Numbers 1 to n = 10

Check Each

Test if digits can rotate and result differs

Count Valid

Count numbers that pass both tests

Code -

solution.c — C

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

int isGood(int num) {
    char s[20];
    sprintf(s, "%d", num);
    char rotated[20] = "";
    
    for (int i = 0; s[i]; i++) {
        char digit = s[i];
        if (digit == '3' || digit == '4' || digit == '7') {
            return 0;
        } else if (digit == '0') {
            strcat(rotated, "0");
        } else if (digit == '1') {
            strcat(rotated, "1");
        } else if (digit == '2') {
            strcat(rotated, "5");
        } else if (digit == '5') {
            strcat(rotated, "2");
        } else if (digit == '6') {
            strcat(rotated, "9");
        } else if (digit == '8') {
            strcat(rotated, "8");
        } else if (digit == '9') {
            strcat(rotated, "6");
        }
    }
    
    int rotatedNum = atoi(rotated);
    return rotatedNum != num;
}

int solution(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", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Check each of n numbers, each taking O(log n) time to process digits

⚡ Linearithmic

Space Complexity

O(log n)

String conversion requires O(log n) space for digit storage

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

850 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 Each Number — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler