[..] Programme de résolution de sudoku qui ne marche pas ...

[guitarist]

Et j'ai Reussi !

Merci Beaucoup ZDS

Voilà le code final :

[ZDS]

Bonjour,

De rien, mais tu es loin d'avoir réussi :s Désolé de te casser dans ton élan comme ça, mais :
"000400000570000103210605000390080200000701000007020016000802079905000082000009000"
Teste cette grille, et tu verras que ton algo te génère des doublons, et qu'il ne remplit pas la grille entièrement.

Je vais jeter un coup d'oeil à ton code dans la journée, mais je te conseille de repasser le sujet en non-résolu [..].

A bientôt.

[guitarist]

Effectivement depuis hier je vois ça et je suis juste super dégouté
Pourtant je vois pas d'erreur (surtout que ça marche desfois... et pas d'autres... )

Merci ZDS de m'aider (encore)

[ZDS]

Bonsoir,

(désolé ce weekend, tu vas devoir te débrouiller seul ^^)

J'ai regardé ton code, et question algo avec le nestPasPossibleAilleurs, tu as fait une assez grosse erreur de conception Ton principe n'est pas bon. Il ne faut pas modifier la grille avec une valeur POSSIBLE comme dans ta facon (tu affecte $k+1 à $grille[$i][$j] avant de vérifier si c'est bon quitte à remettre 0 dedans, c'est une grosse erreur), sinon ça risque de corrompre le reste du code, TA GRILLE DOIT TOUJOURS ETRE VALIDE A TOUT MOMENT DU CODE, au moins avec ça tu ne pourras pas générer d'erreurs. Ne lis pas la suite si tu veux trouver par toi même, sinon, voila de l'aide :

► Afficher le texteSi tu souhaites une aide plus poussée, jette un coup d'oeil ici

Code : Tout sélectionner

; on récpère les possibilitées dans un tableau
Local $possibilites2 = getValeursPossibles($grille,$i,$j)
; on test si la valeur est possible dans la case ET pas ailleurs
For $k = 0 to 8
    If $possibilites2[$k] And nestPasPossibleAilleurs($grille,$i,$j,$k+1) Then
        $grille[$i][$j] = $k + 1
    GUICtrlSetData($matrice[$i][$j],$k + 1 )
    EndIf
Next[code]Tu dois donc modifier la facon dont la fonction nestPasPossibleAilleurs se comporte :[code];fonction qui verifie si la non possibilité d'une valeur sur case, ligne, colone
Func nestPasPossibleAilleurs($grille,$x,$y,$val)
    If Not estPossibleSurLigne  ($grille,$x,$y,$val) Then Return True
    If Not estPossibleSurColonne($grille,$x,$y,$val) Then Return True
    If Not estPossibleSurBloc   ($grille,$x,$y,$val) Then Return True
    Return False
EndFunc

Il faut ajouter qq fonctions supplémentaires, à la place des estValideSurXXX :

Code : Tout sélectionner

; Fonction de vérification des possibilités de la ligne
Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités de le colonne
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités du bloc
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$valeur Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc

A bientôt!

[guitarist]

Voilà ou j'en suis du coup :


Comme vous pouvez le voir j'ai rajouté un Else et il va plus loin dans la grille : étrange non? Franchement je cale :/
Mais en contre partie il est pas capable de remplir une grille vide.

Merci ZDS pour ta correction, mais j'ai aussi besoin de qqln (d'autre) pour ce week-end, HELP !

[ZDS]

Pour les fonctions que tu viens de me montrer, elles concernent ton bouton BT, c'est bien ça?
Je t'ai répondu sans passer par là, parce que je n'en ai pas vu l'utilité. Les modifications que je t'ai proposé ne concernent que ce qui est appelé par le bouton "Remplir", c'est à dire la méthode propre au remplissage d'une grille. Voici le code complet auquel j'ai retiré toutes les fonctions inutiles.

En fait les fonctions inutiles sont toutes celles que tu utilises dans ton précédent message : backT, absentSurLigne, absentSurColonne et absentSurBloc. Personnellement je ne me sens pas de reprendre ton code, ce n'est pas du tout ma façon de coder (je t'ai déjà parlé des appels récursifs, tu ferais mieux de laisser tomber ça avant d'aller dans le mur. Fais déjà un code qui marche, et tu fais ensuite les moulures et les peintures ^^), et ta façon d''arranger l'algo est (désolé du mot) incompréhensible.

