Tableau de sommes pour le kakuro

Commenter

Contenu du snippet

Pour ceux qui ne connaissent pas le kakuro :
Il s'agit d'une grille, avec des nombre indiquées pour les colonnes et les lignes
Le but du jeux est donc de remplir ces lignes et colonnes, de maniere a :
1) ce que la somme des chiffre inscrit dans ces
lignes/colonnes corresponde au chiffre inscrit
2) ce que chaque chiffre n'apparaisse qu'une fois.

Ce programme liste donc chaque nombre, de 3 a 45, et ses décompositions possibles en
somme de nombres entier de 1 a 9, n'apparaissant qu'une fois.

exemple : 7 = 1 + 2 +4
= 3 + 4
= 2 + 5
= 1 + 6

Source / Exemple : 


import math

NomDuFichier = 'Kakuro.txt'

def GetBinaryMatrice(Valeur) : 
    Matrice = [0,0,0,0,0,0,0,0,0]
    TempValeur = Valeur
    for Index in range(9,0,-1) :
        Coef = pow(2,Index-1)
        if TempValeur>=Coef:
            TempValeur -= Coef
            Matrice[Index-1] = 1
    return Matrice
           
            
def MatToSum(Matrice):
    Somme = 0
    for Index in range(0,9):
        if Matrice[Index]==1:
            Somme += Index+1
    return Somme
        
        
        
def CompileMat(Matrice):
    Chaine = ''
    Chaine = Chaine + str(MatToSum(Matrice)) + ' = '
    for Index in range(0,9):
        if Matrice[Index]==1:
           Chaine = Chaine + str(Index+1) + '+'
    Chaine = Chaine[0:-1]
    return Chaine

def CreateTableau():
    Tableau = []
    for Index in range(0,46):
        Tableau.append( [] )
        
    for Index in range(1,512):
        Matrice = GetBinaryMatrice(Index)
        Somme   = MatToSum(Matrice)
        Liste   = Tableau[Somme]
        if not(Matrice in Liste):
            Liste.append(Matrice)
    return Tableau

Fichier = open(NomDuFichier,'w')
Fichier.write('///////////// Decomposition En Somme /////////////\n')

Table = CreateTableau()

for Index in range(1,46):
    Fichier.write( "***** " + str (Index) + " *****" + "\n")
    Liste = Table[Index]
    for Mat in Liste:
        Fichier.write(CompileMat(Mat) + "\n" )
        
Fichier.close

Conclusion :


But :
Remplir un tableau[1:45], contenant toutes les manieres de décomposer la valeur de l'index, en
somme de nombre entiers. Dans chaque somme, un chiffre ne doit apparaitre qu'une fois au maximum.

Fonctionnement :

1) Je cherche toutes les combinaisons possibles de somme de chiffre entiers > 0.
Pour cela, je compte de 1 a 512, et je fait correspondre ce nombre a une liste de chiffre binaires.
1 2 3 4 5 6 7 8 9
Ex : 5 = [0,1,1,0,0,0,0,0,0].Cette liste represente une somme. Ici = 1*0 + 2*1 + 3*1 + 4*0 .. etc .

2) Pour chaque combinaison possible, je calcule la somme (comprise entre 1 et 1+2+3+4+5+6+7+8+9).
Si ma matrice n'existe pas déja, j'ajoute ma Liste Binaire a un tableau, a l'index [Somme].

3) La fonction CompileMat, crée une chaine de caractère, représentant la matrice-somme binaire que je
lui envoie.
Ex : [1,0,1,0,0,0,0,0,0] -> "5 = 2 + 3"
(La ligne Chaine = Chaine [0:-1] supprime le dernier caractère, qui est forcement un '+'

J'espère que ce n'est pas trop embrouillé tout ca.

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_raoullevert)