Strobogrammatic Number - Practice Coding Problems

Strobogrammatic Number - Problem

Imagine rotating a digital clock display 180 degrees - some numbers would still look like valid numbers, while others would become unreadable! This is the fascinating concept behind strobogrammatic numbers.

Given a string num representing an integer, determine if it's a strobogrammatic number - a number that looks identical when rotated 180 degrees (viewed upside down).

Key insight: Only certain digits remain valid when rotated:

0 → 0
1 → 1
6 → 9
8 → 8
9 → 6

All other digits (2, 3, 4, 5, 7) become invalid when rotated.

Example: "69" is strobogrammatic because when rotated 180°, it becomes "69" again!

Input & Output

example_1.py — Basic Strobogrammatic

$ Input: num = "69"

› Output: true

💡 Note: When '69' is rotated 180°: '6' becomes '9' and '9' becomes '6', resulting in '69' when read from right to left. Since it matches the original, it's strobogrammatic.

example_2.py — Invalid Digit

$ Input: num = "88"

› Output: true

💡 Note: When '88' is rotated 180°: both '8's remain '8', so we get '88'. It matches the original string.

example_3.py — Non-Strobogrammatic

$ Input: num = "962"

› Output: false

💡 Note: The digit '2' has no valid 180° rotation, so '962' cannot be strobogrammatic.

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Rotations

Only digits 0,1,6,8,9 can be rotated 180° and remain valid digits

Check Symmetry

For a number to be strobogrammatic, it must read the same when rotated

Pair Validation

Each digit position must match its rotated counterpart

Key Takeaway

🎯 Key Insight: A strobogrammatic number must be symmetric when rotated - use two pointers to check if corresponding digits are valid rotations of each other!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking at most n/2 pairs of digits

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and rotation mapping

✓ Linear Space

Constraints

1 ≤ num.length ≤ 50
num consists of only digits
num does not contain any leading zeros except for the number 0 itself

Asked in

G Google 28 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal approach uses two pointers to check symmetry in O(1) space. Start from both ends and verify that each digit pair has valid rotations (0↔0, 1↔1, 6↔9, 8↔8, 9↔6). This avoids building the rotated string and provides early termination on invalid digits.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers from both ends to check symmetry without extra space
Brute Force (String Reconstruction)	O(n)	O(n)	Rotate each digit and reconstruct the entire rotated string

Two Pointers (Optimal) — Algorithm Steps

Create a mapping of valid digit rotations
Initialize left pointer at start (0) and right pointer at end (n-1)
Check if digit at left position has valid rotation to digit at right position
If valid, move both pointers inward (left++, right--)
If invalid rotation found, return false
Continue until pointers meet or cross

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Place left pointer at start, right pointer at end

Check Pair

Verify if left digit's rotation matches right digit

Move Inward

Move both pointers toward center and repeat

Code -

solution.c — C

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

char getRotation(char digit) {
    switch(digit) {
        case '0': return '0';
        case '1': return '1';
        case '6': return '9';
        case '8': return '8';
        case '9': return '6';
        default: return '\0';
    }
}

bool isStrobogrammatic(char* num) {
    int left = 0;
    int right = strlen(num) - 1;
    
    while (left <= right) {
        char leftDigit = num[left];
        char rightDigit = num[right];
        
        // Check if left digit has valid rotation
        char rotation = getRotation(leftDigit);
        if (rotation == '\0') {
            return false;
        }
        
        // Check if rotation of left digit matches right digit
        if (rotation != rightDigit) {
            return false;
        }
        
        left++;
        right--;
    }
    
    return true;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    // Remove newline and quotes
    input[strcspn(input, "\n")] = '\0';
    char* start = strchr(input, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        printf("%s\n", isStrobogrammatic(start) ? "true" : "false");
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking at most n/2 pairs of digits

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for pointers and rotation mapping

✓ Linear Space

Constraints

1 ≤ num.length ≤ 50
num consists of only digits
num does not contain any leading zeros except for the number 0 itself

28.4K Views

Medium Frequency

~15 min Avg. Time

982 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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler