**π‘ Problem Formulation:** When working with lists in Python, you might encounter the need to sort them according to the units digit (the last digit) of each number. For example, given the input list `[12, 105, 34, 9, 56]`

, the sorted output based on each number’s units digit should be `[12, 105, 56, 34, 9]`

.

## Method 1: Using a Custom Key Function

This method involves defining a custom sorting key that extracts the units digit of each number and passes it to the built-in `sorted()`

method. The key function could be a lambda function or a regular function that returns the last digit using modulus operation.

Here’s an example:

numbers = [12, 105, 34, 9, 56] sorted_numbers = sorted(numbers, key=lambda x: x % 10) print(sorted_numbers)

Output: `[12, 105, 56, 34, 9]`

This code snippet defines a lambda function as the key, which takes each element `x`

and computes `x % 10`

to get its units digit. The `sorted()`

method then orders the list according to the computed key values.

## Method 2: Using the Operator Module

The `operator`

module provides functions that correspond to intrinsic operators in Python. For sorting by units digit, we can use the `itemgetter()`

function to extract this digit after converting each number to a string.

Here’s an example:

from operator import itemgetter numbers = [12, 105, 34, 9, 56] sorted_numbers = sorted(numbers, key=lambda x: itemgetter(-1)(str(x))) print(sorted_numbers)

Output: `[12, 105, 56, 34, 9]`

Here, the expression `itemgetter(-1)(str(x))`

extracts the last character (the units digit) of the string representation of `x`

. The key function sorts the numbers based on this character.

## Method 3: In-Place Sorting Using a Custom Key

In this method, we sort the list in-place using the `list.sort()`

method with a key that determines the sort order by the units digit, similar to Method 1.

Here’s an example:

numbers = [12, 105, 34, 9, 56] numbers.sort(key=lambda x: x % 10) print(numbers)

Output: `[12, 105, 56, 34, 9]`

This code directly sorts the original list `numbers`

in-place using the same key function as in Method 1, which considers the units digit when determining the order of elements.

## Method 4: Comprehensive Sorting with Transformations

The fourth method involves comprehensive sorting through a transformation step which creates pairs of units digits and original numbers, sorts the pairs, and then extracts the sorted numbers.

Here’s an example:

numbers = [12, 105, 34, 9, 56] pairs = [(x % 10, x) for x in numbers] sorted_pairs = sorted(pairs) sorted_numbers = [x[1] for x in sorted_pairs] print(sorted_numbers)

Output: `[12, 105, 56, 34, 9]`

The code snippet creates a list of tuples, with each tuple containing the units digit and the original number. After sorting these pairs by the first element (the units digit), it extracts the second element of each tuple to obtain the sorted list.

## Bonus One-Liner Method 5: Using Sorted with key and Map

The fifth method is a concise one-liner that leverages the `sorted()`

function with a key that applies a map to transform each number to its units digit.

Here’s an example:

numbers = [12, 105, 34, 9, 56] print(sorted(numbers, key=lambda x: map(int, str(x)[-1])))

Output: `[12, 105, 56, 34, 9]`

This one-liner involves converting each number to a string, slicing to get the last character, transforming it back to an integer, and providing this as a key for sorting.

## Summary/Discussion

**Method 1:**Custom Key Function. Strengths: Simple and straightforward. Weaknesses: May not be immediately clear to beginners.**Method 2:**Operator Module. Strengths: Demonstrates the use of Python’s standard library modules. Weaknesses: Overcomplication for a simple task.**Method 3:**In-Place Sorting. Strengths: Directly modifies the original list, which is memory efficient. Weaknesses: Not suitable if the original order needs to be preserved.**Method 4:**Comprehensive Sorting. Strengths: Creates a clear sorting structure with pairs. Weaknesses: Requires additional space and steps.**Bonus Method 5:**Sorted with Map. Strengths: Very concise. Weaknesses: The combination of`map()`

with`sorted()`

may not be easy to read.