Strobogrammatic Number III - Practice Coding Problems

Strobogrammatic Number III - Problem

Imagine looking at a digital calculator display upside down - some numbers still look like valid numbers! A strobogrammatic number is a fascinating mathematical concept where a number appears identical when rotated 180 degrees.

Given two strings low and high representing integers where low ≤ high, your task is to count how many strobogrammatic numbers exist within the range [low, high].

Key Rules:

Only digits 0, 1, 6, 8, 9 can appear in strobogrammatic numbers
When rotated 180°: 0→0, 1→1, 6→9, 8→8, 9→6
Numbers like 69, 88, 96, 1001, 6009 are strobogrammatic
Numbers like 25, 34, 78 are not (contain invalid digits)

This problem combines string manipulation, recursion, and clever mathematical insights to efficiently generate and count valid numbers within bounds.

Input & Output

example_1.py — Basic Range

$ Input: low = "50", high = "100"

› Output: 3

💡 Note: The strobogrammatic numbers in range [50, 100] are: 69, 88, 96. Each of these numbers looks the same when rotated 180 degrees.

example_2.py — Single Digit Range

$ Input: low = "0", high = "0"

› Output: 1

💡 Note: Only the number 0 is in the range [0, 0], and 0 is strobogrammatic since it looks the same upside down.

example_3.py — No Valid Numbers

$ Input: low = "10", high = "50"

› Output: 0

💡 Note: There are no strobogrammatic numbers between 10 and 50. The next strobogrammatic number after single digits is 11, but it's not in this range.

Visualization

Tap to expand

Understanding the Visualization

Foundation

Start with base cases: empty string and single digits 0, 1, 8

Recursive Growth

Wrap each smaller number with valid pairs: 00, 11, 69, 88, 96

Length Control

Generate numbers for each length from low.length to high.length

Range Filtering

Keep only numbers that fall within [low, high] bounds

Key Takeaway

🎯 Key Insight: Instead of checking every number, generate only valid strobogrammatic candidates using recursion, then filter by range - dramatically reducing time from O(range) to O(5^(n/2))

Time & Space Complexity

Time Complexity

⏱️

O(5^(n/2))

Where n is the maximum length. We generate 5^(n/2) strobogrammatic numbers

✓ Linear Growth

Space Complexity

O(5^(n/2))

Space to store all generated strobogrammatic numbers and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ low.length, high.length ≤ 15
low and high consist of only digits
low ≤ high
low and high do not contain any leading zeros except for the zero itself

Asked in

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

The optimal approach uses recursive generation to build strobogrammatic numbers from the center outward, achieving O(5^(n/2)) time complexity. Instead of checking every number in the range, we generate only valid candidates by wrapping smaller strobogrammatic numbers with valid digit pairs: (0,0), (1,1), (6,9), (8,8), (9,6), then filter by range bounds.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Generation (Optimal)	O(5^(n/2))	O(5^(n/2))	Generate strobogrammatic numbers recursively and count those in range

Recursive Generation (Optimal) — Algorithm Steps

Generate all strobogrammatic numbers for lengths between low and high lengths
Use recursion to build numbers from center outward
For each length, start with base cases (empty, '0', '1', '8') and build outward
Add valid pairs: '00', '11', '69', '88', '96' around existing numbers
Filter generated numbers to only include those in [low, high] range
Handle edge cases like leading zeros and single digits

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

Start with length 0: [''] and length 1: ['0','1','8']

Recursive Building

For length n, wrap length n-2 results with valid pairs

Add Pairs

Wrap with: 00, 11, 69, 88, 96 (no leading zeros)

Filter Range

Keep only numbers within [low, high] bounds

Code -

solution.c — C

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

char** helper(int n, int m, int* returnSize) {
    if (n == 0) {
        char** result = malloc(sizeof(char*));
        result[0] = malloc(1);
        result[0][0] = '\0';
        *returnSize = 1;
        return result;
    }
    
    if (n == 1) {
        char** result = malloc(3 * sizeof(char*));
        result[0] = malloc(2); strcpy(result[0], "0");
        result[1] = malloc(2); strcpy(result[1], "1");
        result[2] = malloc(2); strcpy(result[2], "8");
        *returnSize = 3;
        return result;
    }
    
    int prevSize;
    char** prev = helper(n - 2, m, &prevSize);
    char pairs[5][2] = {{"0"[0], "0"[0]}, {"1"[0], "1"[0]}, {"6"[0], "9"[0]}, {"8"[0], "8"[0]}, {"9"[0], "6"[0]}};
    
    char** result = malloc(prevSize * 5 * sizeof(char*));
    int count = 0;
    
    for (int i = 0; i < prevSize; i++) {
        for (int j = 0; j < 5; j++) {
            if (n != m || pairs[j][0] != '0') {
                int len = strlen(prev[i]) + 3;
                result[count] = malloc(len);
                sprintf(result[count], "%c%s%c", pairs[j][0], prev[i], pairs[j][1]);
                count++;
            }
        }
    }
    
    // Free previous result
    for (int i = 0; i < prevSize; i++) {
        free(prev[i]);
    }
    free(prev);
    
    *returnSize = count;
    return result;
}

int isInRange(char* num, char* low, char* high) {
    int numLen = strlen(num);
    int lowLen = strlen(low);
    int highLen = strlen(high);
    
    if (numLen < lowLen || numLen > highLen) return 0;
    if (numLen == lowLen && strcmp(num, low) < 0) return 0;
    if (numLen == highLen && strcmp(num, high) > 0) return 0;
    return 1;
}

int strobogrammaticInRange(char* low, char* high) {
    int count = 0;
    int lowLen = strlen(low);
    int highLen = strlen(high);
    
    for (int len = lowLen; len <= highLen; len++) {
        int candidateSize;
        char** candidates = helper(len, len, &candidateSize);
        
        for (int i = 0; i < candidateSize; i++) {
            if (strlen(candidates[i]) > 0 && isInRange(candidates[i], low, high)) {
                count++;
            }
            free(candidates[i]);
        }
        free(candidates);
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(5^(n/2))

Where n is the maximum length. We generate 5^(n/2) strobogrammatic numbers

✓ Linear Growth

Space Complexity

O(5^(n/2))

Space to store all generated strobogrammatic numbers and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ low.length, high.length ≤ 15
low and high consist of only digits
low ≤ high
low and high do not contain any leading zeros except for the zero itself

12.6K Views

Medium Frequency

~25 min Avg. Time

420 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

Recursive Generation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler