Open In App
Related Articles

Python Program to Find Largest Item in a Tuple

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given a tuple, the task is to write a Python program to find the greatest number in a Tuple.

Example:

Input: (10,20,23,5,2,90) #tuple
Output: 90
Explanation: 90 is the largest element from tuple

Values of a tuple are syntactically separated by ‘commas’. Although it is not necessary, it is more common to define a tuple by closing the sequence of values in parentheses. This helps in understanding the Python tuples more easily.

Python program to demonstrate the maximum element in a Tuple.

Method 1: Using the max() method

We can use Python built-in max() Method to find the maximum element in a tuple.

Python3

print("Enter number separated by comma:")
t1 = tuple([int(e) for e in input().split(',')])
print("Greatest number in the tuple is:", max(t1))

                    

Output:

Enter number separated by comma:
10,20,23,5,2,80
Greatest number in the tuple is: 80

Time complexity: O(n) where n is the number of elements in the tuple. This is because the max() function has a linear time complexity of O(n) and the tuple creation using a list comprehension also has a time complexity of O(n).
Auxiliary space: O(n), where n is the number of elements in the tuple. 

Method 2: Using for-loop

Here we iterate on the for-loop and compare each element to find the maximum element in the tuple.

Python3

t = (25, 17, 55, 63, 40)
 
max_val = t[0]
 
for i in range(len(t)):
    if t[i] > max_val:
        max_val = t[i]
 
print("Maximum value is:", max_val)

                    

Output
Maximum value is: 63

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

Method 3: Using Recursive Functions

Here, we have used a recursive function to find the maximum element in the tuple.

Python3

def tupleLargest(num_tuple, index=0, max_item=float("-inf")):
    # setting base condition for recursion
    if index == len(num_tuple):
        return max_item
       
    # getting item at current index
    current_item = num_tuple[index]
     
    # update if new greater value is found
    if current_item > max_item:
        max_item = current_item
         
    # recursive call with incremented index value
    return tupleLargest(num_tuple, index + 1, max_item)
 
 
if __name__ == '__main__':
    maxTuple = (11, 65, 54, 23, 76, 33, 82, 98)
    print("Tuple Items = ", maxTuple)
 
    largest_element = tupleLargest(maxTuple)
    print("Maximum Item in Tuple = ", largest_element)

                    

Output
Tuple Items =  (11, 65, 54, 23, 76, 33, 82, 98)
Maximum Item in Tuple =  98

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

One approach that is not mentioned in the given article is to use the Python reduce function from the functools module to find the maximum element in the tuple. The reduce function applies a given function to a sequence of elements, reducing the sequence to a single value.

Here is an example of how this could be implemented:

Python3

from functools import reduce
 
def find_max(t):
    return reduce(lambda x, y: x if x > y else y, t)
 
t = (25, 17, 55, 63, 40)
print(find_max(t))

                    

Output
63

Time complexity: O(n), where n is the length of the tuple,
Auxiliary space: O(1) because it does not create any additional data structures.

Method 4: Using sort() method

Python3

t = (25, 17, 55, 63, 40)
 
x=list(t)
x.sort(reverse=True)
max_val=x[0]
 
print("Maximum value is:", max_val)

                    

Output
Maximum value is: 63

Time complexity: O(nlogn), where n is the length of the tuple,
Auxiliary space: O(n) 

Method 5: Using enumerate() method

Python3

data=(10,21,3141,48,120,57#declaring tuple
max_value=data[0#assuming first value in tuple as maximum value
for i,j in enumerate(data):
  if j>max_value: #condition to find largest value
    max_value=#updating max_value
print("The largest value in tuple is :",max_value)

                    

Output
The largest value in tuple is : 3141

Time complexity: O(n), where n is the length of the tuple,
Auxiliary space: O(1) 

Method 6: Using heapq module: 

Python3

import heapq
 
maxTuple = (11, 65, 54, 23, 76, 33, 82, 98)
largest_element = heapq.nlargest(1, maxTuple)[0]
 
print("Tuple Items: ", maxTuple)
print("Maximum Item in Tuple: ", largest_element)
#This code is contributed by Jyothi pinjala

                    

Output
Tuple Items:  (11, 65, 54, 23, 76, 33, 82, 98)
Maximum Item in Tuple:  98

Time complexity: O(nlogk), where n is the size of the input tuple and k is the number of largest elements to be found (in this case, k=1). The nlargest function uses a heap to efficiently find the largest element, which takes O(logk) time for each element in the input tuple. Therefore, the total time complexity is O(nlogk).
Auxiliary Space: O(k), where k is the number of largest elements to be found. In this case, we only need to find the largest element (k=1), so the space complexity is O(1).



Last Updated : 27 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads