5 Best Ways to Check If the Frequency of All the Digits in a Number is the Same in Python

Rate this post

πŸ’‘ Problem Formulation: Determining whether each digit within a number appears with the same frequency can sometimes be critical in algorithms and data analysis. For instance, given the input number 556677, we want to verify if each digit (5, 6, and 7) appears the same number of timesβ€”in this case, twice. The desired output is a boolean value: True if the frequency is uniform across all digits, or False otherwise.

Method 1: Using Collections Counter

This method employs Python’s standard library collections module, specifically the Counter class, which conveniently counts the frequency of each element in an iterable. It’s effective and leverages built-in functionality to solve our problem.

Here’s an example:

from collections import Counter

def check_frequency(number):
    counts = Counter(str(number))
    return len(set(counts.values())) == 1

# Testing the function
print(check_frequency(556677))  # Should return True

Output: True

In this code snippet, Counter is used to count the occurrences of each digit in the string representation of a number. By converting the count values to a set, we can check if there’s only one unique frequency, indicating that all digits have the same frequency.

Method 2: Using a Dictionary

Instead of the Counter class, one can manually create a frequency dictionary that records the number of times each digit appears. It’s a more ‘from scratch’ approach and doesn’t require importing any additional libraries.

Here’s an example:

def check_frequency(number):
    frequency = {}
    for digit in str(number):
        frequency[digit] = frequency.get(digit, 0) + 1
    return len(set(frequency.values())) == 1

# Testing the function
print(check_frequency(112233))  # Should return True

Output: True

The function iterates through each digit, updating the frequency dictionary with the count of each digit. It then checks the number of unique frequencies in the same way as Method 1.

Method 3: Using list comprehension and all()

This method simplifies checking if all digits have the same frequency by transforming the frequency dictionary into a list and then using the all() function to ensure uniformity across all frequencies.

Here’s an example:

def check_frequency(number):
    freq = [str(number).count(i) for i in set(str(number))]
    return all(f == freq[0] for f in freq)

# Testing the function
print(check_frequency(123123))  # Should return True

Output: True

The function first creates a list that holds the frequency of each unique digit. Then, it uses all() to check whether all elements in the frequency list are equal to the first one, thereby ensuring they’re all the same.

Method 4: Sorting and Grouping

The fourth approach entails converting the number into a string, sorting it, and grouping consecutive identical digits to compare their counts. This method uses more traditional programming techniques rather than Python-specific shortcuts.

Here’s an example:

from itertools import groupby

def check_frequency(number):
    sorted_digits = sorted(str(number))
    grouped = [list(g) for k, g in groupby(sorted_digits)]
    return all(len(grouped[0]) == len(g) for g in grouped)

# Testing the function
print(check_frequency(445566))  # Should return True

Output: True

The code sorts the digits and uses groupby from the itertools module to group identical digits. It then compares the lengths of these groups to the length of the first group to determine if all digit frequencies match.

Bonus One-Liner Method 5: Using a Lambda Function

For those who favor brevity and inline solutions, this one-liner uses a lambda function alongside Python’s set and map functions to quickly check the uniformity of digit frequency.

Here’s an example:

check_frequency = lambda number: len(set(map(str(number).count, str(number)))) == 1

# Testing the function
print(check_frequency(778899))  # Should return True

Output: True

This lambda function transforms the problem into a set comprehension, which ensures all counts of digits (obtained using the map function) are the same, and checks if the set’s length is 1.

Summary/Discussion

  • Method 1: Collections Counter. Straightforward and efficient, uses built-in Python functionality. Not as educational for understanding frequency counting basics.
  • Method 2: Using a Dictionary. An educational approach demonstrating basic frequency counting without special modules. It is slightly more verbose than using Counter.
  • Method 3: List comprehension and all(). Compact and pythonic, but may be less clear to beginners. Can also be less efficient for very large numbers.
  • Method 4: Sorting and Grouping. Teaches fundamental sorting and grouping operations, but it is far less efficient for large numbers due to the sorting step.
  • Bonus Method 5: Lambda One-Liner. Concise and elegant, perfect for use in inline expressions. It can be too dense for readability and maintainability in larger codebases.