Strobogrammatic Number II

Strobogrammatic Number II - Problem

Given an integer n, return all the strobogrammatic numbers that are of length n. You may return the answer in any order.

A strobogrammatic number is a number that looks the same when rotated 180 degrees (looked at upside down).

The valid strobogrammatic digits are: 0, 1, 6, 8, 9 where:

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

Input & Output

Example 1 — Small Case

$ Input: n = 2

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

💡 Note: All 2-digit strobogrammatic numbers: 11 (1↔1), 69 (6↔9), 88 (8↔8), 96 (9↔6)

Example 2 — Single Digit

$ Input: n = 1

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

💡 Note: Single digits that look the same upside down: 0, 1, and 8

Example 3 — Larger Case

$ Input: n = 4

› Output: ["1001","1111","1691","1881","1961","6009","6119","6699","6889","6969","8008","8118","8698","8888","8968","9006","9116","9696","9886","9966"]

💡 Note: 4-digit numbers built by adding valid pairs around 2-digit strobogrammatic numbers, excluding those with leading zeros

Constraints

0 ≤ n ≤ 14

Visualization

Tap to expand

Asked in

G Google 30 f Facebook 25 a Amazon 20

The key insight is to build strobogrammatic numbers recursively by placing valid digit pairs symmetrically. The optimal approach uses recursive construction to generate numbers from outside-in, ensuring all results are valid. Time: O(5^(n/2)), Space: O(n × 5^(n/2))

Common Approaches

✓ Brute Force Generation

⏱️ Time: O(10ⁿ) Space: O(k)

Generate every possible n-digit number, then check each one to see if it remains the same when rotated 180 degrees. This involves checking if each digit has a valid rotation and if the rotated number equals the original.

Memoized Recursion

⏱️ Time: O(5^(n/2)) Space: O(n × 5^(n/2))

Enhance the recursive approach by caching results for each length n. This prevents redundant calculations when the same subproblem is encountered multiple times, though for this specific problem the benefit is minimal since each n is computed only once.

Recursive Construction

⏱️ Time: O(5^(n/2)) Space: O(n × 5^(n/2))

Use recursion to construct strobogrammatic numbers by placing valid digit pairs at the beginning and end, then recursively filling the middle. This ensures all generated numbers are valid strobogrammatic numbers.

Brute Force Generation — Algorithm Steps

Generate all n-digit numbers
For each number, check if it's strobogrammatic
Add valid numbers to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2-digit numbers: 10, 11, 12, ...

Check

Test each number if it's strobogrammatic

Filter

Keep only valid strobogrammatic numbers

Code -

solution.c — C

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

int isStrobogrammatic(char* numStr, int len) {
    char mapping[256];
    memset(mapping, 0, sizeof(mapping));
    mapping['0'] = '0';
    mapping['1'] = '1';
    mapping['6'] = '9';
    mapping['8'] = '8';
    mapping['9'] = '6';
    
    char rotated[20];
    for (int i = 0; i < len; i++) {
        char c = numStr[len - 1 - i];
        if (mapping[c] == 0 && c != '0' && c != '1' && c != '8') return 0;
        rotated[i] = mapping[c];
    }
    rotated[len] = '\0';
    
    return strcmp(rotated, numStr) == 0;
}

char** solution(int n, int* returnSize) {
    *returnSize = 0;
    if (n == 0) return NULL;
    
    char** result = (char**)malloc(1000 * sizeof(char*));
    long long start = n > 1 ? (long long)pow(10, n-1) : 0;
    long long end = (long long)pow(10, n);
    
    for (long long num = start; num < end; num++) {
        char numStr[20];
        sprintf(numStr, "%0*lld", n, num);
        if (isStrobogrammatic(numStr, n)) {
            result[*returnSize] = (char*)malloc(20 * sizeof(char));
            strcpy(result[*returnSize], numStr);
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int returnSize;
    char** result = solution(n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(10ⁿ)

Generate 10^n possible numbers and check each one

✓ Linear Growth

Space Complexity

O(k)

Store k valid strobogrammatic numbers in result

✓ Linear Space

28.0K Views

Medium Frequency

~25 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 Generation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler