Programme hermionne.py

def solution_correcte (sol) :
    """cette fonction recoit un tableau de 7 cases,
    chaque case contient un entier compris entre 0 et 3 inclus :
    0 : poison, 1 : vin, 2 : reculer, 3 : avancer
    la fonction determine si l'agencement propose dans sol
    verifie les cinq regles de l'enonce,
    retourne True si toutes les regles sont verifiees
    ou False si l'une des regles n'est pas verifiee,
    
    rappel : les indices vont de 0 a 6 inclus car il y a 7 cases"""
    
    # regle 1
    nb = [0,0,0,0]
    for s in sol : 
        nb [s] += 1
    if nb [0] != 3 : return False # 3 poison
    if nb [1] != 2 : return False # 2 vin
    if nb [2] != 1 : return False # 1 reculer
    if nb [3] != 1 : return False # 1 avancer
        
    # regle 2
    for i in range (1,len (sol)) :
        if sol [i] == 1 and sol [i-1] != 0 : return False
            
    # regle 3
    if sol [0] == sol [6] : return False
    if sol [0] == 3 : return False
    if sol [6] == 3 : return False
        
    # regle 4
    if sol [2] == 0 : return False
    if sol [5] == 0 : return False
        
    # regle 5
    if sol [1] != sol [5] : return False
        
    # si on arrive ici, c'est que toutes les regles sont verifiees
    return True
    
def affiche_solution (sol) :
    a = ["poison", "vin", "reculer", "avancer"]
    for s in sol :
        print a [s], ", ",
    print " "
        

# premier idee : 7 boucles imbriqees
sol = [ 0,0,0,0,0,0,0] 
for a in range (0,4) :
    sol [0] = a
    for b in range (0,4) :
        sol [1] = b
        for c in range (0,4) :
            sol [2] = c
            for d in range (0,4) :
                sol [3] = d
                for e in range (0,4) :
                    sol [4] = e
                    for f in range (0,4) :
                        sol [5] = f
                        for g in range (0,4) :
                            sol [6] = g
                            #print sol
                            r = solution_correcte (sol)
                            if r :
                                affiche_solution (sol)
                                
# seconde idee : 2 boucles seulement pour 
# parcourir toutes les solutions
sol = [ 0,0,0,0,0,0,0] 
while sol [0] < 4 :
    r = solution_correcte (sol)
    if r :
        affiche_solution (sol)
    
    sol [6] += 1
    for i in range (len (sol)-1, 0, -1) :  # on parcourt les indices en 
                                             # allant de 6 a 1 inclus
        if sol [i] >= 4 :
            sol [i]    = 0
            sol [i-1] += 1