Sometimes, while working with Python Lists, we can have a problem in which we receive Strings as elements and wish to compute the String which has maximum length. This kind of problem can have applications in many domains. Let’s discuss certain ways in which this problem can be solved.
Method #1 : Using loop This is the brute method in which we perform this task. In this, we run a loop to keep a memory of longest string length and return the string which has max length in list.
Python3
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
print("The original list : " + str(test_list))
max_len = -1
for ele in test_list:
if len(ele) > max_len:
max_len = len(ele)
res = ele
print("Maximum length string is : " + res)
|
Output : The original list : ['gfg', 'is', 'best', 'for', 'geeks']
Maximum length string is : geeks
Time Complexity: O(n)
Auxiliary Space: O(1)
Method #2 : Using max() + key This method can also be used to solve this problem. In this, we use inbuilt max() with “len” as key argument to extract the string with the maximum length.
Python3
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
print("The original list : " + str(test_list))
res = max(test_list, key = len)
print("Maximum length string is : " + res)
|
Output : The original list : ['gfg', 'is', 'best', 'for', 'geeks']
Maximum length string is : geeks
Time Complexity: O(n) where n is the number of elements in the string list. The max() + key is used to perform the task and it takes O(n) time.
Auxiliary Space: O(1) constant additional space is created.
Method #3 : Using reduce() + lambda
In this method, we use the reduce() function from the functools module, and pass a lambda function as the first argument, which compares the length of the current and next elements and returns the element with the maximum length.
Python3
from functools import reduce
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
print("The original list : " + str(test_list))
res = reduce(lambda x, y: x if len(x) > len(y) else y, test_list)
print("Maximum length string is : " + res)
|
OutputThe original list : ['gfg', 'is', 'best', 'for', 'geeks']
Maximum length string is : geeks
Time Complexity: O(n) where n is the number of elements in the list
Auxiliary Space: O(1) as it uses only a single variable to store the result.
Method #4: Using recursive function.
This method can also be used to solve this problem. In this, we use recursive function to extract the string with the maximum length.
Python3
def find_maximum(lst,start=0,max_word=''):
if start==len(lst):
return max_word
if len(lst[start])>len(max_word):
max_word=lst[start]
return find_maximum(lst,start+1,max_word)
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
print("The original list : " + str(test_list))
res = find_maximum(test_list)
print("Maximum length string is : " + res)
|
OutputThe original list : ['gfg', 'is', 'best', 'for', 'geeks']
Maximum length string is : geeks
Time Complexity: O(n)
Auxiliary Space: O(n)
Method #4:Using a list comprehension
step-by-step algorithm for implementing the approach:
Initialize the list of strings.
Use a list comprehension to create a new list of string lengths. This iterates through each string in the original list and applies the len() function to get the length of each string.
Use the index() method on the lengths list to find the index of the longest string. The max() function returns the largest length, and the index() method returns the index of the first occurrence of that length.
Use the index of the longest string to retrieve the string from the original list.
Print the longest string.
Python3
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
lengths = [len(s) for s in test_list]
longest_index = lengths.index(max(lengths))
longest_string = test_list[longest_index]
print("Longest string is : " + longest_string)
|
OutputLongest string is : geeks
time complexity: O(n), where n is the length of the test_list.
auxiliary space complexity: O(n), because we create a new list to store the lengths of each string in the test_list. However, since the lengths list is only used to find the maximum length and then discarded, the space complexity is effectively O(1) in practice.
Method #4:Using the heapq module :
Algorithm:
1.Initialize a list test_list with strings.
2.Use the heapq.nlargest() function to get the index of the largest element in the list based on the length of each string.
3.Use the index obtained in step 2 to get the corresponding string from the test_list.
4.Print the longest string.
Python3
import heapq
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
index = heapq.nlargest(1, range(len(test_list)), key=lambda x: len(test_list[x]))[0]
longest_string = test_list[index]
print("Longest string is: " + longest_string)
|
OutputLongest string is: geeks
Time Complexity:
The time complexity of this algorithm is O(n log k), where n is the length of the list and k is the number of elements to be returned. In this case, we are only returning the single longest string, so k = 1, and the time complexity simplifies to O(n log 1) = O(n). This is because the heapq.nlargest() function has a time complexity of O(n log k) to find the k largest elements.
Space Complexity:
The space complexity of this algorithm is O(1), as we are only using a few variables to store the list of strings, the index of the largest string, and the longest string itself. We are not using any additional data structures that depend on the input size.
Method #7: Using a sorted() function with a custom key
- Initialize the list
- Sort the list in descending order based on the length of each string
- The first element in the sorted list will be the longest string
- Print the result
Python3
test_list = ['gfg', 'is', 'best', 'for', 'geeks']
print("The original list: " + str(test_list))
res = sorted(test_list, key=len, reverse=True)[0]
print("Maximum length string is: " + res)
|
OutputThe original list: ['gfg', 'is', 'best', 'for', 'geeks']
Maximum length string is: geeks
Time complexity: O(n log n) – sorting the list takes O(n log n) time in the worst case.
Auxiliary space: O(n) – we need to create a sorted copy of the list.