Python | Merging duplicates to list of list

Sometimes, we need to perform the conventional task of grouping some like elements into a separate list and thus forming a list of lists. This can also help in counting and also get the sorted order of elements. Let’s discuss certain ways in which this can be done. 

Method #1: Using collections.Counter() This particular function can prove to be quite useful to perform this particular task as it counts the frequency of elements in the list and then we can pair them using the list comprehension. 

The original list : [1, 3, 4, 2, 1, 3, 4, 2, 3, 4, 1]
The elements after grouping are : [[1, 1, 1], [3, 3, 3], [4, 4, 4], [2, 2]]

Time complexity: O(n) where n is the number of elements in the list
Auxiliary space: O(n) where n is the number of unique elements in the list after grouping.

Method #2 : Using itertools.groupby() This problem can easily be solved by traditional group functionality that is offered by Python via group by function, which groups the like elements as suggested by the ame. 

The original list : [1, 3, 4, 2, 1, 3, 4, 2, 3, 4, 1]
The elements after grouping are : [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4]]

Time complexity: O(nlogn) .
Auxiliary space: O(n). 

Method #3 : Using count() and * operator

The original list : [1, 3, 4, 2, 1, 3, 4, 2, 3, 4, 1]
The elements after grouping are : [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4]]

Time complexity: O(n^2)
Auxiliary space: O(n) (for the resulting list)

Method #4 : Using set() and * operator

The given code initializes a list called test_list with a list of integers. It then creates a new list called result using a list comprehension and the count() method.

The list comprehension loops through the elements in set(test_list), which creates a new set object containing all the unique elements in test_list. For each element in this set, the count() method is called on test_list with the element as an argument. This returns the number of occurrences of the element in test_list. The element is then added to a new sublist, which is repeated the number of times it appears in test_list using the * operator. For example, if the element is 3 and it appears 3 times in test_list, the sublist would be [3, 3, 3].

The elements after grouping are : [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4]]

Time complexity: O(n), because the list comprehension and the count() method both loop through the entire list once. 
Auxiliary Space: O(n), because the result list will have a length equal to the number of unique elements in the list, and each element in the result list is a sublist containing at least one element.

Method 5:  using operator.countOf() method

The original list : [1, 3, 4, 2, 1, 3, 4, 2, 3, 4, 1]
The elements after grouping are : [[1, 1, 1], [2, 2], [3, 3, 3], [4, 4, 4]]

Time Complexity: O(N)
Auxiliary Space: O(N)

Method #6: Using a dictionary

Step-by-step approach:

• Initialize an empty dictionary.
• Loop through the elements of the given list.
• If the element is not already a key in the dictionary, add it with a value of an empty list.
• Append the element to the list associated with its key in the dictionary.
• Return a list of the values in the dictionary.

Below is the implementation of the above approach:

The original list : [1, 3, 4, 2, 1, 3, 4, 2, 3, 4, 1]
The elements after grouping are : [[1, 1, 1], [3, 3, 3], [4, 4, 4], [2, 2]]

Time complexity: O(n), where n is the length of the given list.
Auxiliary space: O(n), to store the dictionary.