LeetCode 246: Strobogrammatic Number Solution in Python – A Step-by-Step Guide

What Is LeetCode 246: Strobogrammatic Number?

In LeetCode 246: Strobogrammatic Number, you’re given a string num representing a number, and your task is to check if it’s strobogrammatic—meaning it looks the same when rotated 180 degrees. This problem is a fun twist on string validation, distinct from array challenges like LeetCode 242: Valid Anagram, focusing on symmetry and digit properties.

Problem Statement

• Input: A string num containing only digits.
• Output: A boolean—true if num is strobogrammatic, false otherwise.
• Rules: Valid digits are 0, 1, 6, 8, 9; when rotated, 6 becomes 9, 9 becomes 6, and 0, 1, 8 stay the same.

Constraints

• String length: 1 to 50.
• Characters: Digits 0-9 only.

Examples

• Input: num = "69"
• Output: true (6 rotates to 9, 9 to 6—matches).
• Input: num = "88"
• Output: true (8 rotates to 8—symmetric).
• Input: num = "2"
• Output: false (2 isn’t strobogrammatic).
• Input: num = "818"
• Output: true (8 to 8, 1 to 1, 8 to 8).

Understanding the Problem: Rotational Symmetry

To solve LeetCode 246: Strobogrammatic Number in Python, we need to verify if a number’s digits, when rotated 180 degrees, form the same sequence when read from the opposite end. Only certain digits work:

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

Digits like 2, 3, 4, 5, 7 don’t have valid rotations. We’ll use two methods: 1. Best Solution (Two-Pointer): O(n) time, O(1) space—fast and elegant. 2. Alternative Solution (Mapping with Reversal): O(n) time, O(n) space—simple but uses more memory.

Let’s dive into the best solution with extra detail for beginners.

Best Solution: Two-Pointer Approach

Why This Is the Best Solution

The two-pointer approach is the top pick for LeetCode 246 because it checks the string in one pass, comparing digits from both ends using minimal space (O(1)). It’s efficient and intuitive once you understand how digits pair up, making it ideal for this problem.

How It Works (Super Detailed for Beginners)

Think of this solution as holding the number up to a mirror with two fingers: one at the start and one at the end. You move your fingers toward the middle, checking if each pair of digits matches when one is rotated. If every pair works, the number is strobogrammatic. Here’s how it works, step-by-step, in a way anyone can follow:

• Set Up: Use two pointers: left starts at the beginning (index 0), and right starts at the end (last index). You’ll also need a way to know what each digit rotates to (like a little cheat sheet).
• Cheat Sheet (Mapping):
• 0 stays 0.
• 1 stays 1.
• 6 becomes 9.
• 8 stays 8.
• 9 becomes 6.
• Anything else (2, 3, 4, 5, 7) isn’t allowed.
• Check Pairs:
• Look at the digit at left and the digit at right.
• Ask: “If I rotate the left digit 180 degrees, does it match the right digit?”
• For example, if left is 6, it rotates to 9, so right must be 9.
• If they don’t match, stop—it’s not strobogrammatic.
• Move Inward: Move left one step right and right one step left. Repeat until your fingers meet or pass each other.
• Finish: If all pairs match, return true. If any fail, return false.

It’s like checking a palindrome, but with a twist—each digit has a “mirror buddy” it needs to match!

Step-by-Step Example

Example 1: num = "69"

• Setup: left = 0, right = 1.
• Check Pair:
• num[0] = '6', rotates to '9'.
• num[1] = '9', matches '9'.
• Move: left = 1, right = 0—they cross, done.
• Result: true.

Example 2: num = "818"

• Setup: left = 0, right = 2.
• Check Pair 1:
• num[0] = '8', rotates to '8'.
• num[2] = '8', matches '8'.
• Move: left = 1, right = 1.
• Check Pair 2:
• num[1] = '1', rotates to '1'.
• num[1] = '1', matches itself.
• Move: left = 2, right = 0—crossed, done.
• Result: true.

Example 3: num = "25"

• Setup: left = 0, right = 1.
• Check Pair:
• num[0] = '2', no valid rotation.
• Stop: false.

