Discussion :

[Sisbai]

Bonjour

Je cherche à faire des boucles imbriquées à partir d'un tableau d'indices.
Un exemple vaut mieux qu'un long discours:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
ind = [2,2,3,6]
for i in range(1, ind[0]+1):
    for j in range(i, ind[1]+1):
        for k in range(j, ind[2]+1):
            for l in range(k, ind[3]+1):
                 ...

Le problème est que ind est de longueur variable. Il peut y avoir plus d'éléments.
Je ne trouve pas mon bonheur dans le module itertools (à cause des boucles qui démarre sur l'indice précédent et non à partir d'un nombre fixe).

Quelqu'un sait si je peux faire ce genre de boucles imbriquées sans savoir à l'avance le nombre imbrications ?

Merci d'avance

PS : Je peux faire ça avec des combinaisons et en éliminant les p-uplets qui ne correspondent pas. Mais c'est trop lent.

[Sisbai]

J'ai trouvé !
Je me suis inspiré de la doc de Python qui fournit ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
def combinations_with_replacement(iterable, r):
    # combinations_with_replacement('ABC', 2) → AA AB AC BB BC CC
 
    pool = tuple(iterable)
    n = len(pool)
    if not n and r:
        return
    indices = [0] * r
 
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != n - 1:
                break
        else:
            return
        indices[i:] = [indices[i] + 1] * (r - i)
        yield tuple(pool[i] for i in indices)

Ce qui m'a permet de faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
def mycombi(indices):
 
    n = len(indices)
    lt = [1]*n
 
    yield tuple(lt)
    while True:
        if lt == indices:
            return
 
        ind = n-1
        while lt[ind] == indices[ind]:
            ind -= 1
 
 
        lt[ind] += 1
        for j in range(ind+1,n):
            lt[j] = lt[ind]
 
        yield tuple(lt)

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
for c in mycombi([2,2,3,6]):
    print(c)

Qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
(1, 1, 1, 1)
(1, 1, 1, 2)
(1, 1, 1, 3)
(1, 1, 1, 4)
(1, 1, 1, 5)
(1, 1, 1, 6)
(1, 1, 2, 2)
(1, 1, 2, 3)
(1, 1, 2, 4)
(1, 1, 2, 5)
(1, 1, 2, 6)
(1, 1, 3, 3)
(1, 1, 3, 4)
(1, 1, 3, 5)
(1, 1, 3, 6)
(1, 2, 2, 2)
(1, 2, 2, 3)
(1, 2, 2, 4)
(1, 2, 2, 5)
(1, 2, 2, 6)
(1, 2, 3, 3)
(1, 2, 3, 4)
(1, 2, 3, 5)
(1, 2, 3, 6)
(2, 2, 2, 2)
(2, 2, 2, 3)
(2, 2, 2, 4)
(2, 2, 2, 5)
(2, 2, 2, 6)
(2, 2, 3, 3)
(2, 2, 3, 4)
(2, 2, 3, 5)
(2, 2, 3, 6)