We are given a list, the task is to convert the list into tuple of lists.
Input: ['Geeks', 'For', 'geeks'] Output: (['Geeks'], ['For'], ['geeks'])
Input: ['first', 'second', 'third'] Output: (['first'], ['second'], ['third'])
Method #1: Using Comprehension
# Python code to convert a list into tuple of lists # Initialisation of list Input = [ 'Geeks' , 'for' , 'geeks' ]
# Using list Comprehension Output = tuple ([name] for name in Input )
# printing output print (Output)
|
(['Geeks'], ['for'], ['geeks'])
Time Complexity: O(n), where n is the length of the Input list.
Auxiliary Space: O(n), as we are creating a new tuple of lists of the same length as Input.
Method #2 : Using Map + Lambda
# Python code to convert a list into tuple of lists # Initialisation of list Input = [ 'first' , 'second' , 'third' ]
# Using map + lambda Output = tuple ( map ( lambda x: [x], Input ))
# printing output print (Output)
|
(['first'], ['second'], ['third'])
Time complexity: O(n), where n is the length of the input list.
Auxiliary space: O(n), where n is the length of the input list.
Method #3 : Using Map + zip
# Python code to convert a list into tuple of lists # Initialisation of list Input = [ 'first' , 'second' , 'third' ]
# Using Map + zip Output = tuple ( map ( list , zip ( Input )))
# printing output print (Output)
|
(['first'], ['second'], ['third'])
Time complexity: O(n), where n is the length of the input list ‘Input’.
Auxiliary space: O(n), where n is the length of the input list ‘Input’.
Method #4: Using enumerate function
lst = [ 'Geeks' , 'for' , 'geeks' ]
x = tuple ([i] for a,i in enumerate (lst))
print (x)
|
(['Geeks'], ['for'], ['geeks'])
Time Complexity: O(n), where n is the length of the list
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the list
Method#5: Using Recursive method.
Algorithm:
- Define a recursive function list_to_tuple_of_lists which takes a list lst as an input.
- If the list is empty, return an empty tuple.
- Otherwise, take the first element of the list and wrap it in a list.
- Wrap that list in a tuple, and concatenate the tuple with the result of recursively calling list_to_tuple_of_lists on the rest of the list.
- Return the resulting tuple.
def list_to_tuple_of_lists(lst):
if not lst:
return ()
else :
return ([lst[ 0 ]],) + list_to_tuple_of_lists(lst[ 1 :])
# example usage input_list = [ 'Geeks' , 'for' , 'geeks' ]
output_tuple = list_to_tuple_of_lists(input_list)
print (output_tuple) # output: (['Geeks'], ['for'], ['geeks'])
|
(['Geeks'], ['for'], ['geeks'])
Time Complexity:
The time complexity of the list_to_tuple_of_lists function is O(n), where n is the length of the input list. This is because the function makes a recursive call on a list of length n-1, and performs constant time operations (creating a list and wrapping it in a tuple) for each element of the list.
Auxiliary Space:
The space complexity of the list_to_tuple_of_lists function is also O(n), where n is the length of the input list. This is because the function creates a new list of length 1 for each element of the input list, and the maximum depth of the recursion is also n.
Method #6: Using a For Loop
Step-by-step approach:
- Initialize an empty list result to store the output.
- Use a for loop to iterate over each element of the input list.
- Append each element as a single-element list to the result list.
- Convert the result list to a tuple using the tuple() function.
- Assign the tuple to the output variable.
- Print the output variable.
# Python code to convert a list into tuple of lists # Initialization of list input_list = [ 'Geeks' , 'for' , 'geeks' ]
# Using a for loop result = []
for name in input_list:
result.append([name])
# Convert result list to tuple output = tuple (result)
# Print output print (output)
|
(['Geeks'], ['for'], ['geeks'])
Time complexity: O(n), where n is the number of elements in the input list, because we iterate over each element of the list once.
Auxiliary space: O(n), where n is the number of elements in the input list, because we create a list of n lists to store the output before converting it to a tuple.