5 Best Ways to Sort Python List Items Based on Their Digits

by

💡 Problem Formulation: You are given a list of non-negative integers and your task is to sort the list based on the digits of the numbers, not on their face value. For example, given the input [305, 234, 52, 105], the desired output based on the digits would be [105, 305, 234, 52], since 105 with digits ‘1’, ‘0’, ‘5’ comes before 305 with ‘3’, ‘0’, ‘5’, and so on.

Method 1: Using a Custom Key Function

Sorting a list in Python using a custom key function allows for complex sorting criteria. This method utilizes the sorted() function or list.sort() in combination with a lambda function to define the sorting logic based on the individual digits of the items.

Here’s an example:

numbers = [305, 234, 52, 105]
sorted_numbers = sorted(numbers, key=lambda x: str(x))
print(sorted_numbers)

Output:

[105, 234, 305, 52]

This code snippet converts the numbers to strings, which makes the sort function compare them lexicographically, digit by digit. This achieves the desired effect of sorting the list items based on their digits.

Method 2: Using Custom Comparison Logic

A more explicit approach can be to define a custom comparison function to directly compare the digits of the numbers. The functools.cmp_to_key() utility can convert a comparison function into a key function suited for sorting.

Here’s an example:

from functools import cmp_to_key

def compare_digits(x, y):
    return (x > y) - (x < y)

numbers = [305, 234, 52, 105]
sorted_numbers = sorted(numbers, key=cmp_to_key(compare_digits))
print(sorted_numbers)

Output:

[105, 234, 305, 52]

In this code snippet, we define a comparison function that orders two numbers by their digits and then use cmp_to_key() to transform this comparison into a key function suitable for sorting.

Method 3: Sorting by Individual Digits

By extracting individual digits and sorting based on tuples, we can control the sort order more precisely. Python’s tuple comparison proceeds item by item: if the first items are equal, the second items are compared, and so on.

Here’s an example:

numbers = [305, 234, 52, 105]
sorted_numbers = sorted(numbers, key=lambda x: tuple(map(int, str(x))))
print(sorted_numbers)

Output:

[105, 234, 305, 52]

This code snippet takes each number, converts it to a string to extract individual characters, maps them to integers to form a tuple, and then sorts based on these tuples.

Method 4: Custom Sorting by Digit Frequency

Another advanced method could sort the list based on the frequency of digits, giving precedence to numbers with rarer digits. This method applies a more custom sorting logic.

Here’s an example:

from collections import Counter

numbers = [305, 234, 52, 105]
digit_frequency = Counter(str(digit) for number in numbers for digit in str(number))

sorted_numbers = sorted(numbers, key=lambda x: (sum(digit_frequency[digit] for digit in str(x)), str(x)))
print(sorted_numbers)

Output:

[105, 52, 234, 305]

This code snippet calculates the frequency of each digit across all numbers, then sorts numbers first by the cumulative frequency of their digits and then lexicographically by their string representation.

Bonus One-Liner Method 5: Using List Comprehensions

List comprehensions can also be used to create a sequence for sorting. This one-liner combines a list comprehension with the sorted() function to achieve the sort.

Here’s an example:

numbers = [305, 234, 52, 105]
sorted_numbers = sorted([(str(number), number) for number in numbers])
print([number for _, number in sorted_numbers])

Output:

[105, 234, 305, 52]

The one-liner creates a list of tuples (string representation, original number) and sorts it. The string representation ensures a digit-wise sort, and then we extract the sorted numbers.

Summary/Discussion

  • Method 1: Custom Key Function. Straightforward and Pythonic. Limited customization.
  • Method 2: Custom Comparison Logic. Provides explicit control over sorting criteria. Requires more code and understanding of cmp_to_key conversion.
  • Method 3: Sorting by Individual Digits. Offers precise control over sorting by comparing digit-wise tuples. Can seem less intuitive and may incur overhead due to tuple creation.
  • Method 4: Custom Sorting by Digit Frequency. Allows sorting by unique criteria like the rarity of digits. Potentially complex and specific to use cases with digit frequency considerations.
  • Method 5: Using List Comprehensions. Concise one-liner but might be less readable to those who are not familiar with Python’s syntax.