Aide algo sudoku

Hugo33 -  
Phil_1857 Messages postés 1956 Statut Membre -
Bonjour, je travaille actuellement sur un projet de jeu de sudoku en python et je n'arrive pas a trouver de fonction pour vérifier que les carrés soit bien rempli à la fin de la partie si qqn a une idée ? 

import random #importation de la librairie random pour définir aléatoirement une grille

ligne = 0 #boolen utilisé pour la vérification des valeurs de ligne
colone = 0 #boolen utilisé pour la vérification des valeurs de colone
en_ligne = 0 # entrée de ligne du joueur
en_colone = 0 # entrée de colone du joueur
en_utilisateur = 0 #valeur que le joueur veux mettre dans la grille
rdm_valeur1 = 0 # valeur aléatoire de ligne utilisé pour définir aléatoirement ma grille
rdm_valeur2 = 0 # valeur aléatoire de colone utilisé pour définir aléatoirement ma grille
rdm = 0 #varialbe aléatoire utilisé pour la définition aléatoire de ma grille
rdm2 = 0 # seconde varialbe aléatoire utilisé pour la définition aléatoire de ma grille
jeu = 0 # variable permettant de suivre l'évolution de l'utilisateur dans le jeu
vu = 0 # booléan permettan de vérifier les valeurs entrée par l'utilisateur
veu = 0 # variable pour vérifier l'entrée de l'utilisateur
vttl = 0 #vartiable utilisé pour la vérifiaction de toute les lignes
vttc = 0 #vartiable utilisé pour la vérifiaction de toute les colones
vartampon1 = 0
vartampon2 = 0
vartampon3 = 0
vartampon4 = 0
vartampon5 = 0
vartampon6 = 0 #variable utilisé pour regarder le nombre d'erreur dans la grille complétement rempli

# définition d'une grille de sudoku valide
g1 = [ [3, 6, 7, 9, 4, 1, 2, 8, 5],
       [1, 5, 2, 6, 8, 3, 4, 9, 7],
       [4, 9, 8, 7, 5, 2, 1, 6, 3],
       [7, 4, 6, 1, 9, 5, 8, 3, 2],
       [8, 1, 9, 2, 3, 7, 6, 5, 4],
       [2, 3, 5, 8, 6, 4, 7, 1, 9],
       [9, 2, 1, 5, 7, 8, 3, 4, 6],
       [5, 8, 4, 3, 2, 6, 9, 7, 1],
       [6, 7, 3, 4, 1, 9, 5, 2, 8] ]

# Fonction d'affichage formatée de la grille de Sudoku
def affichage_grille():
    print(g1[0][0],"|",g1[0][1],"|",g1[0][2],"||",g1[0][3],"|",g1[0][4],"|",g1[0][5],"||",g1[0][6],"|",g1[0][7],"|",g1[0][8])
    print("------------------------------------")
    print(g1[1][0],"|",g1[1][1],"|",g1[1][2],"||",g1[1][3],"|",g1[1][4],"|",g1[1][5],"||",g1[1][6],"|",g1[1][7],"|",g1[1][8])
    print("------------------------------------")
    print(g1[2][0],"|",g1[2][1],"|",g1[2][2],"||",g1[2][3],"|",g1[2][4],"|",g1[2][5],"||",g1[2][6],"|",g1[2][7],"|",g1[2][8])
    print("------------------------------------")
    print("------------------------------------")
    print(g1[3][0],"|",g1[3][1],"|",g1[3][2],"||",g1[3][3],"|",g1[3][4],"|",g1[3][5],"||",g1[3][6],"|",g1[3][7],"|",g1[3][8])
    print("------------------------------------")
    print(g1[4][0],"|",g1[4][1],"|",g1[4][2],"||",g1[4][3],"|",g1[4][4],"|",g1[4][5],"||",g1[4][6],"|",g1[4][7],"|",g1[4][8])
    print("------------------------------------")
    print(g1[5][0],"|",g1[5][1],"|",g1[5][2],"||",g1[5][3],"|",g1[5][4],"|",g1[5][5],"||",g1[5][6],"|",g1[5][7],"|",g1[5][8])
    print("------------------------------------")
    print("------------------------------------")
    print(g1[6][0],"|",g1[6][1],"|",g1[6][2],"||",g1[6][3],"|",g1[6][4],"|",g1[6][5],"||",g1[6][6],"|",g1[6][7],"|",g1[6][8])
    print("------------------------------------")
    print(g1[7][0],"|",g1[7][1],"|",g1[7][2],"||",g1[7][3],"|",g1[7][4],"|",g1[7][5],"||",g1[7][6],"|",g1[7][7],"|",g1[7][8])
    print("------------------------------------")
    print(g1[8][0],"|",g1[8][1],"|",g1[8][2],"||",g1[8][3],"|",g1[8][4],"|",g1[8][5],"||",g1[8][6],"|",g1[8][7],"|",g1[8][8])
    print("")

# fonction pour verifier que l'entrée de l'utilisateur ne soit pas déja dans la  colonne
def verif_colonne():
    global colone
    tab = [g1[0][en_colone], g1[1][en_colone], g1[2][en_colone],
           g1[3][en_colone], g1[4][en_colone], g1[5][en_colone],
           g1[6][en_colone], g1[7][en_colone], g1[8][en_colone]]

    try:
        tab.index(en_utilisateur)
        print("La valeur est déjà dans la colone")
        colone = False
    except ValueError:
        #print("La valeur n'est pas déjà dans la colone")
        colone = True

# fonction pour verifier que l'entrée de l'utilisateur ne soit pas déja dans la  ligne
def verif_ligne():
    global ligne
    tab = [g1[en_ligne][0], g1[en_ligne][1], g1[en_ligne][2],
           g1[en_ligne][3], g1[en_ligne][4], g1[en_ligne][5],
           g1[en_ligne][6], g1[en_ligne][7], g1[en_ligne][8]]

    try:
        tab.index(en_utilisateur)
        print("La valeur est déjà dans la ligne")
        ligne = False
    except ValueError:
        #print("La valeur n'est pas déjà dans la ligne")
        ligne = True

# Vérification que les valeur de ligne et de colone entrée par l'utilisateur sont
# compatible avec le jeu soit comprise entre 1 et 9
def verif_userinput():
    global vu
    if en_ligne > 8:
        print("Veuillez mettre une valeur de ligne plus petite")
        vu = False
    if en_colone > 8:
        print("Veuillez mettre une valeur de colonne plus petite")
        vu = False
    if en_ligne < 0:
        print("Veuillez mettre une valeur de ligne plus grande")
        vu = False
    if en_colone < 0:
        print("Veuillez mettre une valeur de colonne plus grande")
        vu = False
    else:
        vu = True

# Vérification que la valeurs entrée par l'utilisateur est compatible avec le jeu du sudoku
def verif_en_utilisateur():
    global veu
    if en_utilisateur >= 10 or en_utilisateur <= 0:
        print("La valeur que vou voulez mettre dans la grille doit étre comprise entre 1 et 9")
        veu = False

    else:
        print("")
        veu = True

#vérification de toute les lignes quand l'utilisateur a rempli la grille
def verif_tt_lignes():
    global vttl
    while vttl != 8:
        if g1[vttl][0] != g1[vttl][1] != g1[vttl][2] != g1[vttl][3] != g1[vttl][4] != g1[vttl][5] != g1[vttl][6] != g1[vttl][7] != g1[vttl][8]:
            print ("ok ligne :")
            print(vttl)
            print("")
            vttl = vttl + 1

        else :
            print ("erreur ligne")
            print (vttl)
            vttl = vttl + 1
            vartampon6 = vartampon6 + 1

#vérification de toute les colones quand l'utilisateur a rempli la grille
def verif_tt_colones():
    global vttc
    while vttc != 8:
        if g1[0][vttc] != g1[1][vttc] != g1[2][vttc] != g1[3][vttc] != g1[4][vttc] != g1[5][vttc] != g1[6][vttc] != g1[7][vttc] != g1[8][vttc]:
            print("ok colone :")
            print(vttc)
            print("")
            vttc = vttc + 1

        else:
            print("erreur colone :")
            print(vttc)
            vttc = vttc + 1

# fonction pour dfinir  aléatoirment la grille
def grille_aleatoire():
    global rdm
    while rdm != 45:
        rdm_valeur1 = random.randint(0, 8)
        rdm_valeur2= random.randint(0, 8)
        if g1[rdm_valeur1][rdm_valeur2] != 0:
            rdm2 = g1[rdm_valeur1][rdm_valeur2]
            g1[rdm_valeur1][rdm_valeur2] = 0
            rdm = rdm + 1
    print("")
    print("Bonne chance cette grille n'as pas l'air simple: ")
    print("")

#lancement du jeu
grille_aleatoire()
g2 = []
for i in range(len(g1)):
    g2.append(g1[i][:])
affichage_grille()
# définition des entrées de l'utilisateur

while jeu != 45:

    vartampon1 = 0
    vartampon2 = 0
    vartampon3 = 0

#entré de ligne
    while vartampon1 != True:
        en_ligne = input("Dans quelle ligne voulez vous jouer ? ")
        try:
            en_ligne = int(en_ligne)
            #vartampon4 = en_ligne
            en_ligne = en_ligne - 1
            vartampon1 = True
        except ValueError:
            print("Ce n'est pas un entier!")

# entré de colone
    while vartampon2 != True:
        en_colone = input("Dans quelle colone voulez vous jouer ? ")
        try:
            en_colone = int(en_colone)
            #vartampon5 = en_colone
            en_colone = en_colone - 1
            vartampon2 = True
        except ValueError:
            print("Ce n'est pas un entier!")

# entré de l'utilisateur
    while vartampon3 != True:
        en_utilisateur = input("Quelle valeur voulez vous entrez ? ")
        try:
            en_utilisateur = int(en_utilisateur)
            vartampon3 = True
        except ValueError:
            print("Ce n'est pas un entier!")

    verif_userinput()
    verif_colonne()
    verif_ligne()
    verif_en_utilisateur()

    # vérification de la validité des carrés à condition que la ligne et la colonne
    # associés à l'entrée de l'utilisateur soit validés ( t= 2 )
    if colone == ligne and ligne == vu and vu == veu and veu == True:

        if g2[en_ligne][en_colone] == 0 and g1[en_ligne][en_colone] == 0:
            jeu = jeu + 1
            del g1[en_ligne][en_colone]
            g1[en_ligne].insert(en_colone, en_utilisateur)
            print("Vous avez ajouté une valeur")
            print("")
            affichage_grille()

        elif g2[en_ligne][en_colone] != 0:
            print("vous ne pouvez pas modifier cette valeur, elle vous est donnez dès le début")

        elif g1[en_ligne][en_colone] != 0 and g2[en_ligne][en_colone] == 0:
            g1[en_ligne][en_colone] = en_utilisateur
            print("Vous avez modifié une valeur")
            affichage_grille()

        elif g2[en_ligne][en_colone] != 0 and g1[en_ligne][en_colone] != 0:
            print("vous ne pouvez pas modifié cette valeur")

        else:
            print("erreur 1")
    else :
        print("Désolé mais il semble que l'on est un probléme dans vos entrées")

verif_tt_lignes()
verif_tt_colones()


Configuration: Linux / Chrome 80.0.3987.162
A voir également:

20 réponses

Réponse 1 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Bonjour Hugo33,

Si je comprends bien, tu voudrait vérifier que les cases remplies par l'utilisateur sont correctes par rapport aux règle du sodoku ?

Dans le temps j'avais fait un programme qui résolvait automatiquement une grille existante
On saisit la grille avec les chiffres et les cases vides telle qu'on la lit sur un journal (moi, c'est dans mon programme de télé préféré ...), ensuite il y a la recherche avec une fonction récursive (une fonction qui s'appelle elle-même), puisqu'on répète plusieurs fois la même opération de contrôle des cases , et la solution s'affiche avec le nombre d'itérations faites

Toi, tu ne fait pas exactement çà, mais tu peux regarder ma fonction 'contraintes_OK' qui vérifie la case courante par rapport au carré 3x3 cases, et par rapport a toute la grille (9x9)

Pour info, l'exécution de mon script donne çà:


Le code: 
# -*- coding:Latin-1 -*-

import os
import sys

TITRE = '''
********************** SUDOKU 9x9 *******************************
Entrer les valeurs sous la forme suivante (point=case inconnue) :
9 caractères par ligne
Appuyez sur 'enter' pour passer à la ligne suivante
53..7....
6..195...
etc ..
'''

def saisie_grille():

	k = 0
	grille = {}

	print(TITRE)

	while (k < 81):
		c = sys.stdin.read(1)

		if (c >= '1' and c <= '9'):
			grille[k] = int(c)
			k+=1
		elif (c == '.'):
			grille[k] = VIDE
			k+=1

	return(grille)

def affiche_grille(grille):

	for l in range (0,9):
		for c in range (0,9):
			k = l*9+c
			if (grille[k] == VIDE):
				print('.', end  = ' ')
			else:
				print(grille[k], end  = ' ')

		print(' ')

def contraintes_OK(n, grille):
	''' Verifcation des contraintes de la case n '''

	l,c = n // 9, n % 9
	lb,lr = l // 3, l % 3
	cb,cr = c // 3, c % 3

	#Verif de la colonne contenant la case n
	for l2 in range (0,9):
		if (l2 != l and grille[l2*9+c] == grille[n]):
			return False

	#Verif de la ligne contenant la case n
	for c2 in range (0,9):
		if (c2 != c and grille[l*9+c2] == grille[n]):
			return False

	#Verif du carré 3x3 contenant la case n
	for lr2 in range (0,3):
		for cr2 in range (0,3):
			if ((lr2 != lr or cr2 != cr) and grille[(lb*3+lr2)*9+(cb*3+cr2)] == grille[n]):
				return False
	return True

def recherche_recursive(n, grille):
	''' on considère que que toutes les cases dont l'index < n
	sont déjà remplies
	'''

	global nombre_de_noeuds

	#Affichage solution
	if (n == 81):
		print('\nTrouvé !\n')
		affiche_grille(grille)
		return

	#La case est remplie : on passe à la suivante
	if (grille[n] != VIDE):
		recherche_recursive(n+1, grille)
		return

	#La case est vide : verif des contraintes
	nombre_de_noeuds += 1

	for grille[n] in range (1,10):
		if (contraintes_OK(n, grille)): recherche_recursive(n+1, grille)

	#On laisse la case comme elle était au départ
	grille[n] = VIDE


VIDE = 0
nombre_de_noeuds = 0

grille  = saisie_grille()
os.system('cls')

print('\nGrille de depart:\n')
affiche_grille(grille)

recherche_recursive(0, grille)
print('\n{:d} noeuds cherchés'.format(nombre_de_noeuds))

input ('\nPresser Entrée ...')


Sinon : (ne te vexe pas, hein ?) :-)
booléen s'écrit comme çà
colonnes prends 2 n
variable utilisée avec un e à la fin (une variable)
sont compatibles avec un s à la fin
Quelle valeur voulez vous entrer avec un r à la fin (infinitif)
elle vous est donnée : ée pas z, la valeur est donnée
il semble que l'on est un problème : il semble que l'on ait un problème,
c'est pas le verbe être, c'est le verbe avoir : avoir un problème

Bon, allez, j'arrête-là, mais il y en a d'autres :-)
1
Hugo33
 
Oui je sais l'othographe et mois ça fait 600 surtout avec un clavier.
Oui j'ai déja des fonctions pour vérifier les lignes et les colonnes mais pas pour les carrés.
Si tu as une idées je prends...
0
Réponse 2 / 20
yg_be Messages postés 24281 Statut Contributeur Ambassadeur 1 584
 
