 Open in App
Not now

# Print all sublists of a list in Python

• Difficulty Level : Easy
• Last Updated : 20 Feb, 2023

Given a list, print all the sublists of a list.
Examples:

```Input  : list = [1, 2, 3]
Output : [[], , [1, 2], [1, 2, 3], ,
[2, 3], ]

Input : [1, 2, 3, 4]
Output : [[], , [1, 2], [1, 2, 3], [1, 2, 3, 4],
, [2, 3], [2, 3, 4], , [3, 4], ]```

Approach#1:

The approach will be run two nested loops till the length of the given list. The outer loop i traverse from 0 to the length of the list and the inner loop goes from 0 to i. Need to add 1 to length because the range only goes from 0 to i-1. To get the subarray we can use slicing to get the subarray.

Step 1: Run a loop till length+1 of the given list.
Step 2: Run another loop from 0 to i.
Step 3: Slice the subarray from j to i.
Step 4: Append it to a another list to store it
Step 5: Print it at the end

Below is the Python implementation of the above approach:

## Python

 `# Python program to print all``# sublist from a given list` `# function to generate all the sub lists``def` `sub_lists (l):``    ``lists ``=` `[[]]``    ``for` `i ``in` `range``(``len``(l) ``+` `1``):``        ``for` `j ``in` `range``(i):``            ``lists.append(l[j: i])``    ``return` `lists` `# driver code``l1 ``=` `[``1``, ``2``, ``3``]``print``(sub_lists(l1))`

Output

`[[], , [1, 2], , [1, 2, 3], [2, 3], ]`

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

Approach#2:

The approach will use for loop and combinations function. For loop is used to iterate till the length of list which is helpful for generating a sub-list of variable ith length. With each iteration combinations function generate the possible combination of list with ith length.

## Python3

 `# Python program to print all``# sublist from a given list``from` `itertools ``import` `combinations` `# function to generate all the sub lists``def` `sub_lists (l):``    ``# initializing empty list``    ``comb ``=` `[]``    ` `    ``#Iterating till length of list``    ``for` `i ``in` `range``(``len``(l)``+``1``):``        ``# Generating sub list``        ``comb ``+``=` `[``list``(j) ``for` `j ``in` `combinations([``1``, ``2``, ``3``], i)]``    ``# Returning list``    ``return` `comb` `# driver code``#Initial list``l1 ``=` `[``1``, ``2``, ``3``]` `#Print initial list``print``(``"Initial list is : "` `+` `str``(l1))` `# Calling function to generate all sub lists``print``(``"All sub list is : "``+` `str``(sub_lists(l1)))`

Output

```Initial list is : [1, 2, 3]
All sub list is : [[], , , , [1, 2], [1, 3], [2, 3], [1, 2, 3]]```

Approach #3:

The recursive approach uses a base case of an empty list being returned and a recursive case of generating sublists, with and without the first element of the list.
The iteration creates a copy of all the sublists, and then appends each element of the list to each sublist to generate all the sublists.

## Python

 `def` `generateSublists(lst):``    ``# Base case``    ``if` `len``(lst) ``=``=` `0``:``        ``return` `[[]]` `    ``# Recursive case``    ``sublists ``=` `[]``    ``first_element ``=` `lst[``0``]``    ``rest_list ``=` `lst[``1``:]``    ``sublists_of_rest ``=` `generateSublists(rest_list)``    ``# Generate sublists including first element``    ``for` `sublist ``in` `sublists_of_rest:``        ``sublists.append([first_element] ``+` `sublist)``    ``# Generate sublists excluding first element``    ``sublists.extend(sublists_of_rest)` `    ``return` `sublists`  `# Driver code``l1 ``=` `[``1``, ``2``, ``3``]``print``(generateSublists(l1))`

Output

`[[1, 2, 3], [1, 2], [1, 3], , [2, 3], , , []]`

The time complexity of the above code is O(2^n), where n is the length of the input list. This is because at each recursive step, the list is divided into two sublists of equal size.
The Auxiliary Space is also O(2^n), since at each step the recursive call stack will contain a new sublist for each of the 2^n sublists generated.

My Personal Notes arrow_drop_up