有没有一种方法可以有效地迭代Python中的“嵌套”组合？

Question

I am unsure how to define the problem I wish to solve, but from a combinations of numbers, eg:

(4, 3, 2)

I wish to make an iterator that goes over all 'nested' combinations of these numbers. What I mean by this is that it iterates over:

(0, 0, 0), (0, 1, 0), (0, 2, 0), (0, 3, 0), (0, 1, 1), (0, 1, 2), (0, 2, 1), (0, 2, 2), ...

(1, 0, 0), (1, 1, 0), (1, 2, 0), (1, 3, 0), (1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), ...

...

(4, 0, 0), (4, 1, 0), (4, 2, 0), (4, 3, 0), (4, 1, 1), (4, 1, 2), (4, 2, 1), (4, 2, 2), ...

Preferably it could also be constrained by a maximum sum capacity during the generation of combinations (ie sum(combination) < capacity).

I have created a recursive algorithm that generates these combinations, but it is very slow and hope there is a more efficient method.

import numpy as np 

def combinations(current, c, c_set):
    c_rec = c.copy()
    if(current == 0):
        while(c_rec[current] + 1 <= numbers[current] and c_rec[current] + 1 < capacity):
            c_rec[current] += 1
            c_set.append(c_rec.copy())

    while(c_rec[current] + 1 <= numbers[current] and c_rec[current] + 1 < capacity):
        c_rec[current] += 1
        combinations(current - 1, c_rec, c_set)
        c_set.append(c_rec)

numbers = (4,3,2)
n = len(numbers)
capacity = 7
c_init = np.zeros(n)
c_set = [c_init]            
combinations(n - 1, c_init, c_set)

Answer 1

You can make use of itertools.product for this

from itertools import product

li = [4, 3, 2]

#Create a list of ranges
res = [range(item+1) for item in li]
#[range(0, 5), range(0, 4), range(0, 3)]

#Calculate cartesian product between elements of each list
prod = product(*res)

#Iterate over the elements
for item in prod:
    print(item)

The output will be

(0, 0, 0)
(0, 0, 1)
(0, 0, 2)
(0, 1, 0)
(0, 1, 1)
...
(1, 0, 0)
(1, 0, 1)
(1, 0, 2)
(1, 1, 0)
(1, 1, 1)
...
(2, 0, 0)
(2, 0, 1)
(2, 0, 2)
(2, 1, 0)
(2, 1, 1)
.....
(3, 0, 0)
(3, 0, 1)
(3, 0, 2)
(3, 1, 0)
(3, 1, 1)
.....

Answer 2

I might not have fully understood your question, but wouldn't a simple nested for-loop structure solve your problem?

for x in range(4):
    for y in range(3):
        for z in range(2):
            print((x, y, z))

Answer 3

You can use recursion with a generator:

start = (4, 3, 2)
def groups(d):
  yield d
  for i, [a, b] in enumerate(zip(d, start)):
    if a < b:
      yield from groups(tuple([*d[:i], d[i]+1, *d[i+1:]]))

result = set(groups((0, 0, 0)))

Output:

[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 2, 0), (0, 2, 1), (0, 2, 2), (0, 3, 0), (0, 3, 1), (0, 3, 2), (1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 1, 0), (1, 1, 1), (1, 1, 2), (1, 2, 0), (1, 2, 1), (1, 2, 2), (1, 3, 0), (1, 3, 1), (1, 3, 2), (2, 0, 0), (2, 0, 1), (2, 0, 2), (2, 1, 0), (2, 1, 1), (2, 1, 2), (2, 2, 0), (2, 2, 1), (2, 2, 2), (2, 3, 0), (2, 3, 1), (2, 3, 2), (3, 0, 0), (3, 0, 1), (3, 0, 2), (3, 1, 0), (3, 1, 1), (3, 1, 2), (3, 2, 0), (3, 2, 1), (3, 2, 2), (3, 3, 0), (3, 3, 1), (3, 3, 2), (4, 0, 0), (4, 0, 1), (4, 0, 2), (4, 1, 0), (4, 1, 1), (4, 1, 2), (4, 2, 0), (4, 2, 1), (4, 2, 2), (4, 3, 0), (4, 3, 1), (4, 3, 2)]