bonjour,
je pense que les fonctions ne se trouvent pas, elle se conçoivent.
qu'as-tu essayé, comment penses-tu pouvoir faire cette vérification?
0
Hugo33
 
J'ai essayé et réussi en faisant un tableau par carré puis en les vérifiants 1 par 1 mais c'est "pas pros "...
0
yg_be Messages postés 24281 Statut Contributeur 1 584 > Hugo33
 
où se trouve cette vérification dans ton code?
je pense que la ligne 122 ne fait pas ce que tu imagines.
connais-tu l'instruction for? ce serait plus clair de l'utiliser parfois au lieu de while.
0
Hugo33 > yg_be Messages postés 24281 Statut Contributeur
 
je l'ai enlevé car j'en avait honte...
Oui je connait for mais ou veux tu en venir ?
0
yg_be Messages postés 24281 Statut Contributeur 1 584 > Hugo33
 
commence par réfléchir à la ligne 122...
0
Réponse 3 / 20
Phil_1857
 
Regarde ma fonction contraintes_OK comme je te le disais …
0
Hugo33
 
J'ai regardais mais je ne la comprend pas, déjà merci car je ne connaissais pas la maniére dont tu as divisé les valeurs de ligne et de colone en les collants 
l = 9
c = 8

lb, lr = l // 3, l % 3
cb, cr = c // 3, c % 3

print(lr)


Si tu peux me detailler le if ça serait génial.
0
Réponse 4 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Je ne sais pas ce que tu entends par "en les collants"

En fait, comme ma grille est un tableau de 81 cases (de 0 à 80), et non pas un tableau carré à 2 dimensions (9x 9 cases), et que je veux quand même explorer des lignes ou des colonnes, j'utilise cet artifice pour simuler un tableau à 2 dimensions (lignes, colonnes)

pour une case d'indice n (grille[n] ):
le numéro de ligne est n//9 (division entière de n par 9)
le numéro de colonne est n%9 (n modulo 9)

Exemples :
si n = 0 le calcul donne l = 0 et c = 0, car la 1ere case serait bien dans la 1ere ligne, 1ere colonne
si n = 9 : l=1, c=0 : la case 9 serait bien dans la 2eme ligne, 1ere colonne

Et donc dans ma fonction: 
for c2 in range (0,9):
	if (c2 != c and grille[l*9+c2] == grille[n]):
		return False


on explore toute la colonne de la case n : [l2*9+c] donne tous les indices des cases de la colonne c qui contient n, et on vérifie que l'une d'elles ne contient pas le même chiffre que dans la case n

si c'est le cas, (grille[l2*9+c] == grille[n]), on sort de la fonction en retournant False : le contenu de n n'est pas OK

Ensuite on fait pareil pour la ligne qui contient la case d'indice n, puis pour le carré 3x3 qui contient la case d'indice n

Si tout est OK, la fonction retourne True
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
oups, pour mon exemple j'ai recopié la 2eme boucle for qui explore les lignes et non les colonnes, mais çà ne change rien au principe …
0
Réponse 6 / 20
Hugo33
 
Donc concraitement que donnerai la fonction pour définir un carré a partir d'une entrée de l'utilisateur ?
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
que suggères-tu? tu apprendras mieux en créant toi-même, plutôt qu'en recopiant.
comment ferais-tu cette vérification sans ordi?
0
Réponse 7 / 20
Hugo33
  
L = entrée de ligne
C = entrée de colone 
# pour le décalage tableau 

La , LR = La // 3, LR % 3
Ca , CR = Ca // 3, CR % 3

if LR != 0 and CR != 0:
   La = +1
   Ca = +1
   if La = 4 or Ca = 4
       La = 3
       Ca = 3 