Code with Detailed Line-by-Line Explanation

Here’s the Python code, explained for beginners:

Copy codeclass Solution:
    def isStrobogrammatic(self, num: str) -> bool:
        # Step 1: Our cheat sheet (what digits rotate to)
        rotate_map = {
            '0': '0',
            '1': '1',
            '6': '9',
            '8': '8',
            '9': '6'
        }

        # Step 2: Set up our two fingers
        left = 0
        right = len(num) - 1

        # Step 3: Check pairs from outside in
        while left <= right:
            # Get the digits at both ends
            left_digit = num[left]
            right_digit = num[right]

            # Step 4: Is left_digit valid?
            if left_digit not in rotate_map:
                return False  # Not a strobogrammatic digit

            # Step 5: Does rotated left match right?
            if rotate_map[left_digit] != right_digit:
                return False  # No match, fail

            # Step 6: Move fingers inward
            left += 1
            right -= 1

        # Step 7: All pairs matched!
        return True

• Time Complexity: O(n)—one pass through half the string.
• Space Complexity: O(1)—fixed-size dictionary.

This solution is like a mirror check with a simple rulebook—perfect for beginners once you see it in action!

Alternative Solution: Mapping with String Reversal

Why an Alternative Approach?

The mapping with reversal approach is like writing the number backward after rotating each digit and checking if it’s the same as the original. It’s a bit more memory-heavy but super straightforward, making it a great starting point for beginners.

How It Works

• Define the same rotation mapping (0→0, 1→1, 6→9, 8→8, 9→6).
• Create a new string by rotating each digit and reversing the order.
• Compare the new string with the original.

Step-by-Step Example

Example: num = "69"

• Rotate Each Digit: 6→9, 9→6 → "96".
• Reverse: "96" → "69".
• Compare: "69" == "69" → true.

Example: num = "25"

• Rotate: 2 (invalid) → fail early, false.

Code for Mapping with Reversal Approach

Copy codeclass Solution:
    def isStrobogrammatic(self, num: str) -> bool:
        # Step 1: Rotation mapping
        rotate_map = {
            '0': '0',
            '1': '1',
            '6': '9',
            '8': '8',
            '9': '6'
        }

        # Step 2: Build rotated and reversed string
        rotated = ""
        for digit in num:
            if digit not in rotate_map:
                return False
            rotated = rotate_map[digit] + rotated  # Add in reverse order

        # Step 3: Compare with original
        return rotated == num

• Time Complexity: O(n)—one pass to build, one to compare.
• Space Complexity: O(n)—new string storage.

It’s clear but uses more space.

Comparing the Two Solutions

• Best Solution (Two-Pointer):
• Pros: O(n) time, O(1) space, fast.
• Cons: Requires understanding symmetry.
• Alternative Solution (Mapping with Reversal):
• Pros: Intuitive, easy to code.
• Cons: O(n) space, slightly slower.

Two-pointer wins for efficiency.

Additional Examples and Edge Cases

Single Digit

• num = "8" → true
• num = "2" → false

Even Length

• num = "11" → true

Odd Length

• num = "181" → true

Both solutions handle these well.

Complexity Breakdown

• Two-Pointer:
• Time: O(n)—half-string pass.
• Space: O(1)—fixed map.
• Mapping with Reversal:
• Time: O(n)—build and compare.
• Space: O(n)—new string.

Two-pointer is leaner.

Key Takeaways for Beginners

• Two-Pointer: Check symmetry from both ends.
• Strobogrammatic: Only 0, 1, 6, 8, 9 work.
• Mapping: Rotate and reverse—simple concept.
• Python Tip: Dictionaries make lookups easy—see [Python Basics](/python/basics).

Final Thoughts: Flip Numbers Like a Pro

LeetCode 246: Strobogrammatic Number in Python is a delightful symmetry puzzle. The two-pointer solution offers O(1) space brilliance, while mapping with reversal provides a clear alternative. Want more? Try LeetCode 247: Strobogrammatic Number II or LeetCode 248: Strobogrammatic Number III. Ready to rotate? Head to Solve LeetCode 246 on LeetCode and check those numbers today!