Python – Elements frequency in Tuple

Given a Tuple, find the frequency of each element.

Input : test_tup = (4, 5, 4, 5, 6, 6, 5) 
Output : {4: 2, 5: 3, 6: 2} 
Explanation : Frequency of 4 is 2 and so on..

Input : test_tup = (4, 5, 4, 5, 6, 6, 6) 
Output : {4: 2, 5: 2, 6: 3} 
Explanation : Frequency of 4 is 2 and so on.. 

Method #1  Using defaultdict()

In this, we perform task of getting all elements and assigning frequency using defaultdict which maps each element with key and then frequency can be incremented.

The original tuple is : (4, 5, 4, 5, 6, 6, 5, 5, 4)
Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time complexity: O(n), where n is the length of the tuple test_tup. This is because the program iterates through the tuple once to increment the frequency of each element using a dictionary. The += operation and dictionary lookup both take constant time.
Auxiliary space: O(n), where n is the length of the tuple test_tup. This is because the program uses a dictionary to store the frequency of each element in the tuple, which can potentially have n unique elements.

Method #2 : Using Counter()

This is straight forward way to solve this problem. In this, we just employ this function and it returns frequency of elements in container, in this case tuple.

The original tuple is : (4, 5, 4, 5, 6, 6, 5, 5, 4)
Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time complexity: O(n), where n is the number of elements in the tuple.
Auxiliary space: O(n), as the Counter() method creates a dictionary that stores the frequency of each element in the tuple.

Method #3 : Using count() method.

The original tuple is : (4, 5, 4, 5, 6, 6, 5, 5, 4)
Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

The time complexity of this program is O(n^2) because of the nested loops used to count the frequency of each element. 

The auxiliary space complexity of this program is O(n) because the program uses two lists x and y to store the tuple elements and unique elements, respectively, and a dictionary res to store the frequency count of each element. 

Method #4 : Using operator.countOf() method.

The original tuple is : (4, 5, 4, 5, 6, 6, 5, 5, 4)
Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time Complexity: O(N), where n is the length of the given tuple
Auxiliary Space: O(n)

Method 5:dictionary and loop over the elements in the tuple to count their frequency. 

This code is designed to count the frequency of each element in the tuple test_tup. It does this by creating an empty dictionary freq_dict to store the counts, and then looping over each element of the tuple. For each element, it checks if that element is already a key in the dictionary freq_dict. If it is, it increments the value associated with that key (which represents the count of that element in the tuple). If it isn’t, it adds a new key to the dictionary with a value of 1. Once the loop has finished, the code prints out the resulting dictionary, which contains the counts for each unique element in the tuple.

Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time complexity: O(n), where n is the length of the tuple. 
Auxiliary space: O(k), where k is the number of unique elements in the tuple. 

Method 6: using the built-in function set()

Using the built-in function set() to create a set of unique elements in the tuple and then using a list comprehension to count the frequency of each unique element:

Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time complexity: O(n^2) due to the nested loop in the list comprehension, 
Auxiliary space: O(n) to store the dictionary. 

Method 7: Using reduce():

Algorithm:

1. Import the required modules.
2. Initialize a tuple with elements.
3. Apply reduce() function on the tuple with Counter() function and Counter() function as the initial value.
4. Print the result.

The original tuple is : (4, 5, 4, 5, 6, 6, 5, 5, 4)
Tuple elements frequency is : Counter({5: 4, 4: 3, 6: 2})

Time Complexity:
The time complexity of this code is O(nlogn) because sorting is required for tuples and dictionaries, and dictionaries are used by the Counter() function.

Auxiliary Space:
The space complexity of this code is O(n) because additional space is used to store the output.

Method 8: Using numpy:

1. Import the numpy module.
2. Initialize a tuple test_tup with some values.
3. Convert the tuple to a numpy array using np.array().
4. Use np.unique() function to get the unique elements in the numpy array and their corresponding counts using the return_counts=True parameter.
5. Use the zip() function to combine the two arrays into a dictionary, which is stored in the freq_dict variable.
   Print the dictionary freq_dict.

Output:
Tuple elements frequency is : {4: 3, 5: 4, 6: 2}

Time complexity: O(n log n).
Auxiliary Space: O(n)\

manjeet_04

Follow

Improve