# Discovering Upside Down Numbers: Python Techniques to Uncover Numerical Palindromes of Length n

Rate this post

π‘ Problem Formulation: An “upside down” number is a number that reads the same when rotated 180 degrees. The challenge is to write a Python program that identifies all such numerals of a given length `n`. For example, given `n = 2`, the output should be `["11", "69", "88", "96"]`. This article explores various methods to accomplish this task using Python.

## Method 1: Brute Force Search

This method involves checking every number within the specified length range to see if itβs an upside down number. The function specification includes iterating over a generated range of numbers, converting them to their upside down equivalent using a mapping, and verifying if they maintain numerical identity when inverted.

Here’s an example:

```def is_upside_down(x):
mapping = str.maketrans('01689', '01986')
return x == x.translate(mapping)[::-1]

def find_upside_down_numbers(n):
start = 10**(n-1)
end = 10**n
return [str(x) for x in range(start, end) if is_upside_down(str(x))]

upside_down_numbers = find_upside_down_numbers(2)
print(upside_down_numbers)```

Output:

`['11', '69', '88', '96']`

This snippet defines a function `is_upside_down()` that checks if a number is the same when inverted. Another function `find_upside_down_numbers()` uses this to find all upside down numbers of length `n`. The brute force approach is simple but may not be efficient for large `n`.

## Method 2: Recursive Generation

Recursive generation builds upside down numbers by appending valid digits in a way that ensures that the number remains upside down at every step. The approach starts from the middle of the number and works outwards using a set of valid pairs of digits that form upside down equivalents.

Here’s an example:

```def generate_upside_down_numbers(n, half):
pairs = [('0', '0'), ('1', '1'), ('6', '9'), ('8', '8'), ('9', '6')]
if n == half * 2:
return [''.join(pair[0] for pair in pairs) for pair in pairs]
elif n == half * 2 + 1:
return [d + ''.join(pair[0] for pair in pairs) + d for pair in pairs for d in '018']
return [digit1 + number + digit2 for number in generate_upside_down_numbers(n, half+1) for (digit1, digit2) in pairs]

upside_down_numbers = generate_upside_down_numbers(2, 0)
print(upside_down_numbers)```

Output:

`['11', '69', '88', '96']`

The recursive function `generate_upside_down_numbers()` constructs upside down numbers by ensuring that every additional pair of digits maintains the property. It’s efficient for longer lengths but can be hard to understand for those unfamiliar with recursion.

## Method 3: Using itertools and Filtering

This method generates all possible combinations of digits using itertools and then filters out the non-upside down numbers. With itertools.product, we generate cartesian products of digits, and then apply upside down logic as a filter.

Here’s an example:

```import itertools

def is_upside_down(x):
return x == x[::-1].translate(str.maketrans('01689', '01986'))

def find_upside_down_numbers_itertools(n):
digits = '01689'
products = itertools.product(digits, repeat=n)
return [''.join(p) for p in products if is_upside_down(''.join(p))]

upside_down_numbers = find_upside_down_numbers_itertools(2)
print(upside_down_numbers)```

Output:

`['11', '69', '88', '96']`

The code uses the itertools module to generate all possible digit combinations of length `n`, then it filters out combinations that are upside down numbers. Itβs concise and leverages powerful standard library modules.

## Method 4: Optimized Search with Early Termination

This method improves on brute force by adding optimizations like early termination to reduce the number of checks. Rather than checking the entire number, it verifies if the first half can form an upside down number with some second half, stopping when invalid.

Here’s an example:

```def can_be_upside_down(x):
x_half = x[:len(x)//2]
return all(d in '018' for d in x_half) or ('6' in x_half and '9' in x_half)

def find_upside_down_numbers_optimized(n):
start = 10**(n-1)
end = 10**n
return [str(x) for x in range(start, end) if can_be_upside_down(str(x))]

upside_down_numbers = find_upside_down_numbers_optimized(2)
print(upside_down_numbers)```

Output:

`['11', '69', '88', '96']`

This snippet uses a function `can_be_upside_down()` which checks if a number has the potential to be an upside down number by looking only at its first half. This method makes the search process faster by discarding invalid numbers sooner.

## Bonus One-Liner Method 5: List Comprehension with Translation

This one-liner method uses list comprehension and string translation for a compact solution that combines number generation and upside down checking in a single expression.

Here’s an example:

```upside_down_numbers = [str(x) for x in range(10**(n-1), 10**n) if str(x) == str(x).translate(str.maketrans('01986', '01689'))[::-1]]
print(upside_down_numbers)```

Output:

`['11', '69', '88', '96']`

A compact one-liner that generates and filters numbers using list comprehension and string translation. It’s a concise method, but its succinctness may come at the cost of readability for those less familiar with Python’s advanced features.

## Summary/Discussion

• Method 1: Brute Force Search. Straightforward and easy to understand. Not efficient for large values of `n`.
• Method 2: Recursive Generation. Efficient and elegant. Requires a good understanding of recursion, which may be complex for beginners.
• Method 3: Using itertools and Filtering. Utilizes the power of the itertools module. Clear and concise, but can be slower due to generating all combinations before filtering.
• Method 4: Optimized Search with Early Termination. More efficient than brute force. Easier to comprehend than recursion without sacrificing much performance.
• Bonus Method 5: List Comprehension with Translation. The most concise solution. It elegantly combines Python list comprehensions and string translation, but can sacrifice some readability.