def resolve(resposta):
if flag:
for i in range(9):
for j in range(9):
if resposta[i][j]==0: # Captação das posições vazias/nulas
coord=(x,y)
zeroposi.append(list(coord))
flag == False
print_sudoku(resposta)
return False
def resolve(tab, i_i=0):
for i in range(i_i, 9):
for j in range(9):
if tab[i][j] == 0:
for p in valid_movs(tab, i, j):
tab[i][j] = p
print_sudoku(tab)
if resolve(tab, i):
return True
tab[i][j] = 0
return False
return True
def resolve(tab):
# Implementar a funcao e trocar o valor de retorno
tab = resolve_recursao(tab, 0, 0)
strJogo = ""
for k in range(9):
strJogo += "".join(map(str, tab[k]))
if (strJogo.__contains__("0")):
return False
else:
print_sudoku(tab)
return True
def resolve(resposta):
#Copia matriz resposta para comparacao posterior
copia = []
for i in range(0, 9):
copia.append([])
copia[i] += resposta[i]
#Chama a recursao
resposta = recursao(resposta, 0, 0)
print_sudoku(resposta)
#Se a matriz "resposta" for igual a copia da entrada, retorna "False",
#caso contrario retorna "True"
if (resposta == copia):
return False
else:
return True
def resolve(resposta, x = 0, y = 0): """ Funcao que resolve um tabuleiro de sudoku. Altera o tabuleiro dado enquanto e possivel resolve-lo. Caso uma solucao tentada nao seja valida retorna False. """ # Condicao de parada: Caso a funcao esteja em uma linha alem da ultima if x == 9: return True # Se a posicao atual ja estiver resolvida, pula diretamente para a proxima # chamada if resposta[x][y] != 0: # Se a posicao atual for na ultima coluna, a proxima chamada e na primeira # coluna da proxima linha if y == 8: if resolve(resposta, x+1, 0): return True # Caso contrario, continua na mesma linha na proxima coluna else: if resolve(resposta, x, y+1): return True return False # Se a posicao atual ainda nao estiver resolvida, e preciso veririficar # todos os digitos que podem resolver essa posicao for i in range(1,10): # Se o valor testado for valido, continua-se as chamadas if isValid(i, resposta, x, y): resposta[x][y] = i if y == 8: if resolve(resposta, x+1, 0): return True else: if resolve(resposta, x, y+1): return True # Se nao forem encontradas respostas com esse valor nessa posicao, # a posicao e retornada para 0 e outro valor e testado resposta[x][y] = 0 print_sudoku(resposta) # Caso nenhum valor seja valido para essa posicao o tabuleiro nao tem solucao return False
def findNext(sudoku):
# Acha a próxima posição vazia na linha corrente
for i in range(9):
for j in range(9):
if sudoku[i][j] == 0:
# Para cada número válido encontrado:
for valid in validNumbers(sudoku, i, j):
# Troca o zero pelo número encontrado
sudoku[i][j] = valid
print_sudoku(sudoku)
# Chama a função para o próximo zero
if findNext(sudoku):
return True
# Se a função não encontrar nenhum valor válido,
# limpa o valor possível e tenta o próximo
else:
sudoku[i][j] = 0
# Se todos os valores foram tentados e não foi encontrada a solução,
# invalida o caminho e faz com que seja tentado outro
return False
return True
def resolve(resposta):
res = testa(
resposta, 0,
0) #Chama a função que resolverá com recursividade e backtracking
print_sudoku(resposta)
return res #Retorna True caso haja solução e False caso contrário
def resolve(resposta):
res = solve(resposta, 0, 0)
print_sudoku(resposta)
return res
def resolve(resposta):
percorre(resposta) #Percorre a resposta, do inicio ao fim
print_sudoku(resposta)
return True
def resolve_recursao(mat, l, c):
#acha o proximo espaco vazio
if (mat[l][c] != 0):
while (mat[l][c] != 0):
if (c < 8):
c += 1
elif (c == 8):
l += 1
c = 0
if (l > 8):
return mat
#cria string com a linha da posicao atual
linhastr = "".join(map(str, mat[l]))
#cria string com a coluna da posicao atual
colunastr = ""
for k in range(len(mat)):
colunastr += str(mat[k][c])
#cria string com o bloco da posicao atual
blocostr = ""
if (l == 0 or l == 1 or l == 2):
if (c == 0 or c == 1 or c == 2): #bloco 1
blocostr = str(mat[0][0]) + str(mat[0][1]) + str(mat[0][2])
blocostr += str(mat[1][0]) + str(mat[1][1]) + str(mat[1][2])
blocostr += str(mat[2][0]) + str(mat[2][1]) + str(mat[2][2])
elif (c == 3 or c == 4 or c == 5): #bloco 2
blocostr = str(mat[0][3]) + str(mat[0][4]) + str(mat[0][5])
blocostr += str(mat[1][3]) + str(mat[1][4]) + str(mat[1][5])
blocostr += str(mat[2][3]) + str(mat[2][4]) + str(mat[2][5])
else: #bloco 3
blocostr = str(mat[0][6]) + str(mat[0][7]) + str(mat[0][8])
blocostr += str(mat[1][6]) + str(mat[1][7]) + str(mat[1][8])
blocostr += str(mat[2][6]) + str(mat[2][7]) + str(mat[2][8])
elif (l == 3 or l == 4 or l == 5):
if (c == 0 or c == 1 or c == 2): #bloco 4
blocostr = str(mat[3][0]) + str(mat[3][1]) + str(mat[3][2])
blocostr += str(mat[4][0]) + str(mat[4][1]) + str(mat[4][2])
blocostr += str(mat[5][0]) + str(mat[5][1]) + str(mat[5][2])
elif (c == 3 or c == 4 or c == 5): #bloco 5
blocostr = str(mat[3][3]) + str(mat[3][4]) + str(mat[3][5])
blocostr += str(mat[4][3]) + str(mat[4][4]) + str(mat[4][5])
blocostr += str(mat[5][3]) + str(mat[5][4]) + str(mat[5][5])
else: #bloco 6
blocostr = str(mat[3][6]) + str(mat[3][7]) + str(mat[3][8])
blocostr += str(mat[4][6]) + str(mat[4][7]) + str(mat[4][8])
blocostr += str(mat[5][6]) + str(mat[5][7]) + str(mat[5][8])
else:
if (c == 0 or c == 1 or c == 2): #bloco 7
blocostr = str(mat[6][0]) + str(mat[6][1]) + str(mat[6][2])
blocostr += str(mat[7][0]) + str(mat[7][1]) + str(mat[7][2])
blocostr += str(mat[8][0]) + str(mat[8][1]) + str(mat[8][2])
elif (c == 3 or c == 4 or c == 5): #bloco 8
blocostr = str(mat[6][3]) + str(mat[6][4]) + str(mat[6][5])
blocostr += str(mat[7][3]) + str(mat[7][4]) + str(mat[7][5])
blocostr += str(mat[8][3]) + str(mat[8][4]) + str(mat[8][5])
else: #bloco 9
blocostr = str(mat[6][6]) + str(mat[6][7]) + str(mat[6][8])
blocostr += str(mat[7][6]) + str(mat[7][7]) + str(mat[7][8])
blocostr += str(mat[8][6]) + str(mat[8][7]) + str(mat[8][8])
#realiza o backtracking
for i in range(1, 10):
if (linhastr.__contains__(str(i)) == False
and colunastr.__contains__(str(i)) == False
and blocostr.__contains__(str(i)) == False):
mat[l][c] = i
print_sudoku(mat)
mat = resolve_recursao(mat, l, c)
tabstr = ""
for j in range(len(mat)):
tabstr += "".join(map(str, mat[j]))
if (tabstr.__contains__("0")):
mat[l][c] = 0
else:
break
return mat
