Strobogrammatic Number II - Practice Coding Problems

Strobogrammatic Number II - Problem

A strobogrammatic number is a fascinating mathematical concept where a number looks identical when rotated 180 degrees (or viewed upside down). Think of it like looking at a digital clock in a mirror!

Given an integer n, your task is to return all strobogrammatic numbers that have exactly n digits. You may return the answer in any order.

Key insight: Only the digits 0, 1, 6, 8, 9 can be part of a strobogrammatic number because:

0 rotates to 0
1 rotates to 1
6 rotates to 9
8 rotates to 8
9 rotates to 6

Example: For n = 2, valid strobogrammatic numbers are ["11", "69", "88", "96"]

Input & Output

example_1.py — Basic Case

$ Input: n = 2

› Output: ["11", "69", "88", "96"]

💡 Note: For 2-digit numbers, we need pairs that look the same when rotated: 11 (1↔1), 69 (6↔9), 88 (8↔8), and 96 (9↔6).

example_2.py — Single Digit

$ Input: n = 1

› Output: ["0", "1", "8"]

💡 Note: Only digits 0, 1, and 8 look the same when rotated 180 degrees by themselves.

example_3.py — Larger Case

$ Input: n = 3

› Output: ["101", "111", "181", "609", "619", "689", "808", "818", "888", "906", "916", "986"]

💡 Note: For 3-digit numbers, the middle digit must be 0, 1, or 8, and the outer digits must form valid pairs without leading zeros.

Visualization

Tap to expand

Understanding the Visualization

Start from Center

Begin with base cases: empty string or single valid digits

Add Symmetric Layers

Wrap each result with valid strobogrammatic pairs

Avoid Leading Zeros

Filter out invalid numbers starting with 0

Complete Construction

Return all valid n-digit strobogrammatic numbers

Key Takeaway

🎯 Key Insight: Use recursion to build from inside-out, placing symmetric digit pairs at each step to guarantee all generated numbers are strobogrammatic!

Time & Space Complexity

Time Complexity

⏱️

O(5^n)

We generate 5^n combinations and check each one

✓ Linear Growth

Space Complexity

O(5^n)

Store all generated combinations and results

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 14
The answer will fit in a 32-bit integer array
No leading zeros except for single digit "0" when n = 1

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 15

The optimal approach uses recursive construction to build strobogrammatic numbers from the outside-in. By leveraging the symmetric property, we only generate valid numbers, achieving O(5^(n/2)) time complexity. The key insight is that we can wrap smaller strobogrammatic numbers with valid digit pairs: (1,1), (6,9), (8,8), (9,6), and (0,0) for non-leading positions.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Combinations	O(5^n)	O(5^n)	Generate all possible n-digit numbers and check if each is strobogrammatic
Recursive Construction (Optimal)	O(5^(n/2))	O(5^(n/2))	Build strobogrammatic numbers recursively from outside-in using symmetry

Generate All Combinations — Algorithm Steps

Generate all combinations of n digits using {0,1,6,8,9}
For each combination, check if it's strobogrammatic by rotating it
Filter out numbers with leading zeros (except single digit 0)
Return all valid strobogrammatic numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 5^n combinations

Check

Test each for strobogrammatic property

Filter

Remove invalid results

Code -

solution.c — C

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

char** result;
int resultSize = 0;

int isStrobogrammatic(char* num) {
    int len = strlen(num);
    char mapping[256];
    mapping['0'] = '0'; mapping['1'] = '1'; mapping['6'] = '9';
    mapping['8'] = '8'; mapping['9'] = '6';
    
    for (int i = 0; i < len; i++) {
        if (mapping[num[i]] != num[len-1-i]) return 0;
    }
    return 1;
}

void generateCombinations(int length, char* current, int pos) {
    if (pos == length) {
        if (length == 1 || current[0] != '0') {
            if (isStrobogrammatic(current)) {
                result[resultSize] = malloc((length + 1) * sizeof(char));
                strcpy(result[resultSize], current);
                resultSize++;
            }
        }
        return;
    }
    
    char digits[] = {'0', '1', '6', '8', '9'};
    for (int i = 0; i < 5; i++) {
        current[pos] = digits[i];
        current[pos + 1] = '\0';
        generateCombinations(length, current, pos + 1);
    }
}

char** findStrobogrammatic(int n, int* returnSize) {
    result = malloc(10000 * sizeof(char*));
    resultSize = 0;
    char current[n + 1];
    generateCombinations(n, current, 0);
    *returnSize = resultSize;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(5^n)

We generate 5^n combinations and check each one

✓ Linear Growth

Space Complexity

O(5^n)

Store all generated combinations and results

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 14
The answer will fit in a 32-bit integer array
No leading zeros except for single digit "0" when n = 1

32.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Generate All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler