Given a Tuple list, filter tuples that contain all uppercase characters.
Input : test_list = [(“GFG”, “IS”, “BEST”), (“GFg”, “AVERAGE”), (“GfG”, ), (“Gfg”, “CS”)]
Output : [(‘GFG’, ‘IS’, ‘BEST’)]
Explanation : Only 1 tuple has all uppercase Strings.
Input : test_list = [(“GFG”, “iS”, “BEST”), (“GFg”, “AVERAGE”), (“GfG”, ), (“Gfg”, “CS”)]
Output : []
Explanation : No has all uppercase Strings.
Method #1: Using loop
In this, we iterate for each tuple and check if every string is uppercase, if no, that tuple is omitted from new tuple.
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"),
("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res_list = []
for sub in test_list:
res = True
for ele in sub:
if not ele.isupper():
res = False
break
if res:
res_list.append(sub)
print("Filtered Tuples : " + str(res_list))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG', ), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG', )]
Time complexity: O(n^2), where n is the total number of elements in the test_list.
Auxiliary space: O(n), where n is the total number of elements in the res_list.
Method #2 : Using list comprehension + all() + isupper()
In this, we check for all strings uppercase using all(), and list comprehension provide a compact solution to a problem. isupper() is used to check for uppercase.
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"), ("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res = [sub for sub in test_list if all(ele.isupper() for ele in sub)]
print("Filtered Tuples : " + str(res))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG', ), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG', )]
Time Complexity: O(n * m), where n is the number of tuples and m is the average length of each tuple.
Auxiliary Space: O(k), where k is the number of tuples that satisfy the condition.
Method #3 : Using ord() function
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"),
("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
def fun(s):
c = 0
for i in s:
if(ord(i) in range(65, 91)):
c += 1
if(c == len(s)):
return True
return False
nl = []
for i in range(0, len(test_list)):
x = "".join(test_list[i])
if(fun(x)):
nl.append(test_list[i])
print("Filtered Tuples : " + str(nl))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time complexity: O(n*m), where n is the length of the test_list and m is the length of the longest string in the list.
Auxiliary space: O(k), where k is the number of tuples that satisfy the condition in the fun() function.
Method #4 : Using join() and replace() methods
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"), ("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res=[]
upperalphabets="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in test_list:
x="".join(i)
for j in upperalphabets:
x=x.replace(j,"")
if(len(x)==0):
res.append(i)
print("Filtered Tuples : " + str(res))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time complexity: O(n*m), where n is the length of the input list and m is the length of the longest string in the list.
Auxiliary space: O(k), where k is the number of tuples that satisfy the condition.
Method #5 : Using join()+isupper() methods
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"),
("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res_list = []
for sub in test_list:
x="".join(sub)
if x.isupper():
res_list.append(sub)
print("Filtered Tuples : " + str(res_list))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time Complexity: O(M * N), where M and N are the length of the list and the maximum size of each tuple respectively.
Auxiliary Space: O(N*K), where K is the maximum size of words in tuples.
Method #6: Using filter()+lambda() methods
This method uses the filter() function to filter the list of tuples and a lambda function to check if all elements in a tuple are uppercase.
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"),
("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res = list(filter(lambda x: all(ele.isupper() for ele in x), test_list))
print("Filtered Tuples : " + str(res))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time complexity: O(n * m), where n is the number of tuples in the list and m is the maximum length of a tuple
Auxiliary space: O(k), where k is the number of tuples that satisfy the filter condition.
Method #7: Using itertools.filterfalse() method
Python3
import itertools
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"),
("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res = list(itertools.filterfalse(lambda x: not all(ele.isupper() for ele in x), test_list))
print("Filtered Tuples : " + str(res))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time Complexity:O(N*N)
Auxiliary Space:O(N*N)
Method #8: Using map() and all() methods
Use the map() function to apply the isupper() method to each element of the sub-tuple, and then use the all() function to check if all elements in the sub-tuple are uppercase.
Python3
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"), ("GFG", ), ("Gfg", "CS")]
res_list = list(filter(lambda x: all(map(str.isupper, x)), test_list))
print("Filtered Tuples : " + str(res_list))
|
Output
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time complexity: O(nm), where n is the length of the input list and m is the maximum number of elements in a sub-tuple.
Auxiliary space: O(k), where k is the number of sub-tuples that satisfy the condition of having all elements in uppercase. This is because we create a new list to store the filtered sub-tuples.
Method #9: Using a list comprehension and the regex module:
Algorithm:
1.Initialize an empty list to store filtered tuples.
2.For each tuple in the input list:
a. Initialize a boolean variable is_uppercase to True.
b. For each string in the tuple:
i. Check if the string is uppercase by calling the isupper() method.
ii. If the string is not uppercase, set is_uppercase to False and break out of the inner loop.
c. If is_uppercase is still True after checking all the strings in the tuple, append the tuple to the filtered list.
3.Return the filtered list.
Python3
import re
test_list = [("GFG", "IS", "BEST"), ("GFg", "AVERAGE"), ("GFG", ), ("Gfg", "CS")]
print("The original list is : " + str(test_list))
res = [tup for tup in test_list if all(re.match('^[A-Z]+$', word) for word in tup)]
print("Filtered Tuples : " + str(res))
|
Output
The original list is : [('GFG', 'IS', 'BEST'), ('GFg', 'AVERAGE'), ('GFG',), ('Gfg', 'CS')]
Filtered Tuples : [('GFG', 'IS', 'BEST'), ('GFG',)]
Time Complexity:
The algorithm uses nested loops to iterate over the input list and each string in the tuples. The time complexity of the algorithm is O(nmk), where n is the number of tuples in the input list, m is the maximum number of strings in a tuple, and k is the maximum length of a string in the tuple. In the worst case, all tuples have m strings of length k that need to be checked, resulting in a time complexity of O(nmk).
Space Complexity:
The algorithm uses a filtered list to store the tuples containing only uppercase characters. The space complexity of the algorithm is O(pm), where p is the number of tuples in the filtered list and m is the maximum number of strings in a tuple. In the worst case, all tuples in the input list contain only uppercase characters, resulting in a filtered list of size n and a space complexity of O(nm).
Please Login to comment...