tab = [g1[La][Ca],g1[La][Ca+1],g1[La][Ca+2]
           g1[La+1][Ca],g1[La+1][Ca+1],g1[La+1][Ca+2]
           g1[La+2][Ca],g1[La+2][Ca+1],g1[La+2][Ca+2]


#et je lance la comparaison
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
as-tu testé?
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
plus élégant, pour peupler tab: 
tab=[]
for i in range(3):
    for j in range(3):
        tab.append (g1[La+i][Ca+j])
0
Réponse 8 / 20
Hugo33
 
en cours
0
Réponse 9 / 20
Hugo33
  
L = input("entrée de ligne")
C = input("entrée de colone")

La , LR = L // 3, L % 3
Ca , CR = C // 3, C % 3

if LR != 0 and CR != 0:
   La = +1
   Ca = +1
   if La == 4 or Ca == 4:
       La = 3
       Ca = 3

tab = [g1[La][Ca],g1[La][Ca+1],g1[La][Ca+2]
           g1[La+1][Ca],g1[La+1][Ca+1],g1[La+1][Ca+2]
           g1[La+2][Ca],g1[La+2][Ca+1],g1[La+2][Ca+2]


invalid syntax sur le tableau tab
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
compte les [ et les ]
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
à quoi servent les lignes 7 à 12?
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
je pense que La et Ca ne sont pas correctement calculés.
0
Hugo33 > yg_be Messages postés 24281 Statut Contributeur
 
oui c'est ce que je suis entrain de voir...
0
Réponse 10 / 20
Hugo33
 
les lignes 7 à 12 me servent justement a avoir des tableau " en lien "avec le sudoku
0
Réponse 11 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Holà Hugo33,

Je ne sais pas si tu as bien lu tout ce que je te raconte, et tout bien assimilé

notamment l'utilisation de l et c: moi je fais çà parce que mon tableau est unidimensionnel

tu n'est pas obligé de tout changer: toi tu as déjà un tableau (lignes, colonnes):

g1[0][0],"|",g1[0][1], etc...

Il te restait juste a faire une double boucle pour balayer toutes les cases de ta grille, et pour

chaque case, tu appelles une fonction qui ressemble à la mienne, donc qui explore la ligne et la

colonne qui contient la case pour vérifier si une autre case ne contient pas le même chiffre

(et aussi le carré 3x3 qui contient la case)
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
il n'a pas de raison de faire cela ainsi, son programme n'a pas la même fonction que le tien.
0
Réponse 12 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Hello Yg_be,

Cà, je le sais et je le dis dès ma 1ere réponse …. :-)

Sa question initiale était bien de vérifier les cases du tableau pour voir si elles sont remplies correctement vis à vis des règles du sodoku ? non ?

Si oui, pas la peine de tout révolutionner, il y a juste à balayer toutes les case et d'appeler une fonction pour vérifier

Mais bon …
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
je pense que l'idée est de vérifier qu'un chiffre puisse être ajouté dans une case, donc de vérifier la ligne, la colonne, et le carré.
inutile de vérifier toutes les cases, si la vérification est faite à chaque ajout.
0
Phil_1857 Messages postés 1956 Statut Membre 168 > yg_be Messages postés 24281 Statut Contributeur
 
ah !
ok yg_be, excuse-moi

Moi j'avais compris qu'il voulait vérifier que le sudoku était correct en fin de remplissage:
"... fonction pour vérifier que les carrés soit bien rempli à la fin de la partie…"
0
Hugo33 > Phil_1857 Messages postés 1956 Statut Membre
 
Cela m'est égal... Je ne sais pas ce qui vous parlez être le plus simple ?
0
yg_be Messages postés 24281 Statut Contributeur 1 584 > Hugo33
 
quand veux-tu vérifier quoi?
0
Réponse 13 / 20
Hugo33
 
Mais c'est a dire balayer toute les cases ?
0
Réponse 14 / 20
Hugo33
 
Et en faisant des test je suis tomber sur un os dans mon code je soustrait par 1 la ligne et la colone pour que le joueur puisse "compter normalement ": problème en plus.
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
ton code utilisant 0 comme base, il suffit de soustraire ou d'ajouter 1 en communiquant avec le joueur.
0
Réponse 15 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Ouh la …

Ben, faire une double boucle pour trouver le chiffre qui est dans chaque case de la grille …
0
Hugo33
 
ok
0
Réponse 16 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Bonjour Hugo33,

Pour te donner à réfléchir, ci-dessous ton code en 3 fois plus court, en plus concis et beaucoup plus simple

Regarde par exemple la fonction affichage_grille()
Il y avait aussi quelques variables inutiles (g2, rdm2, …)

Mon programme affiche la grille et tant qu'on n'entre pas un numéro de ligne ou de colonne valide, il efface l'écran, ré affiche la grille et repose la question

Si ligne et colonne sont valides, Il contrôle de suite si la case n'est pas déjà remplie,

si oui, on affiche un message d'erreur, on efface, on ré affiche, on redemande ligne et colonne
sinon on demande la valeur à mettre, on remplit, et la grille se réaffiche avec la nouvelle valeur

Dès que les cases sont toutes remplies, on appelle la fonction de vérification … 

# -*- coding:Latin-1 -*-
#Jeu de sudoku	07/04/2020 15:26:54

import random
import os

# définition d'une grille de sudoku valide
grille = [[3, 6, 7, 9, 4, 1, 2, 8, 5],
          [1, 5, 2, 6, 8, 3, 4, 9, 7],
          [4, 9, 8, 7, 5, 2, 1, 6, 3],
          [7, 4, 6, 1, 9, 5, 8, 3, 2],
          [8, 1, 9, 2, 3, 7, 6, 5, 4],
          [2, 3, 5, 8, 6, 4, 7, 1, 9],
          [9, 2, 1, 5, 7, 8, 3, 4, 6],
          [5, 8, 4, 3, 2, 6, 9, 7, 1],
          [6, 7, 3, 4, 1, 9, 5, 2, 8]]

nb_de_cases_vides = int((len(grille)*len(grille))*0.5)

def affichage_grille():
	''' Affiche la grille complete '''

	print('Bonne chance !\n')
	for k in range (9):
		print('|', end = '')
		for j in range (9):
			print(grille[k][j], end = ' | ')
		print('\n------------------------------------')

def grille_aleatoire():
	''' Remplit aléatoirement 40 cases de la grille avec un 0 '''

	k = 0
	while k != nb_de_cases_vides:
		rand_1, rand_2 = random.randint(0, 8), random.randint(0, 8)
		if grille[rand_1][rand_2] != 0:
			grille[rand_1][rand_2] = 0
			k += 1

def verif_case(ligne,colonne):
	''' Verifie que la valeur d'une case est unique dans sa ligne et sa colonne'''

	valeur_case = grille[ligne][colonne]
	for k in range(9):
		if(k != colonne and grille[ligne][k] == valeur_case):
			print('Doublon de la case {:d},{:d} en case {:d},{:d}'.format(ligne,colonne,ligne,k))

	for k in range(9):
		if(k != ligne and grille[k][colonne] == valeur_case):
			print('Doublon de la case {:d},{:d} en case {:d},{:d}'.format(ligne,colonne,k,colonne))

#Jeu
grille_aleatoire()
nb_de_cases_remplies = 0

while(nb_de_cases_remplies < nb_de_cases_vides):
	#Ligne
	ligne = -1
	while(not ligne in ('0', '1', '2', '3', '4', '5', '6', '7', '8','q')):
		os.system('cls' if os.name=='nt' else 'clear')
		affichage_grille()
		ligne = input('Dans quelle ligne voulez vous jouer (0 à 8, q = quitter) ? ')

	if(ligne == 'q'): break
	ligne = int(ligne)

	#Colonne
	colonne = -1
	while(not colonne in ('0', '1', '2', '3', '4', '5', '6', '7', '8')):
		os.system('cls' if os.name=='nt' else 'clear')
		affichage_grille()
		colonne = input('Dans quelle colonne voulez vous jouer (0 à 8) ? ')

	colonne = int(colonne)

	#Test si la case est vide
	if(grille[ligne][colonne] != 0):
		input('Erreur : la case {:d},{:d} est deja remplie  Appuyer sur entrée pour recommencer ...'.format(ligne,colonne))
	else:
		#Chiffre de la case
		chiffre = -1
		while(not chiffre in ('1', '2', '3', '4', '5', '6', '7', '8', '9')):
			os.system('cls' if os.name=='nt' else 'clear')
			affichage_grille()
			chiffre = input('Dans valeur voulez vous entrer (1 à 9) ? ')

		chiffre = int(chiffre)

		grille[ligne][colonne] = chiffre
		nb_de_cases_remplies += 1

#La grille est complète : on vérifie
if(cases_remplies == nb_de_cases_vides):
	for k in range (9):
		for j in range (9):
			verif_case(k,j)

input('Appuyer sur entrée ...')
0
Hugo33
 
Comment marche la vérification à la fin ?
0
yg_be Messages postés 24281 Statut Contributeur 1 584 > Hugo33
 
elle est inutile, puisque la vérification a été faite à chaque case rentrée.
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
afin de vérifier également les carrés: 
def verif_case(ligne,colonne):
    ''' Verifie que la valeur d'une case est unique dans sa ligne et sa colonne et son carré'''
    valeur_case = grille[ligne][colonne]
    for k in range(9):
        if(k != colonne and grille[ligne][k] == valeur_case):
            print('DoublonC de la case {:d},{:d} en case {:d},{:d}'.format(ligne,colonne,ligne,k))
        if(k != ligne and grille[k][colonne] == valeur_case):
            print('DoublonL de la case {:d},{:d} en case {:d},{:d}'.format(ligne,colonne,k,colonne))
    c=3*(colonne//3)
    l=3*(ligne//3)
    for k in range(3):
        for m in range(3):
            if(k+c != colonne and m+l != ligne and grille[m+l][k+c] == valeur_case):
                print('DoublonP de la case {:d},{:d} en case {:d},{:d}'.
                      format(ligne,colonne,m+l,k+c))
0
Réponse 17 / 20
Hugo33
 
ok
0
Réponse 18 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Erreur yg_be !

"elle est inutile, puisque la vérification a été faite à chaque case rentrée. "

Cette vérif - là ne se fait pas a chaque case rentrée !

(je parle de ma fonction verif_case() )

Les verifs dans la boucle while ne portent que sur la validité des numéros de lignes et de colonnes et si la case à remplir est bien vide

Par contre je vois que tu as complété ma fonction en y ajoutant le contrôle du carré 3x3
Mais çà, on aurait pu laisser Hugo33 s'y atteler, non ? :-)
0
yg_be Messages postés 24281 Statut Contributeur 1 584
 
n'est-ce pas un malentendu de laisser compléter une grille incorrecte?

tu suggères de laisser Hugo33 chercher la solution que tu proposes en #5?
0
Réponse 19 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Hugo33,

Tu n'as plus qu'a tester et comparer avec ce que tu avais fait pour voir comment on peut écrire un code plus simple et plus concis …
0
Réponse 20 / 20
Phil_1857 Messages postés 1956 Statut Membre 168
 
Holà yg_be,

Je vois ce que tu veux dire : quand on fait un sudoku a la main, on contrôle dans la ligne et dans la colonne au fur et a mesure que l'on remplit la grille

moi, je n'ai fait que recopier le code d'Hugo33 pour lui montrer comment faire plus court et plus concis, pour commencer

Ensuite il n'y a plus qu'à améliorer ...
0

Discussions similaires

Algorithme avec alg 32
Mira -
Utilisateur anonyme -

3 réponses
Sudoku en C ou C++
Ciola -
Neliel -

31 réponses
Aide : algo palindrome
bansan -
blursly -

5 réponses
Aide pour exercice algo
Billy00 -
jordane45 -

1 réponse
[programmation] sudoku
nolwenn é astrid -
lami20j -

4 réponses