Bref, je te fournis ton code modifié avec mes modifs sur les fonctions quand tu cliques sur "Remplir" (d'ailleurs, le bouton "BT" est désactivé, à toi de rajouter tes fioritures ^^

► Afficher le textescript complet

Code : Tout sélectionner

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <Array.au3>

; Chaines possibles pour l'import des valeurs :
; 9x9 Facile    = 050310020010698540800020000007040080045000910090050700000060007076235090030089050
; 9x9 Débutant  = 000400000570000103210605000390080200000701000007020016000802079905000082000009000
; 9x9 Confirmé  = 005000601000700000780061900300500000059040030000100006007006120810009007500200800
; 9x9 Difficile = 002300007809000005005009046000003000090127600007480000000572013070940000540800000
; 9x9 Expert    = 003040057908060200001350600800700400000008500000014002000430800410080320000000000

#Region Couleurs de l'interface
Global Const $SUDOKU_COLOR_OK = 0x0066FF, $SUDOKU_COLOR_KO = 0xFF6666, $SUDOKU_COLOR_NAN = 0xAAAAAA
#EndRegion

#Region Interface graphique générale
Local $GUI = GUICreate("Sudoku", 480, 363, 192, 132)
GUISetFont(12, 800, 0, "MS Mincho")
#EndRegion

#Region 9x9 cases à remplir du Sudoku
Global $matrice[9][9]
; Pour chaque ligne et colonne
For $i=0 To 8
    For $j=0 To 8
        ; Position [X,Y] pour les cases à remplir du sudoku
        Local $x = 32+$i*32, $y = 40+$j*32
        ; Ajout d'un décalage de 10 px pour bien séparer les 3x3 blocs
        $x +=  cond($i>2,10,0)+cond($i>5,10,0)
        $y +=  cond($j>2,10,0)+cond($j>5,10,0)
        $matrice[$i][$j] = GUICtrlCreateInput("", $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

#Region Boutons d'actions
$Button1 = GUICtrlCreateButton("Lancer", 368, 40, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button1, $SUDOKU_COLOR_OK)
$Button2 = GUICtrlCreateButton("Importer", 368, 90, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button2, $SUDOKU_COLOR_OK)
$Button3 = GUICtrlCreateButton("Remplir", 368, 140, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button3, $SUDOKU_COLOR_OK)
$Button4 = GUICtrlCreateButton ("B' T'",368,190,91,33,$WS_GROUP)
GUICtrlSetColor($Button4, $SUDOKU_COLOR_OK)
#EndRegion

#Region Pavé numérique pour l'affichage des valeurs possibles
Local $chiffres[9]
For $i=0 To 2
    For $j=0 To 2
        ; Position [X,Y] pour les boutons du pavé numérique
        Local $x = 368+$i*32, $y = 252+$j*32, $n=$i*3+$j
        $chiffres[$n] = GUICtrlCreateButton($n+1, $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($chiffres[$n], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

GUICtrlSetState($Button4, $GUI_DISABLE)
GUISetState(@SW_SHOW)
Local $focus_previous[2] = [-1,-1]

#Region Traitement des messages de l'interface
While 1
    Local $nMsg = GUIGetMsg()
    Switch $nMsg
    Case $GUI_EVENT_CLOSE
        Exit
    Case $Button1
        ; Récupération de la grille des valeurs
        Local $grille = getGrille($matrice)
        ; $estValide est une matrice 9x9 contenant dans chaque case une séries de 3 caractères {_,L,C,B}
        ; $checkGrille est à True si toute la grille est correcte
        Local $estValide = estValide($grille), $checkGrille = True
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; La case est correctement remplie si $estValide est égale à "___" en [$i,$j]
                Local $checkCase = ($estValide[$i][$j]="___")
                $checkGrille = $checkGrille And $checkCase
                ; Si $checkCase est à True, on met la case en bleu, sinon en rouge
                GUICtrlSetColor($matrice[$i][$j], cond($checkCase,$SUDOKU_COLOR_OK,$SUDOKU_COLOR_KO))
            Next
        Next
        ; Message Traytip pour prévenir de l'état de la grille
        TrayTip("Sudoku", cond($checkGrille,"Grille correcte", "Grille incorrecte"), 10, cond($checkGrille,1,3))
    Case $Button2
        ; On demande une chaine de 81 caractères (M:obligatoire, 81:taille demandée)
        Local $chaine = InputBox("Importer", "Entrez une chaine de 81 valeurs à importer"&@CRLF&"(1-9 pour les valeurs, 0 pour une valeur vide)", "", " M81")
        ; Si pas d'erreur, et 81 symboles entre 0 et 9, alors...
        If Not @error And StringRegExp($chaine, "^[0-9]{81}$") Then
            ; On sépare chaque caractère de la chaine, on en fait un tableau $split indexé à partir de 0
            Local $split = StringSplit($chaine,"",2)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; la valeur à mettre en [$i,$j] dans $matrice est en $j+9*$i dans $split
                    Local $valeur = Number($split[$j+$i*9])
                    ; Si la valeur n'est pas entre 1 et 9, on affiche la chaine vide
                    GUICtrlSetData($matrice[$i][$j], cond($valeur>0 And $valeur<10,$valeur,""))
                    ; On considère que chaque case est correcte, couleur bleue
                    GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
                Next
            Next
        EndIf
    Case $Button3
        Do
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 To 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante
                        If $found = 1 Then GUICtrlSetData($matrice[$i][$j], $val)
                    EndIf
                Next
            Next

            For $i =0 to 8
                for $j = 0 to 8
                    ; on ne s'occupe que des cases vides
                    If $grille[$i][$j] = 0 Then
                        ; on récpère les possibilitées dans un tableau
                        Local $possibilites2 = getValeursPossibles($grille,$i,$j)

                        ; on test si la valeur est possible dans la case ET pas ailleurs
                        For $k = 0 to 8
                            If $possibilites2[$k] And nestPasPossibleAilleurs($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                GUICtrlSetData($matrice[$i][$j],$k + 1 )
                            EndIf
                        Next
                    EndIf
                Next
            Next

            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($matrice)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille,$grille_apres)
        #region backtraking à partir d'ici
    Case $Button4
        ; backT(getGrille($matrice),0)
        ; #endregion
    Case Else
        ; Liste des boutons du pavé numérique
        For $i = 0 To 8
            ; Si on clique sur le bouton $i (Attention ! valeur du bouton:$i+1, car indexé de 0 à 8 pour les valeurs de 1 à 9)
            If $nMsg = $chiffres[$i] Then
                ; Si le focus est gardé sur une case valide du Sudoku,
                If $focus_previous[0]<>-1 And $focus_previous[1]<>-1 Then
                    ; On affiche la valeur du bouton (GUICtrlRead($chiffres[$i])) dans la case du Sudoku correspondant ($matrice[$focus_previous[0]][$focus_previous[1]])
                    GUICtrlSetData($matrice[$focus_previous[0]][$focus_previous[1]], GUICtrlRead($chiffres[$i]))
                EndIf
            EndIf
        Next
        ; Quel case a le focus?
        Local $focus[2] = [-1,-1] ; [-1,-1] correspond aux coordonnées d'un bouton ayant le focus, mais qui ne fait pas partie des cases du Sudoku
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; Si la case en [$i,$j] a le focus, on l'enregistre
                If isFocused($matrice[$i][$j],$GUI) Then
                    $focus[0]=$i
                    $focus[1]=$j
                EndIf
            Next
        Next
        ; Si le focus a changé depuis la dernière fois (et qu'il est "valide", autrement dit que c'est bien une case du Sudoku)
        If $focus[0]<>$focus_previous[0] Or $focus[1]<>$focus_previous[1] And $focus[0]<>-1 And $focus[1]<>-1 Then
            ; On enregistre dans $focus_previous la valeur actuelle, pour ne faire cette opération que si le focus change
            $focus_previous = $focus
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; On récupère la liste des valeurs possibles
            Local $possibilites = getValeursPossibles($grille, $focus[0],$focus[1])
            ; Pour chaque case du pavé
            For $i = 0 To 8
                ; Si la valeur est disponible, on active le bouton, sinon on le désactive
                GUICtrlSetState($chiffres[$i], cond($possibilites[$i],$GUI_ENABLE,$GUI_DISABLE))
            Next
        EndIf
    EndSwitch
WEnd

;fonction qui verifie si la non possibilité d'une valeur sur case, ligne, colone
Func nestPasPossibleAilleurs($grille,$x,$y,$val)
    If Not estPossibleSurLigne  ($grille,$x,$y,$val) Then Return True
    If Not estPossibleSurColonne($grille,$x,$y,$val) Then Return True
    If Not estPossibleSurBloc   ($grille,$x,$y,$val) Then Return True
    Return False
EndFunc

; Fonction conditionnelle rapide
Func cond($cond, $true, $false)
    If $cond Then Return $true
    Return $false
EndFunc
; Fonction de comparaison de matrices
Func matrixEquals($m1,$m2)
    ; On teste d'abord les dimensions des deux matrices
    For $d = 0 To 2
        ; Si différents, on retourne false
        If UBound($m1,$d)<>UBound($m2,$d) Then Return False
    Next
    ; Pour chaque ligne et colonne
    For $i = 0 To UBound($m1,1)-1
        For $j = 0 To UBound($m1,2)-1
            ; Si différents, on retourne false
            If $m1[$i][$j]<>$m2[$i][$j] Then Return False
        Next
    Next
    Return True
EndFunc
; Fonction de détection d'un état sur un controle
Func isState($control,$state)
    Return BitAND(GUICtrlGetState($control),$state)=$state
EndFunc
; Fonction de détection du focus sur un controle
Func isFocused($control,$gui)
    Return GUICtrlGetHandle($control) = ControlGetHandle($gui,"",ControlGetFocus($gui))
EndFunc

; Fonction de vérification de la grille
Func estValide($grille)
    Local $resultat[9][9]
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            Local $case = "___"
            ; On ne vérifie que les cases dont la valeur est entre 1 et 9
            If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
                $case = _
                    cond(estValideSurLigne($grille,   $i,$j),"_","L") & _
                    cond(estValideSurColonne($grille, $i,$j),"_","C") & _
                    cond(estValideSurBloc($grille,    $i,$j),"_","B")
            EndIf
            $resultat[$i][$j] = $case
        Next
    Next
    Return $resultat
EndFunc

; Fonction de récupération des valeurs de la grille (chiffres entre 0 et 9)
Func getGrille($matrice)
    Local $grille[9][9]
    For $i=0 To 8
        For $j=0 To 8
            $grille[$i][$j] = Number(GUICtrlRead($matrice[$i][$j]))
            If Not StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then $grille[$i][$j] = 0
        Next
    Next
    Return $grille
EndFunc
; Fonction de vérification des lignes
Func estValideSurLigne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $i = 0 To 8
        ; Si $valeur est présente sur la ligne (ailleurs qu'en [$x,$y]), on retourne False
        If $i<>$x And $grille[$i][$y]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurColonne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $j = 0 To 8
        ; Si $valeur est présente sur la colonne (ailleurs qu'en [$x,$y]), on retourne False
        If $j<>$y And $grille[$x][$j]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurBloc($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    ; On détecte le bloc concerné par la valeur [$x,$y] ($bloc est un couple dont chaque valeur est entre 0 et 2)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    ; Pour chaque ligne et colonne de ce bloc
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            ; Si $valeur est présente sur le bloc (ailleurs qu'en [$x,$y]), on retourne False
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$valeur Then
                Return False
            EndIf
        Next
    Next
    Return True
EndFunc

; Fonction de vérification des lignes 
Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des lignes
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des lignes
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If $i<>$x Or $j<>$y Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc

; Fonction de récupération des valeurs possibles pour une case donnée
Func getValeursPossibles($grille, $i,$j)
    Local $resultat[9]
    ; Pour chaque valeur possible (de 1 à 9, dans un tableau indexé de 0 à 8)
    For $n = 0 To 8
        ; Par défaut, $resultat[$n] = True, c'est à dire que la valeur est disponible
        $resultat[$n] = True
        ; On ne teste les valeurs possibles que si les valeurs $i et $j correspondent à un focus valide
        If $i<>-1 And $j<>-1 Then
            ; $n = 0 à 8, dont la valeur à traiter $val (qui est entre 1 et 9) est $n+1
            ; On détecte le bloc concerné par la valeur [$i,$j] ($bloc est un couple dont chaque valeur est entre 0 et 2)
            Local $val = $n+1, $bloc[2]=[ _
                cond($i>2,1,0)+cond($i>5,1,0), _
                cond($j>2,1,0)+cond($j>5,1,0)  _
            ]
            ; On vérifie sur la ligne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$j And $grille[$i][$x] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur la colonne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$i And $grille[$x][$j] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur le bloc concerné que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0+3*$bloc[0] To 2+3*$bloc[0]
                For $y = 0+3*$bloc[1] To 2+3*$bloc[1]
                    If $x<>$i And $y<>$j And $grille[$x][$y] = $val Then $resultat[$n] = False
                Next
            Next
        Else
            ; Pour les valeurs ayant des coordonnées invalides, on retourne False
            $resultat[$n] = False
        EndIf
    Next
    Return $resultat
EndFunc

Pour finir, même ce code là modifié ne fonctionne pas entièrement (sur certaines grilles il ne va pas jusqu'au bout, et tu es parfois obligé de cliquer plusieurs fois sur le bouton "Remplir" pour continuer la résolution). Et surtout, il est super lent ! (j'hallucine, au moins 5 fois plus lent que celui que j'ai sous la main :s)

RAPPEL : Ce programme ne permet que de résoudre une grille, en lui donnant des possibilités de départ, il retrouve LA grille de solution. Par corollaire, on en déduit que la résolution permet de s’arrêter une fois qu'une UNIQUE solution est possible, dans le cas où deux solutions sont possibles (genre 4 cases 12/21 et 21/12), il ne remplira pas les cases pouvant avoir les valeurs bloquantes (à toi de remplir au moins une valeur pour qu'il sache quoi remplir dans les 3 autres).
On en déduit donc que c'est impossible, vu les milliards de grilles possibles, qu'un script de résolution te génère une grille entière depuis une grille entièrement vide C'est comme si tu partais des 4 types de bases azotées A T C G, et que tu demandais à ce qu'on te construise un ADN humain qui soit correct... Faut pas rêver ^^

Bref, je vais déposer sur le forum un script d'exemple que j'ai adapté à ton départ d'interface graphique (uniquement l'interface, et encore c'est énormément modifié). Un résolveur de Sudoku de taille complètement variable (des 3x2², 3x3² classiques, 3x4 ... jusque 5x7² = 35valeurs différentes, et encore c'est à cause du nombre de lettres et chiffres limité dans l'alphabet français), avec vérification totale sans relance, et avec tentative si blocage en choisissant une des valeurs possibles et aller jusqu'à une grille terminée et valide. Autant être franc, l'aspect ressemblera à ton script, mais dans le fonctionnement et les performances, ça sera complétement différent (qu'il n'y ait pas d'histoire de droit d'auteur entre nous ^^).

Tu peux toujours l'utiliser à titre d'exemple de code pour améliorer le tien. Je te laisse pour le weekend, mais même la semaine prochaine, je ne te serai plus d'une grande aide, le mieux est de voir avec quelqu'un d'autre ou de te plier à mon code

A bientôt !

[guitarist]

Je t'avoue que je suis un peu confus :s
En fait tu me propose d'abandonner le backtraking c'est cela?

Et une derniere question, quel est ce fameux code que tu as sous la main et qui est miraculeux ? . C'est avec un des langages que tu as cité c'est ça ?

Pour les droits d'auteurs, meme si tu t'en doute, je m'en fiche, j'ose demander et supplier de l'aide alors pourquoi j'irai chipoter pour ça

Bon en gros si je resume il ne sera pas possible de resoudre les grilles qui n'ont dans aucune case une seula valeur possible ou dans un bloc une valeur posible qu'une seule fois? Apres je pourrai rajouter d'autres techniques non? Genre par exemple si les trois possibilitées sont alignées dans un meme bloc on peut retirer les possibilitées de cette meme valeur dans les bloc alignés. Bref compliqué quoi

[ZDS]

Bonjour,

Tout compte fait j'ai un peu de temps ce weekend La fonction appelée par ton bouton Backtracking ne me semble pas utile dans le sens où 99% du temps l'algo de base permet de résoudre une grille. En fait si on fait une vraie fonctionnalité de BT, il faudrait que tu fasses une hypothèse ("La case I,J vaut X") puis tenter de résoudre la grille ainsi formée. Si la ou les solutions les plus abouties sont toutes incorrectes (une case vide n'a plus aucune possibilité, ou deux cases de la même ligne/colonne/bloc ont la même valeur), on tente une autre hypothèse ("la case I,J vaut Y") et ainsi de suite jusqu'à arriver à une grille correcte et finie.

Ce genre de fonction risque d'être très très lente, et pas forcément très très utile. Il vaut mieux se poser sur un algo comme le suivant :

• 1 - Je regarde l'état actuel => grille_avant
• 2 - Je remplis les cases n'ayant qu'une possibilité
• 3 - Je regarde l'état obtenu => grille_apres
• 4 - Si grille_avant = grille_apres, la méthode à l'étape "2" n'a rien donné et on passe à l'étape "5", sinon, on recommence à l'étape "1"
• 5 - Je remplis les cases ayant une valeur ne pouvant pas aller ailleurs sur la même ligne
• 6 - Je regarde l'état obtenu => grille_apres
• 7 - Si grille_avant = grille_apres, la méthode à l'étape "5" n'a rien donné et on passe à l'étape "8", sinon, on recommence à l'étape "1"
• 8 - Je remplis les cases ayant une valeur ne pouvant pas aller ailleurs sur la même colonne
• 9 - Je regarde l'état obtenu => grille_apres
• 10 - Si grille_avant = grille_apres, la méthode à l'étape "8" n'a rien donné et on passe à l'étape "11", sinon, on recommence à l'étape "1"
• 11 - Je remplis les cases ayant une valeur ne pouvant pas aller ailleurs sur le même bloc
• 12 - Je regarde l'état obtenu => grille_apres
• 13 - Si grille_avant = grille_apres, la méthode à l'étape "11" n'a rien donné et on passe à l'étape finale, sinon, on recommence à l'étape "1"
• 14 - On regarde si la grille est correcte et finie, c'est le résultat final

On peut toujours aussi modifier l'étape 14 par :

• 14 - Si la grille est finie, c'est bon
• 15 - Sinon on enregistre la grille dans grille_temporaire, on choisit une case au hasard, on note une valeur possible, et on recommence à l'étape "1" avec cette hypothèse. Si on revient à cette étape avec une solution incorrecte, on reprend à partir de grille_temporaire, on choisit une autre valeur possible et on reprend à l'étape "1".
• 16 - Si on a testé toutes les valeurs possibles d'une case, on essaye avec une autre case
• 17 - Si on a testé toutes les cases, et si on a toujours aucune solution, c'est que la grille de départ est impossible à résoudre

Bref, ça peut te sembler vachement obscur, mais tout est là. Si vraiment tu veux un exemple de code, tu peux regarder en détail comment est fait mon script dans la section Exemples (http://autoitscript.fr/forum/viewtopic.php?f=6&t=8442).

Si j'ai bien compris, dans ton script, ce qui est appelé lors d'un clic sur "Remplir" correspondait à une résolution de base, et sur "BT" ça correspondait à des essais successifs, c'est ça? En fait, j'étais parti de l'optique qu'un véritable Sudoku n'a qu'une seule solution possible. Si vraiment tu souhaites ajouter un systeme de tentatives, dis moi, mais attends toi à un truc énorme en terme de code, ultra lent (pour une grille vide, on risque d'atteindre une complexité en O(n^log(n))), et pas forcément facile à tester (il faut déjà trouver une grille qui a absolument besoin d'un choix arbitraire pour être résolu, pas facile à générer à part peut-être en prenant une grille, et en enlevant tous les 1 et les 2, ce qui permet au moins deux grilles possibles, les 1 et les 2 pouvant prendre la place l'un de l'autre...)
Un truc inbuvable quoi

Tiens moi au courant, et à la semaine prochaine !

A bientôt !

[guitarist]

Hello

Deja encore merci pour ton aide (ça fait une semaine que tu me repond sans etre desagréable ! )

Alors dans mon script justement je suis en train d'ecrire le cas ou la valeur ne se trouve qu'une fois sur la ligne ou colone. Donc ça m'encourage encore un peu plus :p

Sinon je voit pas la différence entre ta derniere étape (celle ou tu test un nombre) et mon back traking (alias BT) ou alors c'est basé sur le fait qu'on test qu'un seul num?
Si on part la dessus faudrai le faire sur les cases n'ayant que deux choix possibles

Et sinon moi je pensais rajouter qqlch du genre : si dans un meme bloc les 2 ou 3 solutions possibles sont alignées alors on peut en déduire que les solutions d'un autre bloc mais sur une meme ligne ou colone sont fausses.
Tu vois le truc?
J'ai essayé de le coder mais impossible, ça doit pas etre de mon niveau ^^.

A la prochaine , et je posterai mon nouveau code

[ZDS]

Bonsoir.

Je vois pas en quoi je peux t'aider maintenant, ton script fonctionne pour la plupart des grilles. Il reste encore celles qui ne sont réalisables qu'en faisant une tentative, mais ça ne me semble pas facile à implémenter dans ton script tel qu'il est conçu. Idem pour l'algo que tu proposes de mettre en place pour améliorer le fonctionnement du bousin, déjà que le script est assez lent, avec ce genre de chose il risque d'être ingérable.

En tout cas bravo pour le code que tu as fait dans ton dernier message Je vais réfléchir à comment améliorer la réussite du script, mais comme je te disais, maintenant ajouter des algos tarabiscotés ne servira plus à rien, il faut désormais ajouter un système de prise de décision : "Je ne peux plus rien faire, je prends une case vide et je tente de finir la grille avec 1 dedans, si c'est pas possible je tente avec 2, toujours pas je tente avec 3, ... avec 6 ça marche, c'est fini". Aucun des algos "améliorés" que tu comptes rajouter ne sera aussi efficace (en terme de réussite, pas de performance) que ce système de tentative.

A bientôt !

PS : Pour le système de tentative, il faut pouvoir tester une valeur et pouvoir revenir en arrière pour en rester une autre. Et ça, les fonctions permettent très bien de le faire, et cette fois, utilise la récursivité (une fois n'est pas coutume, et là il n'y a pas d'autre moyen simple de faire ça). Voici un schéma :

► Afficher le texteresoudre($grille) avec récursivité

Code : Tout sélectionner

Func resoudre($grille)
    Local $grille_a_remplir = $grille ; On travaille sur une copie pour l'exemple
    ; TODO : remplir les cases ayant un seul choix possible
    If estFinie($grille_a_remplir) Then Return $grille_a_remplir
    ; TODO : remplir les cases n'ayant pas de choix ailleurs dans la ligne
    If estFinie($grille_a_remplir) Then Return $grille_a_remplir
    ; TODO : remplir les cases n'ayant pas de choix ailleurs dans la ligne
    If estFinie($grille_a_remplir) Then Return $grille_a_remplir
    ; TODO : remplir les cases n'ayant pas de choix ailleurs dans la ligne
    If estFinie($grille_a_remplir) Then Return $grille_a_remplir
    ; TODO : tester une valeur
    For $i = 0 To 8
        For $j = 0 To 8
            If $grille_a_remplir[$i][$j] = 0 Then
                Local $possibilites = getPossibilites($grille_a_remplir,$i,$j)
                For $k = 0 To 8
                    If $possibilites[$k] Then
                        ; on copie la grille, on enregistre une valeur possible
                        Local $grille_a_remplir_tentative = $grille_a_remplir
                        $grille_a_remplir_tentative[$i][$j] = $k+1
                        ; On tente de résoudre la grille avec la valeur
                        $grille_a_remplir_tentative = resoudre($grille_a_remplir_tentative)
                        ; Si on a réussi on a la réponse
                        If estFinie($grille_a_remplir_tentative) Then Return $grille_a_remplir_tentative
                        ; Sinon on continue avec une autre valeur possible, et sinon une autre case
                    EndIf
                Next
            EndIf
        Next
    Next
    Return $grille_a_remplir
EndFunc

ATTENTION : c'est un algo symbolique, pas un code à utiliser comme ça. Bonne continuation !

[guitarist]

Regarde ce que j'ai reussi à faire ce soir (je te cache pas que c'est Bagdad) :


Cependant j'ai une erreur de source inconnu :

Code : Tout sélectionner

==> Subscript used with non-Array variable.:
If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
If StringRegExp($grille^ ERROR
->20:50:36 AutoIT3.exe ended.rc:1

Il me dit que le tableau est pas bon -_-, il se fou de ma gueule hein? :p

Bon allez j'arrete la j'ai du boulot ailleur et une grosse journey demain

Merci ZDS

[ZDS]

Bonjour,

C'est normal que ça plante :
- $grille n'est pas un tableau dans le corps de la fonction estValide(), or $grille est un paramètre d'appel de la fonction
- Donc l'appel à la fonction estValide() n'est pas fait avec un tableau, or l'appel est fait dans le corps de estValideBis() à la première ligne : Local $estValide = estValide($grille)
- Donc $grille n'est pas un tableau dans le corps de la fonction estValideBis(), or $grille est un paramètre d'appel de la fonction (aussi)
- Donc l'appel à la fonction estValideBis() n'est pas fait avec un tableau, or l'appel est fait dans le corps de _resoudre() à la troisième boucle : If _estValideBis($resultatProvisoire) And ...
- Et la variable $resultatProvisoire est définie ainsi : Local $resultatProvisoire = _resolution($resultatTest, 1)

Et là, c'est le drame : ta fonction _resolution() ne retourne pas de tableau, pire, elle ne retourne rien ! ^^
N'ayant pas trop le temps de décortiquer le code pour savoir quelle valeur retourner ($matrice, $grille, $grille_avant, $grille_apres, ...), je te laisse rajouter un Return à ta fonction et retenter une grille.

A bientôt!

[guitarist]

Heya,

Voilà ou j'en suis :

► Afficher le texte

Code : Tout sélectionner

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <Array.au3>
; Chaines possibles pour l'import des valeurs :
; 050310020010698540800020000007040080045000910090050700000060007076235090030089050

#Region Couleurs de l'interface
Global Const $SUDOKU_COLOR_OK = 0x0066FF, $SUDOKU_COLOR_KO = 0xFF6666, $SUDOKU_COLOR_NAN = 0xAAAAAA
#EndRegion

#Region Interface graphique générale
Local $GUI = GUICreate("Sudoku", 480, 363, 192, 132)
GUISetFont(12, 800, 0, "MS Mincho")
#EndRegion

#Region 9x9 cases à remplir du Sudoku
Global $matrice[9][9] , $resultatProvisoire[9][9]
; Pour chaque ligne et colonne
For $i=0 To 8
    For $j=0 To 8
        ; Position [X,Y] pour les cases à remplir du sudoku
        Local $x = 32+$i*32, $y = 40+$j*32
        ; Ajout d'un décalage de 10 px pour bien séparer les 3x3 blocs
        $x +=  cond($i>2,10,0)+cond($i>5,10,0)
        $y +=  cond($j>2,10,0)+cond($j>5,10,0)
        $matrice[$i][$j] = GUICtrlCreateInput("", $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

#Region Boutons d'actions
$Button1 = GUICtrlCreateButton("Lancer", 368, 40, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button1, $SUDOKU_COLOR_OK)
$Button2 = GUICtrlCreateButton("Importer", 368, 90, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button2, $SUDOKU_COLOR_OK)
$Button3 = GUICtrlCreateButton("Remplir", 368, 140, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button3, $SUDOKU_COLOR_OK)
;$Button4 = GUICtrlCreateButton ("B' T'",368,190,91,33,$WS_GROUP)
;GUICtrlSetColor($Button4, $SUDOKU_COLOR_OK)
;$Progress1 = GUICtrlCreateProgress(40, 0, 401, 33)
#EndRegion

#Region Pavé numérique pour l'affichage des valeurs possibles
Local $chiffres[9]
For $i=0 To 2
    For $j=0 To 2
        ; Position [X,Y] pour les boutons du pavé numérique
        Local $x = 368+$i*32, $y = 252+$j*32, $n=$i*3+$j
        $chiffres[$n] = GUICtrlCreateButton($n+1, $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($chiffres[$n], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

GUISetState(@SW_SHOW)
Local $focus_previous[2] = [-1,-1]

#Region Traitement des messages de l'interface
While 1
    Local $nMsg = GUIGetMsg()
    Switch $nMsg
    Case $GUI_EVENT_CLOSE
        Exit
        #region Buttons
        #region Button 1
    Case $Button1
        ; Récupération de la grille des valeurs
        Local $grille = getGrille($matrice)
        ; $estValide est une matrice 9x9 contenant dans chaque case une séries de 3 caractères {_,L,C,B}
        ; $checkGrille est à True si toute la grille est correcte
        Local $estValide = estValide($grille), $checkGrille = True
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; La case est correctement remplie si $estValide est égale à "___" en [$i,$j]
                Local $checkCase = ($estValide[$i][$j]="___")
                $checkGrille = $checkGrille And $checkCase
                ; Si $checkCase est à True, on met la case en bleu, sinon en rouge
                GUICtrlSetColor($matrice[$i][$j], cond($checkCase,$SUDOKU_COLOR_OK,$SUDOKU_COLOR_KO))
            Next
        Next
        ; Message Traytip pour prévenir de l'état de la grille
        TrayTip("Sudoku", cond($checkGrille,"Grille correcte", "Grille incorrecte"), 10, cond($checkGrille,1,3))
        #endregion
        #region Button 2
    Case $Button2
        ; On demande une chaine de 81 caractères (M:obligatoire, 81:taille demandée)
        Local $chaine = InputBox("Importer", "Entrez une chaine de 81 valeurs à importer"&@CRLF&"(1-9 pour les valeurs, 0 pour une valeur vide)", "", " M81")
        ; Si pas d'erreur, et 81 symboles entre 0 et 9, alors...
        If Not @error And StringRegExp($chaine, "^[0-9]{81}$") Then
            ; On sépare chaque caractère de la chaine, on en fait un tableau $split indexé à partir de 0
            Local $split = StringSplit($chaine,"",2)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; la valeur à mettre en [$i,$j] dans $matrice est en $j+9*$i dans $split
                    Local $valeur = Number($split[$j+$i*9])
                    ; Si la valeur n'est pas entre 1 et 9, on affiche la chaine vide
                    GUICtrlSetData($matrice[$i][$j], cond($valeur>0 And $valeur<10,$valeur,""))
                    ; On considère que chaque case est correcte, couleur bleue
                    GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
                Next
            Next
        EndIf
        #endregion
        #region Button 3
    Case $Button3
        _resolution($matrice)
        #endregion
        #region Button 4
;   Case $Button4
;       backT(getGrille($matrice),0)
;       #endregion
#region Buttons Chiffres
    Case Else
        ; Liste des boutons du pavé numérique
        For $i = 0 To 8
            ; Si on clique sur le bouton $i (Attention ! valeur du bouton:$i+1, car indexé de 0 à 8 pour les valeurs de 1 à 9)
            If $nMsg = $chiffres[$i] Then
                ; Si le focus est gardé sur une case valide du Sudoku,
                If $focus_previous[0]<>-1 And $focus_previous[1]<>-1 Then
                    ; On affiche la valeur du bouton (GUICtrlRead($chiffres[$i])) dans la case du Sudoku correspondant ($matrice[$focus_previous[0]][$focus_previous[1]])
                    GUICtrlSetData($matrice[$focus_previous[0]][$focus_previous[1]], GUICtrlRead($chiffres[$i]))
                EndIf
            EndIf
        Next
        ; Quel case a le focus?
        Local $focus[2] = [-1,-1] ; [-1,-1] correspond aux coordonnées d'un bouton ayant le focus, mais qui ne fait pas partie des cases du Sudoku
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; Si la case en [$i,$j] a le focus, on l'enregistre
                If isFocused($matrice[$i][$j],$GUI) Then
                    $focus[0]=$i
                    $focus[1]=$j
                EndIf
            Next
        Next
        ; Si le focus a changé depuis la dernière fois (et qu'il est "valide", autrement dit que c'est bien une case du Sudoku)
        If $focus[0]<>$focus_previous[0] Or $focus[1]<>$focus_previous[1] And $focus[0]<>-1 And $focus[1]<>-1 Then
            ; On enregistre dans $focus_previous la valeur actuelle, pour ne faire cette opération que si le focus change
            $focus_previous = $focus
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; On récupère la liste des valeurs possibles
            Local $possibilites = getValeursPossibles($grille, $focus[0],$focus[1])
            ; Pour chaque case du pavé
            For $i = 0 To 8
                ; Si la valeur est disponible, on active le bouton, sinon on le désactive
                GUICtrlSetState($chiffres[$i], cond($possibilites[$i],$GUI_ENABLE,$GUI_DISABLE))
            Next
        EndIf
        #endregion
        #endregion
    EndSwitch
WEnd

#region estPossibleSurX

Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités de le colonne
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités du bloc
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If ($i<>$x Or $j<>$y) And $grille[$i][$j] = 0 Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc
#endregion
; Fonction conditionnelle rapide
Func cond($cond, $true, $false)
    If $cond Then Return $true
    Return $false
EndFunc
; Fonction de comparaison de matrices
Func matrixEquals($m1,$m2)
    ; On teste d'abord les dimensions des deux matrices
    For $d = 0 To 2
        ; Si différents, on retourne false
        If UBound($m1,$d)<>UBound($m2,$d) Then Return False
    Next
    ; Pour chaque ligne et colonne
    For $i = 0 To UBound($m1,1)-1
        For $j = 0 To UBound($m1,2)-1
            ; Si différents, on retourne false
            If $m1[$i][$j]<>$m2[$i][$j] Then Return False
        Next
    Next
    Return True
EndFunc
; Fonction de détection d'un état sur un controle
Func isState($control,$state)
    Return BitAND(GUICtrlGetState($control),$state)=$state
EndFunc
; Fonction de détection du focus sur un controle
Func isFocused($control,$gui)
    Return GUICtrlGetHandle($control) = ControlGetHandle($gui,"",ControlGetFocus($gui))
EndFunc

; Fonction de vérification de la grille
Func estValide($grille)
    Local $resultat[9][9]
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            Local $case = "___"
            ; On ne vérifie que les cases dont la valeur est entre 1 et 9
            If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
                $case = _
                    cond(estValideSurLigne($grille,   $i,$j),"_","L") & _
                    cond(estValideSurColonne($grille, $i,$j),"_","C") & _
                    cond(estValideSurBloc($grille,    $i,$j),"_","B")
            EndIf
            $resultat[$i][$j] = $case
        Next
    Next
    Return $resultat
EndFunc

; Fonction de récupération des valeurs de la grille (chiffres entre 0 et 9)
Func getGrille($matrice)
    Local $grille[9][9]
    For $i=0 To 8
        For $j=0 To 8
            $grille[$i][$j] = Number(GUICtrlRead($matrice[$i][$j]))
            If Not StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then $grille[$i][$j] = 0
        Next
    Next
    Return $grille
EndFunc
#region estValideXXX
; Fonction de vérification des lignes
Func estValideSurLigne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $i = 0 To 8
        ; Si $valeur est présente sur la ligne (ailleurs qu'en [$x,$y]), on retourne False
        If $i<>$x And $grille[$i][$y]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurColonne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $j = 0 To 8
        ; Si $valeur est présente sur la colonne (ailleurs qu'en [$x,$y]), on retourne False
        If $j<>$y And $grille[$x][$j]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurBloc($grille, $x,$y)
    ; On détecte le bloc concerné par la valeur [$x,$y] ($bloc est un couple dont chaque valeur est entre 0 et 2)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    ; Pour chaque ligne et colonne de ce bloc
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            ; Si $valeur est présente sur le bloc (ailleurs qu'en [$x,$y]), on retourne False
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$grille[$x][$y] Then
                Return False
            EndIf
        Next
    Next
    Return True
EndFunc
#endregion
; Fonction de récupération des valeurs possibles pour une case donnée
Func getValeursPossibles($grille, $i,$j)
    Local $resultat[9]
    ; Pour chaque valeur possible (de 1 à 9, dans un tableau indexé de 0 à 8)
    For $n = 0 To 8
        ; Par défaut, $resultat[$n] = True, c'est à dire que la valeur est disponible
        $resultat[$n] = True
        ; On ne teste les valeurs possibles que si les valeurs $i et $j correspondent à un focus valide
        If $i<>-1 And $j<>-1 Then
            ; $n = 0 à 8, dont la valeur à traiter $val (qui est entre 1 et 9) est $n+1
            ; On détecte le bloc concerné par la valeur [$i,$j] ($bloc est un couple dont chaque valeur est entre 0 et 2)
            Local $val = $n+1, $bloc[2]=[ _
                cond($i>2,1,0)+cond($i>5,1,0), _
                cond($j>2,1,0)+cond($j>5,1,0)  _
            ]
            ; On vérifie sur la ligne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$j And $grille[$i][$x] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur la colonne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$i And $grille[$x][$j] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur le bloc concerné que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0+3*$bloc[0] To 2+3*$bloc[0]
                For $y = 0+3*$bloc[1] To 2+3*$bloc[1]
                    If $x<>$i And $y<>$j And $grille[$x][$y] = $val Then $resultat[$n] = False
                Next
            Next
        Else
            ; Pour les valeurs ayant des coordonnées invalides, on retourne False
            $resultat[$n] = False
        EndIf
    Next
    Return $resultat
EndFunc

Func _resolution($matrice, $option = 0)
        ; Récupération de la grille des valeurs
            If $option = 0 Then
            Do
            Local $grille = getGrille($matrice)
            Local $grille_avant = getGrille($matrice)
        _resoudre1( $grille ,1)
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($matrice)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
        If $option <> 0 Then
            Do
            Local $grille = $matrice
            Local $grille_avant = $grille
        _resoudre1( $grille )

            ; On recalcule la grille une fois modifiée
            Local $grille_apres = $grille
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
            Return $grille
    EndIf
    If Not _estTotalementRemplie($grille) Then
        _resoudre($grille)
        return $grille
    Else
        _remplirGrille($grille)
    EndIf
EndFunc

Func _resoudre1 ($grille,$option = 0)

            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grille[$i][$j] = $val
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$val)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                Next
            Next


EndFunc
Func _resoudre ($grille)


            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            ;on part d'une possibilité
                            If $possibilites[$k] Then
                                ; on copie un tableau
                                $resultatTest = $grille
                                ;on met notre essai
                                $resultatTest[$i][$j] = $k+1
                                Local $resultatProvisoire = _resolution($resultatTest, 1)

                                ;si ça marche youpi on met la grille dans la vraie
                                If _estValideBis ($resultatProvisoire) and _estTotalementRemplie($resultatProvisoire) Then
                                    $grille = $resultatProvisoire
                                    _remplirGrille($grille)
                                    ExitLoop

                                EndIf
                            EndIf

                        Next
                    EndIf
                Next
            Next


EndFunc
Func _estTotalementRemplie($grille)


For $i = 0 to 8
    for $j = 0 to 8

        If $grille[$i][$j] = 0 then return False

    Next
Next
return True
EndFunc

Func _estValideBis($grille)
   Local $estValide = estValide($grille)
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            If $estValide[$i][$j]<>"____" Then Return False
        Next
    Next
    Return True
EndFunc

Func _remplirGrille($grille)

    For $i = 0 to 8
        For $j = 0 to 8
            If $grille[$i][$j] <> 0 Then
            GUICtrlSetData($matrice[$i][$j],$grille[$i][$j])
            EndIf
        Next
    Next

EndFunc

Maintenant mon soucis se situe à l'affichage de la grille une fois finie (si elle passe par la résolution que j'appelle "par tests successifs")

Une idée?

[Tlem]

Ce que je trouve ahurissant dans ce sujet, c'est le code y est répété pratiquement à chaque message de guitarist !!!
Je vais donc surement (dés que le sujet aura trouvé une fin heureuse), faire un sacré ménage dans tout cela !

[guitarist]

Pardon Tlem mais comme mon code bouge énormément vu que c'est bagdad et que changé un algo ça demande pas mal de modif derriere. J'était un peu obligé :/

Je vais carrement te provoquer en mettant ma version actuelle car j'ai bosser 3heure ce midi (pas mangé).

Et la mon soucis c'est qu'il déconne à la résolution, j'ai des problemes de gestion de grilles je pense.

► Afficher le texte

Code : Tout sélectionner

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <Array.au3>
; Chaines possibles pour l'import des valeurs :
; 050310020010698540800020000007040080045000910090050700000060007076235090030089050
Global $resultatTest[9][9], $resultatTest2[9][9]
#Region Couleurs de l'interface
Global Const $SUDOKU_COLOR_OK = 0x0066FF, $SUDOKU_COLOR_KO = 0xFF6666, $SUDOKU_COLOR_NAN = 0xAAAAAA
#EndRegion

#Region Interface graphique générale
Local $GUI = GUICreate("Sudoku", 480, 363, 192, 132)
GUISetFont(12, 800, 0, "MS Mincho")
#EndRegion

#Region 9x9 cases à remplir du Sudoku
Global $matrice[9][9] , $resultatProvisoire[9][9]
; Pour chaque ligne et colonne
For $i=0 To 8
    For $j=0 To 8
        ; Position [X,Y] pour les cases à remplir du sudoku
        Local $x = 32+$i*32, $y = 40+$j*32
        ; Ajout d'un décalage de 10 px pour bien séparer les 3x3 blocs
        $x +=  cond($i>2,10,0)+cond($i>5,10,0)
        $y +=  cond($j>2,10,0)+cond($j>5,10,0)
        $matrice[$i][$j] = GUICtrlCreateInput("", $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

#Region Boutons d'actions
$Button1 = GUICtrlCreateButton("Lancer", 368, 40, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button1, $SUDOKU_COLOR_OK)
$Button2 = GUICtrlCreateButton("Importer", 368, 90, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button2, $SUDOKU_COLOR_OK)
$Button3 = GUICtrlCreateButton("Remplir", 368, 140, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button3, $SUDOKU_COLOR_OK)
;$Button4 = GUICtrlCreateButton ("B' T'",368,190,91,33,$WS_GROUP)
;GUICtrlSetColor($Button4, $SUDOKU_COLOR_OK)
;$Progress1 = GUICtrlCreateProgress(40, 0, 401, 33)
#EndRegion

#Region Pavé numérique pour l'affichage des valeurs possibles
Local $chiffres[9]
For $i=0 To 2
    For $j=0 To 2
        ; Position [X,Y] pour les boutons du pavé numérique
        Local $x = 368+$i*32, $y = 252+$j*32, $n=$i*3+$j
        $chiffres[$n] = GUICtrlCreateButton($n+1, $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($chiffres[$n], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

GUISetState(@SW_SHOW)
Local $focus_previous[2] = [-1,-1]

#Region Traitement des messages de l'interface
While 1
    Local $nMsg = GUIGetMsg()
    Switch $nMsg
    Case $GUI_EVENT_CLOSE
        Exit
        #region Buttons
        #region Button 1
    Case $Button1
        ; Récupération de la grille des valeurs
        Local $grille = getGrille($matrice)
        ; $estValide est une matrice 9x9 contenant dans chaque case une séries de 3 caractères {_,L,C,B}
        ; $checkGrille est à True si toute la grille est correcte
        Local $estValide = estValide($grille), $checkGrille = True
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; La case est correctement remplie si $estValide est égale à "___" en [$i,$j]
                Local $checkCase = ($estValide[$i][$j]="___")
                $checkGrille = $checkGrille And $checkCase
                ; Si $checkCase est à True, on met la case en bleu, sinon en rouge
                GUICtrlSetColor($matrice[$i][$j], cond($checkCase,$SUDOKU_COLOR_OK,$SUDOKU_COLOR_KO))
            Next
        Next
        ; Message Traytip pour prévenir de l'état de la grille
        TrayTip("Sudoku", cond($checkGrille,"Grille correcte", "Grille incorrecte"), 10, cond($checkGrille,1,3))
        #endregion
        #region Button 2
    Case $Button2
        ; On demande une chaine de 81 caractères (M:obligatoire, 81:taille demandée)
        Local $chaine = InputBox("Importer", "Entrez une chaine de 81 valeurs à importer"&@CRLF&"(1-9 pour les valeurs, 0 pour une valeur vide)", "", " M81")
        ; Si pas d'erreur, et 81 symboles entre 0 et 9, alors...
        If Not @error And StringRegExp($chaine, "^[0-9]{81}$") Then
            ; On sépare chaque caractère de la chaine, on en fait un tableau $split indexé à partir de 0
            Local $split = StringSplit($chaine,"",2)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; la valeur à mettre en [$i,$j] dans $matrice est en $j+9*$i dans $split
                    Local $valeur = Number($split[$j+$i*9])
                    ; Si la valeur n'est pas entre 1 et 9, on affiche la chaine vide
                    GUICtrlSetData($matrice[$i][$j], cond($valeur>0 And $valeur<10,$valeur,""))
                    ; On considère que chaque case est correcte, couleur bleue
                    GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
                Next
            Next
        EndIf
        #endregion
        #region Button 3
    Case $Button3
        _resolution($matrice)
        #endregion
        #region Button 4
;   Case $Button4
;       backT(getGrille($matrice),0)
;       #endregion
#region Buttons Chiffres
    Case Else
        ; Liste des boutons du pavé numérique
        For $i = 0 To 8
            ; Si on clique sur le bouton $i (Attention ! valeur du bouton:$i+1, car indexé de 0 à 8 pour les valeurs de 1 à 9)
            If $nMsg = $chiffres[$i] Then
                ; Si le focus est gardé sur une case valide du Sudoku,
                If $focus_previous[0]<>-1 And $focus_previous[1]<>-1 Then
                    ; On affiche la valeur du bouton (GUICtrlRead($chiffres[$i])) dans la case du Sudoku correspondant ($matrice[$focus_previous[0]][$focus_previous[1]])
                    GUICtrlSetData($matrice[$focus_previous[0]][$focus_previous[1]], GUICtrlRead($chiffres[$i]))
                EndIf
            EndIf
        Next
        ; Quel case a le focus?
        Local $focus[2] = [-1,-1] ; [-1,-1] correspond aux coordonnées d'un bouton ayant le focus, mais qui ne fait pas partie des cases du Sudoku
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; Si la case en [$i,$j] a le focus, on l'enregistre
                If isFocused($matrice[$i][$j],$GUI) Then
                    $focus[0]=$i
                    $focus[1]=$j
                EndIf
            Next
        Next
        ; Si le focus a changé depuis la dernière fois (et qu'il est "valide", autrement dit que c'est bien une case du Sudoku)
        If $focus[0]<>$focus_previous[0] Or $focus[1]<>$focus_previous[1] And $focus[0]<>-1 And $focus[1]<>-1 Then
            ; On enregistre dans $focus_previous la valeur actuelle, pour ne faire cette opération que si le focus change
            $focus_previous = $focus
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; On récupère la liste des valeurs possibles
            Local $possibilites = getValeursPossibles($grille, $focus[0],$focus[1])
            ; Pour chaque case du pavé
            For $i = 0 To 8
                ; Si la valeur est disponible, on active le bouton, sinon on le désactive
                GUICtrlSetState($chiffres[$i], cond($possibilites[$i],$GUI_ENABLE,$GUI_DISABLE))
            Next
        EndIf
        #endregion
        #endregion
    EndSwitch
WEnd

#region estPossibleSurX

Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités de le colonne
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités du bloc
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If ($i<>$x Or $j<>$y) And $grille[$i][$j] = 0 Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc
#endregion
; Fonction conditionnelle rapide
Func cond($cond, $true, $false)
    If $cond Then Return $true
    Return $false
EndFunc
; Fonction de comparaison de matrices
Func matrixEquals($m1,$m2)
    ; On teste d'abord les dimensions des deux matrices
    For $d = 0 To 2
        ; Si différents, on retourne false
        If UBound($m1,$d)<>UBound($m2,$d) Then Return False
    Next
    ; Pour chaque ligne et colonne
    For $i = 0 To UBound($m1,1)-1
        For $j = 0 To UBound($m1,2)-1
            ; Si différents, on retourne false
            If $m1[$i][$j]<>$m2[$i][$j] Then Return False
        Next
    Next
    Return True
EndFunc
; Fonction de détection d'un état sur un controle
Func isState($control,$state)
    Return BitAND(GUICtrlGetState($control),$state)=$state
EndFunc
; Fonction de détection du focus sur un controle
Func isFocused($control,$gui)
    Return GUICtrlGetHandle($control) = ControlGetHandle($gui,"",ControlGetFocus($gui))
EndFunc

; Fonction de vérification de la grille
Func estValide($grille)
    Local $resultat[9][9]
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            Local $case = "___"
            ; On ne vérifie que les cases dont la valeur est entre 1 et 9
            If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
                $case = _
                    cond(estValideSurLigne($grille,   $i,$j),"_","L") & _
                    cond(estValideSurColonne($grille, $i,$j),"_","C") & _
                    cond(estValideSurBloc($grille,    $i,$j),"_","B")
            EndIf
            $resultat[$i][$j] = $case
        Next
    Next
    Return $resultat
EndFunc

; Fonction de récupération des valeurs de la grille (chiffres entre 0 et 9)
Func getGrille($matrice)
    Local $grille[9][9]
    For $i=0 To 8
        For $j=0 To 8
            $grille[$i][$j] = Number(GUICtrlRead($matrice[$i][$j]))
            If Not StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then $grille[$i][$j] = 0
        Next
    Next
    Return $grille
EndFunc
#region estValideXXX
; Fonction de vérification des lignes
Func estValideSurLigne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $i = 0 To 8
        ; Si $valeur est présente sur la ligne (ailleurs qu'en [$x,$y]), on retourne False
        If $i<>$x And $grille[$i][$y]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurColonne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $j = 0 To 8
        ; Si $valeur est présente sur la colonne (ailleurs qu'en [$x,$y]), on retourne False
        If $j<>$y And $grille[$x][$j]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurBloc($grille, $x,$y)
    ; On détecte le bloc concerné par la valeur [$x,$y] ($bloc est un couple dont chaque valeur est entre 0 et 2)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    ; Pour chaque ligne et colonne de ce bloc
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            ; Si $valeur est présente sur le bloc (ailleurs qu'en [$x,$y]), on retourne False
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$grille[$x][$y] Then
                Return False
            EndIf
        Next
    Next
    Return True
EndFunc
#endregion
; Fonction de récupération des valeurs possibles pour une case donnée
Func getValeursPossibles($grille, $i,$j)
    Local $resultat[9]
    ; Pour chaque valeur possible (de 1 à 9, dans un tableau indexé de 0 à 8)
    For $n = 0 To 8
        ; Par défaut, $resultat[$n] = True, c'est à dire que la valeur est disponible
        $resultat[$n] = True
        ; On ne teste les valeurs possibles que si les valeurs $i et $j correspondent à un focus valide
        If $i<>-1 And $j<>-1 Then
            ; $n = 0 à 8, dont la valeur à traiter $val (qui est entre 1 et 9) est $n+1
            ; On détecte le bloc concerné par la valeur [$i,$j] ($bloc est un couple dont chaque valeur est entre 0 et 2)
            Local $val = $n+1, $bloc[2]=[ _
                cond($i>2,1,0)+cond($i>5,1,0), _
                cond($j>2,1,0)+cond($j>5,1,0)  _
            ]
            ; On vérifie sur la ligne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$j And $grille[$i][$x] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur la colonne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$i And $grille[$x][$j] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur le bloc concerné que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0+3*$bloc[0] To 2+3*$bloc[0]
                For $y = 0+3*$bloc[1] To 2+3*$bloc[1]
                    If $x<>$i And $y<>$j And $grille[$x][$y] = $val Then $resultat[$n] = False
                Next
            Next
        Else
            ; Pour les valeurs ayant des coordonnées invalides, on retourne False
            $resultat[$n] = False
        EndIf
    Next
    Return $resultat
EndFunc

Func _resolution($grillade, $option = 0)
        ; Récupération de la grille des valeurs
            If $option = 0 Then
            Do
            Local $grille = getGrille($grillade)
            Local $grille_avant = getGrille($grillade)
        _resoudre1( $grille ,1)
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($grillade)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
        If $option <> 0 Then
            Do
            Local $grille = $grillade
            Local $grille_avant = $grille
        _resoudre1( $grille,1 )

            ; On recalcule la grille une fois modifiée
            Local $grille_apres = $grille
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
            Return $grille
    EndIf
    If Not _estTotalementRemplie($grille) Then
        _resoudre($grille)
        return $grille
    Else
        _remplirGrille($grille)
    EndIf
EndFunc

Func _resoudre1 ($grille,$option = 0)

            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grille[$i][$j] = $val
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$val)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option <> 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k + 1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                    _estValideBis(getGrille($matrice))
                Next
            Next


EndFunc
Func _resoudre ($grille)


            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; on copie un tableau
                        $resultatTest = _scinderGrilles($grille,$resultatTest)
                        ; On compte
                        For $k = 0 to 8
                            ;on part d'une possibilité
                            If $possibilites[$k] Then

                                ;on met notre essai
                                $resultatTest[$i][$j] = $k+1
                                GUICtrlSetData($matrice[$i][$j],$k+1)
                                $resultatTest2 = _resolution($resultatTest,1)
                                If  _estValideBis ($resultatTest2) Then
                                    ExitLoop
                                    _remplirGrille($grille)
                                Else
                                    $resultatTest[$i][$j] = 0
                                    GUICtrlSetData($matrice[$i][$j],"")
                                EndIf

                            EndIf

                        Next

                    EndIf
                Next
            Next
                                ;si ça marche youpi on met la grille dans la vraie
                            If _estValideBis ($resultatTest) and _estTotalementRemplie($matrice) Then
                                $grille = $resultatTest
                                _remplirGrille($grille)
                            ElseIf _estValideBis($resultatTest) and Not _estTotalementRemplie($matrice) Then
                                _resolution($resultatTest,1)
                            ElseIf Not _estValideBis($resultatTest) And _estTotalementRemplie($matrice) Then
                                _resolution($grille)
                                _remplirGrille($grille)
                            EndIf

EndFunc
Func _estTotalementRemplie($grille)


For $i = 0 to 8
    for $j = 0 to 8

        If $grille[$i][$j] = 0 then return False

    Next
Next
return True
EndFunc

Func _estValideBis($grille)
   Local $estValide = estValide($grille)
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            If $estValide[$i][$j]<>"____" Then
            $matrice[$i][$j] = 0
            Return False
            EndIf
        Next
    Next
    Return True
EndFunc

Func _remplirGrille($grille)

    For $i = 0 to 8
        For $j = 0 to 8
            If $grille[$i][$j] <> 0 Then
            GUICtrlSetData($matrice[$i][$j],$grille[$i][$j])
            EndIf
        Next
    Next

EndFunc
Func _scinderGrilles($grille1,$grille2)

    For $i = 0 to 8
        For $j = 0 to 8

        If $grille2[$i][$j] = 0 Then
            $grille2[$i][$j] = $grille1[$i][$j]
        EndIf

        Next
    Next
    Return $grille2

EndFunc

Et pardon Tlem

Ok je modifie le début et bye bye le reste

[ZDS]

Au lieu de reposter à chaque fois, modifie ton premier message avec le nouveau code.
(Profites-en pour retirer les milliers de lignes de code des autres messages)

[guitarist]

Voilà j'ai nettoyé un peu , du coup faut supprimer pas mal de messages inutiles maintenant.


Bon rien ne va plus niveau code

Voilà ce que j'ai (oui je reposte encore désolé)

► Afficher le texte

Code : Tout sélectionner

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <Array.au3>
; Chaines possibles pour l'import des valeurs :
; 050310020010698540800020000007040080045000910090050700000060007076235090030089050
Global $resultatTest[9][9], $resultatTest2[9][9]
#Region Couleurs de l'interface
Global Const $SUDOKU_COLOR_OK = 0x0066FF, $SUDOKU_COLOR_KO = 0xFF6666, $SUDOKU_COLOR_NAN = 0xAAAAAA
#EndRegion

#Region Interface graphique générale
Local $GUI = GUICreate("Sudoku", 480, 363, 192, 132)
GUISetFont(12, 800, 0, "MS Mincho")
#EndRegion

#Region 9x9 cases à remplir du Sudoku
Global $matrice[9][9] , $resultatProvisoire[9][9]
; Pour chaque ligne et colonne
For $i=0 To 8
    For $j=0 To 8
        ; Position [X,Y] pour les cases à remplir du sudoku
        Local $x = 32+$i*32, $y = 40+$j*32
        ; Ajout d'un décalage de 10 px pour bien séparer les 3x3 blocs
        $x +=  cond($i>2,10,0)+cond($i>5,10,0)
        $y +=  cond($j>2,10,0)+cond($j>5,10,0)
        $matrice[$i][$j] = GUICtrlCreateInput("", $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

#Region Boutons d'actions
$Button1 = GUICtrlCreateButton("Lancer", 368, 40, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button1, $SUDOKU_COLOR_OK)
$Button2 = GUICtrlCreateButton("Importer", 368, 90, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button2, $SUDOKU_COLOR_OK)
$Button3 = GUICtrlCreateButton("Remplir", 368, 140, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button3, $SUDOKU_COLOR_OK)
;$Button4 = GUICtrlCreateButton ("B' T'",368,190,91,33,$WS_GROUP)
;GUICtrlSetColor($Button4, $SUDOKU_COLOR_OK)
;$Progress1 = GUICtrlCreateProgress(40, 0, 401, 33)
#EndRegion

#Region Pavé numérique pour l'affichage des valeurs possibles
Local $chiffres[9]
For $i=0 To 2
    For $j=0 To 2
        ; Position [X,Y] pour les boutons du pavé numérique
        Local $x = 368+$i*32, $y = 252+$j*32, $n=$i*3+$j
        $chiffres[$n] = GUICtrlCreateButton($n+1, $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($chiffres[$n], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

GUISetState(@SW_SHOW)
Local $focus_previous[2] = [-1,-1]

#Region Traitement des messages de l'interface
While 1
    Local $nMsg = GUIGetMsg()
    Switch $nMsg
    Case $GUI_EVENT_CLOSE
        Exit
        #region Buttons
        #region Button 1
    Case $Button1
        ; Récupération de la grille des valeurs
        Local $grille = getGrille($matrice)
        ; $estValide est une matrice 9x9 contenant dans chaque case une séries de 3 caractères {_,L,C,B}
        ; $checkGrille est à True si toute la grille est correcte
        Local $estValide = estValide($grille), $checkGrille = True
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; La case est correctement remplie si $estValide est égale à "___" en [$i,$j]
                Local $checkCase = ($estValide[$i][$j]="___")
                $checkGrille = $checkGrille And $checkCase
                ; Si $checkCase est à True, on met la case en bleu, sinon en rouge
                GUICtrlSetColor($matrice[$i][$j], cond($checkCase,$SUDOKU_COLOR_OK,$SUDOKU_COLOR_KO))
            Next
        Next
        ; Message Traytip pour prévenir de l'état de la grille
        TrayTip("Sudoku", cond($checkGrille,"Grille correcte", "Grille incorrecte"), 10, cond($checkGrille,1,3))
        #endregion
        #region Button 2
    Case $Button2
        ; On demande une chaine de 81 caractères (M:obligatoire, 81:taille demandée)
        Local $chaine = InputBox("Importer", "Entrez une chaine de 81 valeurs à importer"&@CRLF&"(1-9 pour les valeurs, 0 pour une valeur vide)", "", " M81")
        ; Si pas d'erreur, et 81 symboles entre 0 et 9, alors...
        If Not @error And StringRegExp($chaine, "^[0-9]{81}$") Then
            ; On sépare chaque caractère de la chaine, on en fait un tableau $split indexé à partir de 0
            Local $split = StringSplit($chaine,"",2)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; la valeur à mettre en [$i,$j] dans $matrice est en $j+9*$i dans $split
                    Local $valeur = Number($split[$j+$i*9])
                    ; Si la valeur n'est pas entre 1 et 9, on affiche la chaine vide
                    GUICtrlSetData($matrice[$i][$j], cond($valeur>0 And $valeur<10,$valeur,""))
                    ; On considère que chaque case est correcte, couleur bleue
                    GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
                Next
            Next
        EndIf
        #endregion
        #region Button 3
    Case $Button3
        _resolution($matrice)
        #endregion
        #region Button 4
;   Case $Button4
;       backT(getGrille($matrice),0)
;       #endregion
#region Buttons Chiffres
    Case Else
        ; Liste des boutons du pavé numérique
        For $i = 0 To 8
            ; Si on clique sur le bouton $i (Attention ! valeur du bouton:$i+1, car indexé de 0 à 8 pour les valeurs de 1 à 9)
            If $nMsg = $chiffres[$i] Then
                ; Si le focus est gardé sur une case valide du Sudoku,
                If $focus_previous[0]<>-1 And $focus_previous[1]<>-1 Then
                    ; On affiche la valeur du bouton (GUICtrlRead($chiffres[$i])) dans la case du Sudoku correspondant ($matrice[$focus_previous[0]][$focus_previous[1]])
                    GUICtrlSetData($matrice[$focus_previous[0]][$focus_previous[1]], GUICtrlRead($chiffres[$i]))
                EndIf
            EndIf
        Next
        ; Quel case a le focus?
        Local $focus[2] = [-1,-1] ; [-1,-1] correspond aux coordonnées d'un bouton ayant le focus, mais qui ne fait pas partie des cases du Sudoku
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; Si la case en [$i,$j] a le focus, on l'enregistre
                If isFocused($matrice[$i][$j],$GUI) Then
                    $focus[0]=$i
                    $focus[1]=$j
                EndIf
            Next
        Next
        ; Si le focus a changé depuis la dernière fois (et qu'il est "valide", autrement dit que c'est bien une case du Sudoku)
        If $focus[0]<>$focus_previous[0] Or $focus[1]<>$focus_previous[1] And $focus[0]<>-1 And $focus[1]<>-1 Then
            ; On enregistre dans $focus_previous la valeur actuelle, pour ne faire cette opération que si le focus change
            $focus_previous = $focus
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; On récupère la liste des valeurs possibles
            Local $possibilites = getValeursPossibles($grille, $focus[0],$focus[1])
            ; Pour chaque case du pavé
            For $i = 0 To 8
                ; Si la valeur est disponible, on active le bouton, sinon on le désactive
                GUICtrlSetState($chiffres[$i], cond($possibilites[$i],$GUI_ENABLE,$GUI_DISABLE))
            Next
        EndIf
        #endregion
        #endregion
    EndSwitch
WEnd

#region estPossibleSurX

Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités de le colonne
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités du bloc
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If ($i<>$x Or $j<>$y) And $grille[$i][$j] = 0 Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc
#endregion
; Fonction conditionnelle rapide
Func cond($cond, $true, $false)
    If $cond Then Return $true
    Return $false
EndFunc
; Fonction de comparaison de matrices
Func matrixEquals($m1,$m2)
    ; On teste d'abord les dimensions des deux matrices
    For $d = 0 To 2
        ; Si différents, on retourne false
        If UBound($m1,$d)<>UBound($m2,$d) Then Return False
    Next
    ; Pour chaque ligne et colonne
    For $i = 0 To UBound($m1,1)-1
        For $j = 0 To UBound($m1,2)-1
            ; Si différents, on retourne false
            If $m1[$i][$j]<>$m2[$i][$j] Then Return False
        Next
    Next
    Return True
EndFunc
; Fonction de détection d'un état sur un controle
Func isState($control,$state)
    Return BitAND(GUICtrlGetState($control),$state)=$state
EndFunc
; Fonction de détection du focus sur un controle
Func isFocused($control,$gui)
    Return GUICtrlGetHandle($control) = ControlGetHandle($gui,"",ControlGetFocus($gui))
EndFunc

; Fonction de vérification de la grille
Func estValide($grille)
    Local $resultat[9][9]
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            Local $case = "___"
            ; On ne vérifie que les cases dont la valeur est entre 1 et 9
            If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
                $case = _
                    cond(estValideSurLigne($grille,   $i,$j),"_","L") & _
                    cond(estValideSurColonne($grille, $i,$j),"_","C") & _
                    cond(estValideSurBloc($grille,    $i,$j),"_","B")
            EndIf
            $resultat[$i][$j] = $case
        Next
    Next
    Return $resultat
EndFunc

; Fonction de récupération des valeurs de la grille (chiffres entre 0 et 9)
Func getGrille($matrice)
    Local $grille[9][9]
    For $i=0 To 8
        For $j=0 To 8
            $grille[$i][$j] = Number(GUICtrlRead($matrice[$i][$j]))
            If Not StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then $grille[$i][$j] = 0
        Next
    Next
    Return $grille
EndFunc
#region estValideXXX
; Fonction de vérification des lignes
Func estValideSurLigne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $i = 0 To 8
        ; Si $valeur est présente sur la ligne (ailleurs qu'en [$x,$y]), on retourne False
        If $i<>$x And $grille[$i][$y]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurColonne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $j = 0 To 8
        ; Si $valeur est présente sur la colonne (ailleurs qu'en [$x,$y]), on retourne False
        If $j<>$y And $grille[$x][$j]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurBloc($grille, $x,$y)
    ; On détecte le bloc concerné par la valeur [$x,$y] ($bloc est un couple dont chaque valeur est entre 0 et 2)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    ; Pour chaque ligne et colonne de ce bloc
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            ; Si $valeur est présente sur le bloc (ailleurs qu'en [$x,$y]), on retourne False
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$grille[$x][$y] Then
                Return False
            EndIf
        Next
    Next
    Return True
EndFunc
#endregion
; Fonction de récupération des valeurs possibles pour une case donnée
Func getValeursPossibles($grille, $i,$j)
    Local $resultat[9]
    ; Pour chaque valeur possible (de 1 à 9, dans un tableau indexé de 0 à 8)
    For $n = 0 To 8
        ; Par défaut, $resultat[$n] = True, c'est à dire que la valeur est disponible
        $resultat[$n] = True
        ; On ne teste les valeurs possibles que si les valeurs $i et $j correspondent à un focus valide
        If $i<>-1 And $j<>-1 Then
            ; $n = 0 à 8, dont la valeur à traiter $val (qui est entre 1 et 9) est $n+1
            ; On détecte le bloc concerné par la valeur [$i,$j] ($bloc est un couple dont chaque valeur est entre 0 et 2)
            Local $val = $n+1, $bloc[2]=[ _
                cond($i>2,1,0)+cond($i>5,1,0), _
                cond($j>2,1,0)+cond($j>5,1,0)  _
            ]
            ; On vérifie sur la ligne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$j And $grille[$i][$x] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur la colonne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$i And $grille[$x][$j] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur le bloc concerné que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0+3*$bloc[0] To 2+3*$bloc[0]
                For $y = 0+3*$bloc[1] To 2+3*$bloc[1]
                    If $x<>$i And $y<>$j And $grille[$x][$y] = $val Then $resultat[$n] = False
                Next
            Next
        Else
            ; Pour les valeurs ayant des coordonnées invalides, on retourne False
            $resultat[$n] = False
        EndIf
    Next
    Return $resultat
EndFunc

Func _resolution($grillade, $option = 0)
        ; Récupération de la grille des valeurs
    If $option = 0 Then
            Do
            Local $grille = getGrille($grillade)
            Local $grille_avant = getGrille($grillade)
        _resoudre1( $grille)
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($grillade)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
    If $option <> 0 Then
            Do
            Local $grille = $grillade
            Local $grille_avant = $grille
             Local $grille_apres =     _resoudre1( $grille)

            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
    If Not _estTotalementRemplie(getGrille($matrice)) Then
        _resoudre(getGrille($matrice))
        return getGrille($matrice)
    Else
        _remplirGrille(getGrille($matrice))
        return getGrille($matrice)
    EndIf
EndFunc

Func _resoudre1 ($grille)

            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grille[$i][$j] = $val
                                GUICtrlSetData($matrice[$i][$j],$val)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                GUICtrlSetData($matrice[$i][$j],$k + 1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                GUICtrlSetData($matrice[$i][$j],$k + 1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                GUICtrlSetData($matrice[$i][$j],$k + 1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                Next
            Next
    Return $grille

EndFunc
Func _resoudre ($grille)


            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; on copie un tableau
                        $resultatTest = _scinderGrilles($grille,$resultatTest)
                        ; On compte
                        For $k = 0 to 8
                            MsgBox(0,"","")
                            ;on part d'une possibilité
                            If $possibilites[$k] Then

                                ;on met notre essai
                                $resultatTest[$i][$j] = $k+1
                                _remplirGrille($resultatTest)
                                MsgBox(0,"","")
                                $resultatTest2 = _resolution($resultatTest,1)
                                MsgBox(0,"","")
                                If  _estValideBis ($resultatTest2) Then

                            MsgBox(0,"","")
                                    Return True
                                Else
                                    $resultatTest[$i][$j] = 0
                                    $grille[$i][$j] = 0
                                    GUICtrlSetData($matrice[$i][$j],"")
                                    MsgBox(0,"","2")
                                EndIf

                            MsgBox(0,"","")
                            EndIf

                        Next

                    EndIf
                Next
            Next
                                ;si ça marche youpi on met la grille dans la vraie
                            If _estValideBis ($resultatTest) and _estTotalementRemplie($matrice) Then
                                $grille = $resultatTest
                                _remplirGrille($grille)
                                MsgBox(0,"","3")
                            ElseIf _estValideBis($resultatTest) and Not _estTotalementRemplie($matrice) Then
                                _resolution($resultatTest,1)
                                MsgBox(0,"","4")
                            ElseIf Not _estValideBis($resultatTest) And _estTotalementRemplie($matrice) Then
                                _resolution($grille,1)
                                MsgBox(0,"","5")
                                _remplirGrille($grille)
                            EndIf

EndFunc
Func _estTotalementRemplie($grille)


For $i = 0 to 8
    for $j = 0 to 8

        If $grille[$i][$j] = 0 then return False

    Next
Next
return True
EndFunc

Func _estValideBis($grille)
   Local $estValide = estValide($grille)
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            If $estValide[$i][$j]<>"____" Then
            Return False
            EndIf
        Next
    Next
    Return True
EndFunc

Func _remplirGrille($grille)

    For $i = 0 to 8
        For $j = 0 to 8
            If $grille[$i][$j] <> 0 Then
            GUICtrlSetData($matrice[$i][$j],$grille[$i][$j])
            EndIf
        Next
    Next

EndFunc
Func _scinderGrilles($grille1,$grille2)

    For $i = 0 to 8
        For $j = 0 to 8

        If $grille2[$i][$j] = 0 Then
            $grille2[$i][$j] = $grille1[$i][$j]
        EndIf

        Next
    Next
    Return $grille2

EndFunc

Pour le coup il tourne dans le vide sans donner signe de vie. -_-
Bref help :/

[guitarist]

Up

Voilà j'ai travaillé (bon y a des moment je fait du surplace c'est vrai) mais maintenant mon seul soucis viens au moment d'afficher la grille, rien ne se passe.

Tu veux bien jeter un coup d'oeil ZDS?
Voilà mes 3 fonctions :

► Afficher le texte

Code : Tout sélectionner

Func _resolution($grillade, $option = 0,$grilleatest = 0)
        ; Récupération de la grille des valeurs
            If $option = 0 Then
            Do
            Local $grille = getGrille($grillade)
            Local $grille_avant = getGrille($grillade)
        _resoudre1( $grille)
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($grillade)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
        If $option <> 0 Then
        Do
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = _resoudre1( $grillade,1)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until $grille_apres = False
    EndIf
    If Not _estTotalementRemplie(getGrille($matrice)) Then
        If $grilleatest <> 0 Then
        _resoudre($grillade)
        Else
            _resoudre (getGrille($matrice) )
        EndIf
    Else
        MsgBox(0,"","Fini")
        Return True
    EndIf
EndFunc

Func _resoudre1 ($grille,$option = 0)
Local $grille_avant2[9][9]
$grille_avant2= $grille
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grille[$i][$j] = $val
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$val)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                Next
            Next
            If $grille_avant2 <> $grille Then
                Return False
            Else
                Return True
            EndIf
EndFunc
Func _resoudre ($grille)
$GrilleTest = _scinderGrilles ($grille,$GrilleTest)
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $GrilleTest[$i][$j] = 0 Then
                         ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($GrilleTest, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $GrilleTest[$i][$j] = $k + 1
                                If _estTotalementRemplie($GrilleTest) Then
                                _remplirGrille($GrilleTest)
                                MsgBox(0,"","Fini²")
                                EndIf
                                If _resolution($GrilleTest,1,1) Then
                                    Return $GrilleTest
                                EndIf

                            EndIf
                        Next
                    EndIf
                Next
            Next


EndFunc

[ZDS]

Bonjour,

Avant que je regarde, mets à jour ton premier post avec le code plus ou moins fonctionnel, parce que là je me ramasse des erreurs type :

WARNING: Func _resoudre ($grille) => $GrilleTest: possibly used before declaration. $GrilleTest = _scinderGrilles ($grille,$GrilleTest)

J'y jetterai un coup d'oeil quand tu auras édité avec qq chose sans erreur (sinon à premiere vue ton souci d'affichage vient de ta variable $option qui est le plus souvent à 0).

A bientôt.

[guitarist]

Bon en fait je pense avoir fini, j'ai changé mon point de vu et ça marche mieux

► Afficher le texte

Code : Tout sélectionner

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
#include <Array.au3>
; Chaines possibles pour l'import des valeurs :
; 050310020010698540800020000007040080045000910090050700000060007076235090030089050
Global $GrilleTest[9][9]
#Region Couleurs de l'interface
Global Const $SUDOKU_COLOR_OK = 0x0066FF, $SUDOKU_COLOR_KO = 0xFF6666, $SUDOKU_COLOR_NAN = 0xAAAAAA
#EndRegion

#Region Interface graphique générale
Local $GUI = GUICreate("Sudoku", 480, 363, 192, 132)
GUISetFont(12, 800, 0, "MS Mincho")
#EndRegion

#Region 9x9 cases à remplir du Sudoku
Global $matrice[9][9] , $resultatProvisoire[9][9]
; Pour chaque ligne et colonne
For $i=0 To 8
    For $j=0 To 8
        ; Position [X,Y] pour les cases à remplir du sudoku
        Local $x = 32+$i*32, $y = 40+$j*32
        ; Ajout d'un décalage de 10 px pour bien séparer les 3x3 blocs
        $x +=  cond($i>2,10,0)+cond($i>5,10,0)
        $y +=  cond($j>2,10,0)+cond($j>5,10,0)
        $matrice[$i][$j] = GUICtrlCreateInput("", $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

#Region Boutons d'actions
$Button1 = GUICtrlCreateButton("Lancer", 368, 40, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button1, $SUDOKU_COLOR_OK)
$Button2 = GUICtrlCreateButton("Importer", 368, 90, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button2, $SUDOKU_COLOR_OK)
$Button3 = GUICtrlCreateButton("Remplir", 368, 140, 91, 33, $WS_GROUP)
GUICtrlSetColor($Button3, $SUDOKU_COLOR_OK)
;$Button4 = GUICtrlCreateButton ("B' T'",368,190,91,33,$WS_GROUP)
;GUICtrlSetColor($Button4, $SUDOKU_COLOR_OK)
;$Progress1 = GUICtrlCreateProgress(40, 0, 401, 33)
#EndRegion

#Region Pavé numérique pour l'affichage des valeurs possibles
Local $chiffres[9]
For $i=0 To 2
    For $j=0 To 2
        ; Position [X,Y] pour les boutons du pavé numérique
        Local $x = 368+$i*32, $y = 252+$j*32, $n=$i*3+$j
        $chiffres[$n] = GUICtrlCreateButton($n+1, $x, $y, 25, 25, $ES_CENTER)
        GUICtrlSetColor($chiffres[$n], $SUDOKU_COLOR_OK)
    Next
Next
#EndRegion

GUISetState(@SW_SHOW)
Local $focus_previous[2] = [-1,-1]

#Region Traitement des messages de l'interface
While 1
    Local $nMsg = GUIGetMsg()
    Switch $nMsg
    Case $GUI_EVENT_CLOSE
        Exit
        #region Buttons
        #region Button 1
    Case $Button1
        ; Récupération de la grille des valeurs
        Local $grille = getGrille($matrice)
        ; $estValide est une matrice 9x9 contenant dans chaque case une séries de 3 caractères {_,L,C,B}
        ; $checkGrille est à True si toute la grille est correcte
        Local $estValide = estValide($grille), $checkGrille = True
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; La case est correctement remplie si $estValide est égale à "___" en [$i,$j]
                Local $checkCase = ($estValide[$i][$j]="___")
                $checkGrille = $checkGrille And $checkCase
                ; Si $checkCase est à True, on met la case en bleu, sinon en rouge
                GUICtrlSetColor($matrice[$i][$j], cond($checkCase,$SUDOKU_COLOR_OK,$SUDOKU_COLOR_KO))
            Next
        Next
        ; Message Traytip pour prévenir de l'état de la grille
        TrayTip("Sudoku", cond($checkGrille,"Grille correcte", "Grille incorrecte"), 10, cond($checkGrille,1,3))
        #endregion
        #region Button 2
    Case $Button2
        ; On demande une chaine de 81 caractères (M:obligatoire, 81:taille demandée)
        Local $chaine = InputBox("Importer", "Entrez une chaine de 81 valeurs à importer"&@CRLF&"(1-9 pour les valeurs, 0 pour une valeur vide)", "", " M81")
        ; Si pas d'erreur, et 81 symboles entre 0 et 9, alors...
        If Not @error And StringRegExp($chaine, "^[0-9]{81}$") Then
            ; On sépare chaque caractère de la chaine, on en fait un tableau $split indexé à partir de 0
            Local $split = StringSplit($chaine,"",2)
            ; Pour chaque ligne et colonne
            For $i = 0 To 8
                For $j = 0 To 8
                    ; la valeur à mettre en [$i,$j] dans $matrice est en $j+9*$i dans $split
                    Local $valeur = Number($split[$j+$i*9])
                    ; Si la valeur n'est pas entre 1 et 9, on affiche la chaine vide
                    GUICtrlSetData($matrice[$i][$j], cond($valeur>0 And $valeur<10,$valeur,""))
                    ; On considère que chaque case est correcte, couleur bleue
                    GUICtrlSetColor($matrice[$i][$j], $SUDOKU_COLOR_OK)
                Next
            Next
        EndIf
        #endregion
        #region Button 3
    Case $Button3
        _resolution($matrice)
        #endregion
        #region Button 4
;   Case $Button4
;       backT(getGrille($matrice),0)
;       #endregion
#region Buttons Chiffres
    Case Else
        ; Liste des boutons du pavé numérique
        For $i = 0 To 8
            ; Si on clique sur le bouton $i (Attention ! valeur du bouton:$i+1, car indexé de 0 à 8 pour les valeurs de 1 à 9)
            If $nMsg = $chiffres[$i] Then
                ; Si le focus est gardé sur une case valide du Sudoku,
                If $focus_previous[0]<>-1 And $focus_previous[1]<>-1 Then
                    ; On affiche la valeur du bouton (GUICtrlRead($chiffres[$i])) dans la case du Sudoku correspondant ($matrice[$focus_previous[0]][$focus_previous[1]])
                    GUICtrlSetData($matrice[$focus_previous[0]][$focus_previous[1]], GUICtrlRead($chiffres[$i]))
                EndIf
            EndIf
        Next
        ; Quel case a le focus?
        Local $focus[2] = [-1,-1] ; [-1,-1] correspond aux coordonnées d'un bouton ayant le focus, mais qui ne fait pas partie des cases du Sudoku
        ; Pour chaque ligne et colonne
        For $i = 0 To 8
            For $j = 0 To 8
                ; Si la case en [$i,$j] a le focus, on l'enregistre
                If isFocused($matrice[$i][$j],$GUI) Then
                    $focus[0]=$i
                    $focus[1]=$j
                EndIf
            Next
        Next
        ; Si le focus a changé depuis la dernière fois (et qu'il est "valide", autrement dit que c'est bien une case du Sudoku)
        If $focus[0]<>$focus_previous[0] Or $focus[1]<>$focus_previous[1] And $focus[0]<>-1 And $focus[1]<>-1 Then
            ; On enregistre dans $focus_previous la valeur actuelle, pour ne faire cette opération que si le focus change
            $focus_previous = $focus
            ; Récupération de la grille des valeurs
            Local $grille = getGrille($matrice)
            ; On récupère la liste des valeurs possibles
            Local $possibilites = getValeursPossibles($grille, $focus[0],$focus[1])
            ; Pour chaque case du pavé
            For $i = 0 To 8
                ; Si la valeur est disponible, on active le bouton, sinon on le désactive
                GUICtrlSetState($chiffres[$i], cond($possibilites[$i],$GUI_ENABLE,$GUI_DISABLE))
            Next
        EndIf
        #endregion
        #endregion
    EndSwitch
WEnd

#region estPossibleSurX

Func estPossibleSurLigne($grille, $x,$y, $val)
    For $i = 0 To 8
        If $i<>$x Then
            Local $possibilites = getValeursPossibles($grille, $i,$y)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités de le colonne
Func estPossibleSurColonne($grille, $x,$y, $val)
    For $j = 0 To 8
        If $j<>$y Then
            Local $possibilites = getValeursPossibles($grille, $x,$j)
            If $possibilites[$val-1] Then Return True
        EndIf
    Next
    Return False
EndFunc
; Fonction de vérification des possibilités du bloc
Func estPossibleSurBloc($grille, $x,$y, $val)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            If ($i<>$x Or $j<>$y) And $grille[$i][$j] = 0 Then
                Local $possibilites = getValeursPossibles($grille, $i,$j)
                If $possibilites[$val-1] Then Return True
            EndIf
        Next
    Next
    Return False
EndFunc
#endregion
; Fonction conditionnelle rapide
Func cond($cond, $true, $false)
    If $cond Then Return $true
    Return $false
EndFunc
; Fonction de comparaison de matrices
Func matrixEquals($m1,$m2)
    ; On teste d'abord les dimensions des deux matrices
    For $d = 0 To 2
        ; Si différents, on retourne false
        If UBound($m1,$d)<>UBound($m2,$d) Then Return False
    Next
    ; Pour chaque ligne et colonne
    For $i = 0 To UBound($m1,1)-1
        For $j = 0 To UBound($m1,2)-1
            ; Si différents, on retourne false
            If $m1[$i][$j]<>$m2[$i][$j] Then Return False
        Next
    Next
    Return True
EndFunc
; Fonction de détection d'un état sur un controle
Func isState($control,$state)
    Return BitAND(GUICtrlGetState($control),$state)=$state
EndFunc
; Fonction de détection du focus sur un controle
Func isFocused($control,$gui)
    Return GUICtrlGetHandle($control) = ControlGetHandle($gui,"",ControlGetFocus($gui))
EndFunc

; Fonction de vérification de la grille
Func estValide($grille)
    Local $resultat[9][9]
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            Local $case = "___"
            ; On ne vérifie que les cases dont la valeur est entre 1 et 9
            If StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then
                $case = _
                    cond(estValideSurLigne($grille,   $i,$j),"_","L") & _
                    cond(estValideSurColonne($grille, $i,$j),"_","C") & _
                    cond(estValideSurBloc($grille,    $i,$j),"_","B")
            EndIf
            $resultat[$i][$j] = $case
        Next
    Next
    Return $resultat
EndFunc

; Fonction de récupération des valeurs de la grille (chiffres entre 0 et 9)
Func getGrille($matrice)
    Local $grille[9][9]
    For $i=0 To 8
        For $j=0 To 8
            $grille[$i][$j] = Number(GUICtrlRead($matrice[$i][$j]))
            If Not StringRegExp($grille[$i][$j]&"", "^[1-9]$") Then $grille[$i][$j] = 0
        Next
    Next
    Return $grille
EndFunc
#region estValideXXX
; Fonction de vérification des lignes
Func estValideSurLigne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $i = 0 To 8
        ; Si $valeur est présente sur la ligne (ailleurs qu'en [$x,$y]), on retourne False
        If $i<>$x And $grille[$i][$y]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurColonne($grille, $x,$y)
    Local $valeur = $grille[$x][$y]
    For $j = 0 To 8
        ; Si $valeur est présente sur la colonne (ailleurs qu'en [$x,$y]), on retourne False
        If $j<>$y And $grille[$x][$j]=$valeur Then
            Return False
        EndIf
    Next
    Return True
EndFunc
; Fonction de vérification des lignes
Func estValideSurBloc($grille, $x,$y)
    ; On détecte le bloc concerné par la valeur [$x,$y] ($bloc est un couple dont chaque valeur est entre 0 et 2)
    Local $bloc[2]=[ _
        cond($x>2,1,0)+cond($x>5,1,0), _
        cond($y>2,1,0)+cond($y>5,1,0)  _
    ]
    ; Pour chaque ligne et colonne de ce bloc
    For $i = 0+3*$bloc[0] To 2+3*$bloc[0]
        For $j = 0+3*$bloc[1] To 2+3*$bloc[1]
            ; Si $valeur est présente sur le bloc (ailleurs qu'en [$x,$y]), on retourne False
            If ($i<>$x Or $j<>$y) And $grille[$i][$j]=$grille[$x][$y] Then
                Return False
            EndIf
        Next
    Next
    Return True
EndFunc
#endregion
; Fonction de récupération des valeurs possibles pour une case donnée
Func getValeursPossibles($grille, $i,$j)
    Local $resultat[9]
    ; Pour chaque valeur possible (de 1 à 9, dans un tableau indexé de 0 à 8)
    For $n = 0 To 8
        ; Par défaut, $resultat[$n] = True, c'est à dire que la valeur est disponible
        $resultat[$n] = True
        ; On ne teste les valeurs possibles que si les valeurs $i et $j correspondent à un focus valide
        If $i<>-1 And $j<>-1 Then
            ; $n = 0 à 8, dont la valeur à traiter $val (qui est entre 1 et 9) est $n+1
            ; On détecte le bloc concerné par la valeur [$i,$j] ($bloc est un couple dont chaque valeur est entre 0 et 2)
            Local $val = $n+1, $bloc[2]=[ _
                cond($i>2,1,0)+cond($i>5,1,0), _
                cond($j>2,1,0)+cond($j>5,1,0)  _
            ]
            ; On vérifie sur la ligne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$j And $grille[$i][$x] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur la colonne concernée que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0 To 8
                If $x<>$i And $grille[$x][$j] = $val Then $resultat[$n] = False
            Next
            ; On vérifie sur le bloc concerné que la valeur n'apparait pas ailleurs qu'en [$i,$j]
            For $x = 0+3*$bloc[0] To 2+3*$bloc[0]
                For $y = 0+3*$bloc[1] To 2+3*$bloc[1]
                    If $x<>$i And $y<>$j And $grille[$x][$y] = $val Then $resultat[$n] = False
                Next
            Next
        Else
            ; Pour les valeurs ayant des coordonnées invalides, on retourne False
            $resultat[$n] = False
        EndIf
    Next
    Return $resultat
EndFunc

Func _resolution($grillade, $option = 0,$grilleatest = 0)
        ; Récupération de la grille des valeurs
            If $option = 0 Then
            Do
            Local $grille = getGrille($grillade)
            Local $grille_avant = getGrille($grillade)
        _resoudre1( $grille)
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = getGrille($grillade)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until matrixEquals($grille_avant,$grille_apres)
    EndIf
        If $option <> 0 Then
        Do
            ; On recalcule la grille une fois modifiée
            Local $grille_apres = _resoudre1( $grillade,1)
            ; Tant que la grille change entre le début de l'opération ($grille) et la fin ($grille_apres), on recommence
        Until $grille_apres = False
    EndIf
; 1er cas: résolution incoplete
if not _estTotalementRemplie(getGrille($matrice)) then
_resoudre(getgrille($matrice))
else
return true
endif
; 2e cas résolution complete
EndFunc

Func _resoudre1 ($grille,$option = 0)
Local $grille_avant2[9][9]
$grille_avant2= $grille
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grille[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grille, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grille[$i][$j] = $val
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$val)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k + 1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grille[$i][$j] = $k+1
                                If $option = 0 Then
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                EndIf
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                Next
            Next
            If $grille_avant2 <> $grille Then
                Return False
            Else
                Return True
            EndIf
EndFunc
Func _resoudre ($grille)
$GrilleTest = _scinderGrilles ($grille,$GrilleTest)
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $GrilleTest[$i][$j] = 0 Then
                         ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($GrilleTest, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $GrilleTest[$i][$j] = $k + 1
                        GUICtrlSetData($matrice[$i][$j],$k+1)
#region algorithme 1
do
$grille_debut = $grilleTest
            For $i = 0 To 8
                For $j = 0 To 8
                    ; On ne travaille que sur les valeurs qui ne sont pas remplies, et qui valent donc 0 dans la grille des valeurs
                    If $grilleTest[$i][$j] = 0 Then
                        ; On récupère la liste des valeurs possibles, $found correspond au nombre de valeurs possibles, et $val à la valeur possible la plus haute
                        Local $possibilites = getValeursPossibles($grilletest, $i,$j), $found=0, $val=-1
                        ; On compte
                        For $k = 0 to 8
                            If $possibilites[$k] Then
                                $found=$found+1
                                $val=$k+1
                            EndIf
                        Next
                        ; Si une seule valeur possible ($found = 1), on affiche $val dans la case correspondante

                            If $found = 1 Then
                                $grilletest[$i][$j] = $val
                                    GUICtrlSetData($matrice[$i][$j],$val)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        If $grille[$i][$j] = 0 Then
                        For $k = 0 To 8

                            ;on regarde si la valeur n'est possible qu'une fois sur la ligne
                            If $possibilites[$k] and Not estPossibleSurLigne($grille,$i,$j,$k+1) Then
                                $grilletest[$i][$j] = $k+1
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        ;on regarde si la valeur n'est possible qu'une fois dans le bloc
                            If $possibilites[$k] And Not estPossibleSurBloc($grille,$i,$j,$k+1) Then
                                $grilletest[$i][$j] = $k + 1
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                            ;on regarde si la valeur n'est possible qu'une fois sur la colone
                            If $possibilites[$k] and Not estPossibleSurColonne ($grille,$i,$j,$k+1) Then
                                $grilletest[$i][$j] = $k+1
                                    GUICtrlSetData($matrice[$i][$j],$k+1)
                                ;une fois remplit plus besoin de continuer à chercher dans cette case
                                ExitLoop
                            EndIf
                        Next
                        EndIf
                    EndIf
                Next
            Next
            Until matrixequals($grille_debut,$grilletest)
            _resoudre($GrilleTest)
            if _esttotalementremplie($grilletest) then
            return true
            endif
#end-region



                            EndIf
                        Next
                    EndIf
                Next
            Next


EndFunc
Func _estTotalementRemplie($grille)


For $i = 0 to 8
    for $j = 0 to 8

        If $grille[$i][$j] = 0 then return False

    Next
Next
return True
EndFunc

Func _estValideBis($grille)
   Local $estValide = estValide($grille)
    ; Pour chaque ligne et colonne
    For $i = 0 To 8
        For $j = 0 To 8
            If $estValide[$i][$j]<>"____" Then
            Return False
            EndIf
        Next
    Next
    Return True
EndFunc

Func _remplirGrille($grille)

    For $i = 0 to 8
        For $j = 0 to 8
            If $grille[$i][$j] <> 0 Then
            GUICtrlSetData($matrice[$i][$j],$grille[$i][$j])
            EndIf
        Next
    Next

EndFunc
Func _scinderGrilles($grille1,$grille2)

    For $i = 0 to 8
        For $j = 0 to 8

        If $grille2[$i][$j] = 0 Then
            $grille2[$i][$j] = $grille1[$i][$j]
        EndIf

        Next
    Next
    Return $grille2

EndFunc

Et comme il faut une mauvaise nouvelle la voici : il revient pas sur une decision prise pourtant j'ai tout fait pour que ça soit possible non? Ou est mon erreur?