💡 Problem Formulation: In Python, we may encounter the task of determining if a given number contains a pair of identical digits alongside any number of digit triplets. For instance, with the input 11533221, the desired output would be True because the digit pair 11 and the digit triplet 222 are present.
Method 1: Using Default Dictionary
Implementing a digit pair and triplet checker in Python using a Default Dictionary tracks the frequency of each digit. The function checks for at least one pair and any number of triplets.
Here’s an example:
from collections import defaultdict
def check_pairs_triplets(number):
digit_count = defaultdict(int)
for digit in str(number):
digit_count[digit] += 1
pair_found = any(count == 2 for count in digit_count.values())
triplet_or_more_found = any(count >= 3 for count in digit_count.values())
return pair_found and triplet_or_more_found
print(check_pairs_triplets(11533221))Output: True
This function converts the number to a string, iterates through each digit, counting occurrences with a default dictionary. It then checks for at least one occurrence of a digit pair and any number of triplets or more using Python’s any() function.
Method 2: Using Counter from Collections
Python’s Counter object from the collections module can efficiently count digit occurrences and verify the presence of pairs and triplets.
Here’s an example:
from collections import Counter
def has_pair_and_triplets(number):
counts = Counter(str(number))
return 2 in counts.values() and any(count >= 3 for count in counts.values())
print(has_pair_and_triplets(11533221))Output: True
The has_pair_and_triplets function creates a Counter object for the digits and uses it to confirm the existence of at least one pair (count of 2) and one or more triplets (count of 3 or more).
Method 3: Regular Expressions
Regular expressions can be an efficient solution for matching patterns, such as finding a digit pair followed by any number of triplets in a string representation of a number.
Here’s an example:
import re
def matches_pair_and_triplets(number):
string_number = str(number)
pair_match = re.search(r'(\\d)\\1', string_number)
triplet_matches = len(re.findall(r'(\\d)\\1{2,}', string_number))
return bool(pair_match) and triplet_matches >= 1
print(matches_pair_and_triplets(11533221))Output: True
This method uses Python’s regular expression module to check for adjacent identical digits forming pairs and triplets within the number’s string representation. It considers patterns where a digit (\\d) is followed by the same digit (\\1).
Method 4: Iterative Approach
An iterative method to count digit occurrences without additional modules can also determine the presence of pairs and triplets in a number.
Here’s an example:
def check_digits_iteratively(number):
digit_count = {}
for digit in str(number):
if digit in digit_count:
digit_count[digit] += 1
else:
digit_count[digit] = 1
pair_found = 2 in digit_count.values()
triplet_found = any(count >= 3 for count in digit_count.values())
return pair_found and triplet_found
print(check_digits_iteratively(11533221))Output: True
By iterating through each digit in the number string, this function maintains a count of each digit’s occurrences. It then checks for the presence of a pair and triplet directly within the counts.
Bonus One-Liner Method 5: Functional Approach
A one-liner functional approach using Python’s filter and map functions for the tech-savvy who prefer concise code.
Here’s an example:
print((lambda n: any(map(lambda x: x == 2, n.values())) and any(map(lambda x: x >= 3, n.values())))(__import__('collections').Counter(str(11533221))))Output: True
This one-liner uses a lambda function to instantiate a Counter for the digits, then applies the map and any functions to check for the pair and triplets conditions in a functional programming style.
Summary/Discussion
- Method 1: Using Default Dictionary. Advantages: Readable and straightforward. Disadvantages: Requires additional import from
collections. - Method 2: Using Counter from Collections. Advantages: Clean and efficient. Disadvantages: Less transparent for beginners.
- Method 3: Regular Expressions. Advantages: Powerful pattern matching. Disadvantages: Can be complex and less efficient for larger numbers.
- Method 4: Iterative Approach. Advantages: Simple, no imports necessary. Disadvantages: Potentially less performant with the increasing length of the number.
- Method 5: Functional Approach. Advantages: Compact one-liner. Disadvantages: Less readable, especially for those not familiar with functional programming paradigms.