Python – Sort Tuples by Total digits

Given a Tuple List, perform sort on basis of total digits in tuple.

Examples:

Input : test_list = [(3, 4, 6, 723), (1, 2), (134, 234, 34)] 
Output : [(1, 2), (3, 4, 6, 723), (134, 234, 34)] 
Explanation : 2 < 6 < 8, sorted by increasing total digits.

Input : test_list = [(1, 2), (134, 234, 34)] 
Output : [(1, 2), (134, 234, 34)] 
Explanation : 2 < 8, sorted by increasing total digits. 

Method #1: Using sort() + len() + sum()

In this, we get all sum of all lengths of each element in the tuple by string conversion and len(). Then sort() is used with key to solve this problem.

Python3

# Python3 code to demonstrate working of
# Sort Tuples by Total digits
# Using sort() + len() + sum()

def count_digs(tup):

    # gets total digits in tuples
    return sum([len(str(ele)) for ele in tup ])

# initializing list
test_list = [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]

# printing original list
print("The original list is : " + str(test_list))

# performing sort
test_list.sort(key = count_digs)

# printing result
print("Sorted tuples : " + str(test_list))

Output

The original list is : [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]
Sorted tuples : [(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]

Time Complexity: O(nlogn)
Auxiliary Space: O(1)

Method #2 : Using sorted() + lambda + sum() + len()

In this, we perform task of sorting using sorted(), and the lambda function performs the task of computation of total digits in tuples.

Python3

# Python3 code to demonstrate working of
# Sort Tuples by Total digits
# Using sorted() + lambda + sum() + len()

# initializing list
test_list = [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]

# printing original list
print("The original list is : " + str(test_list))

# performing sort, lambda function provides logic
res = sorted(test_list, key = lambda tup : sum([len(str(ele)) for ele in tup ]))

# printing result
print("Sorted tuples : " + str(res))

Output

The original list is : [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]
Sorted tuples : [(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]

Time Complexity: O(n*logn) where n is the number of elements in the list “test_list”. sorted() + lambda + sum() + len() performs n*logn number of operations.
Auxiliary Space: O(n), extra space is required where n is the number of elements in the list 

Method #3: Using reduce:

1. Initialize the list of tuples.
2. Print the original list.
3. Apply the sorted() function on the list of tuples with a key function lambda to sort the tuples based on the sum of the total number of digits in the tuples.
4. The key function lambda takes each tuple as an input and calculates the length of each element after converting it to a string using len(str(ele)). The lengths are summed up using the built-in sum() function to get the total number of digits in the tuple.
5. The sorted tuples are stored in the variable res.
6. Print the sorted tuples.

Python3

from functools import reduce

# initializing list
test_list = [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]

# printing original list
print("The original list is : " + str(test_list))

# performing sort, reduce function provides logic to count total digits in each tuple
res = sorted(test_list, key=lambda tup: reduce(lambda x, y: x + len(str(y)), tup, 0))

# printing result
print("Sorted tuples : " + str(res))
#This code is contributed by Jyothi pinjala,

Output

The original list is : [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]
Sorted tuples : [(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]

Time complexity: O(nlogn), where n is the length of the list of tuples. The time complexity of the sorted() function is O(nlogn) due to its underlying sorting algorithm.

Space complexity: O(n), where n is the length of the list of tuples. The space complexity is determined by the size of the list of tuples.

METHOD 4:Using def and for function

APPROACH:

This program takes a list of tuples as input and sorts the tuples based on the total digits present in each tuple. The tuples with fewer total digits are placed first in the output list, while those with more total digits are placed later.

ALGORITHM:

1.Define a function count_digits(t) to count the total number of digits in a tuple t.
2.Create a list tuples_with_counts of tuples, where each tuple contains an original tuple and its corresponding total digit count (calculated using the count_digits() function).
3.Sort the tuples_with_counts list based on the second element of each tuple (i.e., the total digit count), using the sorted() function and a lambda function as the key.
4.Create a list sorted_tuples by taking the first element (i.e., the original tuple) from each tuple in the sorted tuples_with_counts list.
5.Output the sorted_tuples list.

Python3

# Input list of tuples
lst = [(3, 4, 6, 723), (1, 2), (12345,), (134, 234, 34)]

# Define a function to calculate the total digits in a tuple
def count_digits(t):
    total = 0
    for num in t:
        total += len(str(num))
    return total

# Create a list of tuples with their corresponding total digit counts
tuples_with_counts = [(t, count_digits(t)) for t in lst]

# Sort the list of tuples based on their corresponding total digit counts
sorted_tuples = [t[0] for t in sorted(tuples_with_counts, key=lambda x: x[1])]

# Output the sorted list of tuples
print("Sorted tuples:", sorted_tuples)

Output

Sorted tuples: [(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]

Time complexity: The time complexity of this algorithm is O(nklog(n)), where n is the number of tuples in the input list, and k is the maximum length of a tuple.

Space complexity: The space complexity of this algorithm is O(n*k), where n is the number of tuples in the input list, and k is the maximum length of a tuple. This is because we create a new list tuples_with_counts that is the same size as the input list, and each tuple in tuples_with_counts has an additional integer element to store the total digit count.