Python get all combinations of length n

In case you don't want to calculate all the combinations at once, you can make a generator that returns the combinations of length n as follows:

def combinations(list_get_comb, length_combination):
    """ Generator to get all the combinations of some length of the elements of a list.

    :param list_get_comb: List from which it is wanted to get the combination of its elements.
    :param length_combination: Length of the combinations of the elements of list_get_comb.
    :return: Generator with the combinations of this list.
    """

    # Generator to get the combinations of the indices of the list
    def get_indices_combinations(sub_list_indices, max_index):
        """ Generator that returns the combinations of the indices

        :param sub_list_indices: Sub-list from which to generate ALL the possible combinations.
        :param max_index: Maximum index.
        :return:
        """
        if len(sub_list_indices) == 1:  # Last index of the list of indices
            for index in range(sub_list_indices[0], max_index + 1):
                yield [index]
        elif all([sub_list_indices[-i - 1] == max_index - i for i in
                  range(len(sub_list_indices))]):  # The current sublist has reached the end
            yield sub_list_indices
        else:
            for comb in get_indices_combinations(sub_list_indices[1:],
                                                 max_index):  # Get all the possible combinations of the sublist sub_list_indices[1:]
                yield [sub_list_indices[0]] + comb
            # Advance one position and check all possible combinations
            new_sub_list = []
            new_sub_list.extend([sub_list_indices[0] + i + 1 for i in range(len(sub_list_indices))])
            for new_comb in get_indices_combinations(new_sub_list, max_index):
                yield new_comb  # Return all the possible combinations of the new list

    # Start the algorithm:
    sub_list_indices = list(range(length_combination))
    for list_indices in get_indices_combinations(sub_list_indices, len(list_get_comb) - 1):
        yield [list_get_comb[i] for i in list_indices]

By calling:

comb = combinations([1, 2, 3, 4], 3) 

You can calculate one by one each of the possible combinations of length 3 by calling next(comb) or by using the generator in a loop: for c in comb:.

The advantage of this code is that, in case the list is very long, there are many possible combinations and you want to get one of all the possible combinations that meets some criteria, you wouldn't need to calculate all the possible combinations and then filter them by that criteria. You can just generate them one by one until you find a combination that meets your criteria. This will be computationaly much more efficient. As well, note that the above code calculates only those combinations of length n, instead of calculating all the possible combinations and then filtering them by length, which makes it more efficient as well.

However, if wanted, you can calculate all the combinations at once by listing them list(comb).

Listing all combinations of a list up to length n (Python)

Tags: python , list Answers: 1 | Viewed 5,446 times

What would be an efficient algorithm to do the following:
given a list, we have to output all combinations of elements up to a length n. Let's say x = ['a','b','c','d','e'] and n = 2. The output should be:

[['a'], ['b'], ['c'], ['d'], ['e'], ['a', 'b'], ['a', 'c'], ['a', 'd'], ['a', 'e'], ['b', 'c'], ['b', 'd'], ['b', 'e'], ['c', 'd'], ['c', 'e'], ['d', 'e']]
 

Stefano Sanfilippo answer at 2014-07-26 10

You could use itertools.combinations and iterate for increasing lengths:

from itertools import combinations
 x = ['a','b','c','d','e']
 c = []
 n = 2
 for i in range(n):
     c.extend(combinations(x, i + 1))
 print(c)
 

or, using a list comprehension:

from itertools import combinations
 x = ['a','b','c','d','e']
 n = 2
 c = [comb for i in range(n) for comb in combinations(x, i + 1)]
 print(c)
 

* The answers/resolutions are collected from stackoverflow, are licensed under CC BY-SA 3.0

[['a'], ['b'], ['c'], ['d'], ['e'], ['a', 'b'], ['a', 'c'], ['a', 'd'], ['a', 'e'], ['b', 'c'], ['b', 'd'], ['b', 'e'], ['c', 'd'], ['c', 'e'], ['d', 'e']] 

from itertools import combinations  x = ['a','b','c','d','e'] c = [] n = 2  for i in range(n):
c.extend(combinations(x, i + 1))  print(c) 

from itertools import combinations  x = ['a','b','c','d','e'] n = 2 c = [comb for i in range(n) for comb in combinations(x, i + 1)] print(c) 

x = ['a', 'b', 'c', 'd', 'e'] result = []  for length in range(1,3):
result.extend(itertools.combinations(x, length))  print result 

[('a',), ('b',), ('c',), ('d',), ('e',), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('a', 'e'), ('b', 'c'), ('b', 'd'), ('b', 'e'), ('c', 'd'), ('c', 'e'), ('d', 'e')] 

>>>
x = ['a','b','c','d','e'] >>>
n = 2 >>>
import itertools >>>
[list(comb) for i in range(1, n+1) for comb in itertools.combinations(x, i)] [['a'], ['b'], ['c'], ['d'], ['e'],  ['a', 'b'], ['a', 'c'], ['a', 'd'], ['a', 'e'],  ['b', 'c'], ['b', 'd'], ['b', 'e'],  ['c', 'd'], ['c', 'e'], ['d', 'e']] 

x = ['a','b','c','d','e'] n = 2  outList = [] for i in range(0,len(x)):
outEleList = []
outEleList.append(x[i])
outList.append(outEleList)
for c in range(i,len(x)):
  out = []
  out.append(x[i])
  out.append(x[c])
  outList.append(out)  print outList 

How do you get all the combinations of n numbers in Python?

How do you get all the possible combinations of letters in python?

How do you generate all possible combinations of one list?

How do you generate all possible combinations of two lists in Python?