# Assessing Mirror Image Equivalence of Numbers in Seven Segment Displays with Python

Rate this post

π‘ Problem Formulation: In applications involving seven-segment displays, such as digital clocks or calculators, it can be useful to know if a number’s mirrored image would map to a valid and identical digit on the display. This question involves identifying numbers that look the same when flipped horizontally. Our input will be a number, and the desired output is a boolean indicating whether the number is its own mirror image in a seven-segment display context.

## Method 1: Direct Seven Segment Mapping Comparison

This method involves creating a mapping of each digit to its seven-segment display representation and then comparing it to the mirrored segment representation of the digit. This approach requires defining which segments are lit for each numeral and then devising a way to compare each numeral’s mirror image with the original segment pattern.

Here’s an example:

```def is_mirror_image_same(number):
seven_segment = {
'1': '0011000', '2': '0110111', '3': '0111101', '5': '0101101', '8': '1111111'
}
mirror_map = {'1': '1', '2': '', '3': '', '5': '5', '8': '8'}

number_str = str(number)
return all(digit in mirror_map and seven_segment[mirror_map[digit]] == seven_segment[digit]
for digit in number_str)

print(is_mirror_image_same(15851))```

Output:

`True`

This function `is_mirror_image_same()` iterates through each digit of the number and checks if it is one of the digits that have an identical mirrored seven-segment representation. In this case, we’re only considering the numbers 1, 2, 3, 5, and 8 since other numbers wouldn’t look the same when mirrored. The output confirms that 15851 is indeed a number whose seven-segment display would look the same when mirrored.

## Method 2: String Reversal and Comparison

The second method involves flipping the input number as a string to simulate a mirror image and then checking if the flipped string matches one of the pre-defined mirrored digit patterns. It’s a more straightforward approach leveraging Python’s slicing capabilities.

Here’s an example:

```def is_same_in_mirror(number):
mirrorable_digits = '018'
number_str = str(number)
mirrored = number_str[::-1]
return all(digit in mirrorable_digits for digit in mirrored) and number_str == mirrored

print(is_same_in_mirror(181))```

Output:

`True`

The function `is_same_in_mirror()` creates a mirrored version of the number string by reversing it. By ensuring all digits are in the set of mirrorable digits (0, 1, and 8), and by checking that the mirrored string is equal to the original string, it confirms the number is mirrored identically in a seven-segment display.

## Method 3: Selective Lookup with Tuple Matching

This method narrows down the digits to be evaluated by creating tuples with the digit and its mirrored counterpart. We can then check if the tuple exists within a predefined set of mirror-image pairs.

Here’s an example:

```def is_mirror_image(number):
valid_pairs = {('1', '1'), ('8', '8'), ('0', '0')}
number_str = str(number)
return all((digit, mirrored_digit) in valid_pairs for digit, mirrored_digit in zip(number_str, number_str[::-1]))

print(is_mirror_image(808))```

Output:

`True`

The `is_mirror_image()` function uses `zip()` to pair each digit with its mirrored counterpart and checks if these pairs exist in a set of valid mirror-image pairs. It confirms if a number is its own mirror on a seven-segment display, leveraging tuple evaluation for judicious pair checking.

## Method 4: Segment Flipping Function

This approach defines a function to simulate the flipping of segments, thereby checking the mirror image of each individual digit. It focuses on flipping each segment of the digit rather than the digit as a whole.

Here’s an example:

```def flip_segments(segments):
flip_map = {'0': '0', '1': '1', '8': '8'}
return ''.join(flip_map.get(segment, '') for segment in segments)

def is_mirror_image_valid(number):
number_str = str(number)
flipped = flip_segments(number_str)
return flipped == number_str

print(is_mirror_image_valid(101))```

Output:

`True`

In the `is_mirror_image_valid()` function, the intermediary `flip_segments()` function applies the flipping logic for each segment. It verifiably ensures that only numbers formed by segments that remain unchanged when flipped (0, 1, 8) are considered valid mirror images.

## Bonus One-Liner Method 5: Lambda with Filter

A concise one-liner method uses a lambda function and the filter built-in to check if our number’s mirror image is the same, utilizing the direct string comparison after filtering out non-mirrorable characters.

Here’s an example:

```is_mirror_same = lambda num: str(num) == ''.join(filter(lambda x: x in '018', str(num)[::-1]))
print(is_mirror_same(11011))```

Output:

`True`

The lambda function `is_mirror_same` combines string reversal and filtering to verify the mirror image. By ensuring only characters that are the same when mirrored are considered (‘0’, ‘1’, ‘8’), this method achieves its check with remarkable succinctness.

## Summary/Discussion

• Method 1: Direct Seven Segment Mapping Comparison. This is the most accurate method for this problem. It covers the most cases since it includes all valid seven-segment digits. However, it requires a more extensive setup and more detailed segment information.
• Method 2: String Reversal and Comparison. This method is straightforward and easy to understand, but it only works correctly with numbers containing the digits 0, 1, and 8. It might not be applicable for all seven-segment display configurations.
• Method 3: Selective Lookup with Tuple Matching. It’s an efficient method due to the use of sets for constant-time lookup. However, like method 2, it’s limited by the digits it checks.
• Method 4: Segment Flipping Function. Provides a segmented approach, focusing on the mirroring effect on individual digits. It’s a logical method but can be considered complex due to the segment flipping requirement.
• Method 5: Lambda with Filter. Offers a succinct solution. It is the most readable one-liner, but its simplicity also limits its applicability to only include digits 0, 1, and 8, similar to method 2.