Python | Program to count number of lists in a list of lists

Given a list of lists, write a Python program to count the number of lists contained within the list of lists. 

Examples:

Input :  [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
Output : 3
 
Input : [[1], ['Bob'], ['Delhi'], ['x', 'y']]
Output : 4

Method #1 : Using len() 

3

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

Method #2: Using type() 

Use a for loop and in every iteration to check if the type of the current item is a list or not, and accordingly increment ‘count’ variable. This method has a benefit over approach #1, as it works well for a list of heterogeneous elements. 

3

Time complexity: O(n), where n is the number of elements in the list.
Auxiliary space: O(1), as we are only using a single variable (count) to store the count of lists.

A one-liner alternative approach for the above code is given below: 

Method #3 : Using isinstance() method 

3

Time complexity: O(n), where n is the size of the set s.
Auxiliary space: O(n), as we are creating a list x with n elements, where n is the size of the set s.

Method#4: Using the list comprehension

3

Time complexity: O(n), where n is the total number of elements in the list of lists.
Auxiliary space: O(n)

Method #5: Using enumerate function 

3

Time complexity: O(n), where n is length of list.
Auxiliary Space: O(n), where n is length of list.

Method #6: Using lambda function

3

The time complexity of this code is O(n*m), where n is the number of sublists in the list and m is the average length of the sublists.

The auxiliary space required by this code is also O(n*m), since the filter function creates a new list that contains the same elements as the original list.

Method #7: Using map()

3

Method #8: Using eval() 

3

Method #9 : Using recursion

This approach involves reducing the length of the list by 1 at each recursive step and increasing the count by 1 if the first element of the list is a list. The function returns 0 when the list is empty.

3

Time complexity: O(n), where n is the total number of elements in the list of lists. This is because the function processes each element of the list exactly once.
Auxiliary space: O(n) as well, since the maximum depth of the recursion tree is n in the worst case. For example, if the list of lists is a list of n single-element lists, the recursion tree will have a maximum depth of n. At each level of the tree, a new frame is added to the call stack, which takes up space in memory.

Method #10: Using ast.literal_eval()

Step-by-step approach:

• Import the ast module.
• Define the list of strings, lst.
• Create an empty list, num_list, to store the converted lists.
• Loop through each string in lst.
• Use ast.literal_eval() to convert the string to a list.
• Append the resulting list to num_list.
• Calculate the length of num_list using len().
• Print the length of num_list.

3

Time complexity: O(n), where n is the length of lst. This is because we loop through each string in lst and apply ast.literal_eval() once for each string.
Auxiliary space: O(n), where n is the length of lst. This is because we create a list of the converted lists, which takes up space in memory.

Method #11: Using functools.reduce()

Step-by-step approach:

• Initialize a list of lists. 
• Use reduce method on the list. 
• reduce method takes a function, list, and initial value as parameters. 
• reduce iterate over each item of the list and apply a function to it and return value.
• Function checks are an item an instance of the list or not, if it is then count 1 to the initial value else do nothing. 

3

Time complexity: O(N), where N is the length of the list. 
Auxiliary space: O(1), No extra space is used.