Cómo crear un sitio web de juego de Sudoku usando Python

¡Hola!

Supongo que no quieres una interfaz gráfica, pero si lo necesitas, necesitarás el módulo / Framework pyGame y lleva mucho tiempo, considera el código sin Pygame a continuación.

Necesita el módulo numpy aquí

Así que creo que es mejor hacerlo sin interfaz gráfica de usuario, solo mi opinión y dado que no puedo explicar cada línea de código aquí, supongo que entiendes Python

O simplemente copie el código

Fuente: http://code.activestate.com/reci…

Editar: es posible que haya cometido algunos errores al copiar el código o algo así que le sugiero que lo copie directamente desde el enlace

¡Gracias!

#! / usr / bin / env python
# – * – codificación: utf-8 – * –

“” ”
Creador de juegos de sudoku

“” ”

__author__ = ‘Ripley6811’
__contact__ = ‘python at boun.cr’
__copyright__ = ”
__license__ = ”
__date__ = ‘Jue 30 de agosto 10:09:06 2012’
__version__ = ‘0.1’

# ================================================= ==============================
# DECLARACIONES DE IMPORTACIÓN
# ================================================= ==============================
de importación numpy *

# ================================================= ==============================
# MÉTODOS
# ================================================= ==============================

def new_block ():
return random.permutation (arange (1,10)). rehape (3,3)

def test_rowcol (S):
retval = verdadero
para fila en S:
if len (set (row) .difference ([0])) <count_nonzero (row):
retval = falso
descanso
para col en ST:
if len (set (col) .difference ([0] It’s)) <count_nonzero (col):
retval = falso
descanso
retorno retval

def generate_grid (S = Ninguno, detallado = Falso):
# PARTE 1: ESTABLECER PRIMEROS TRES FILAS Y PRIMEROS TRES COLUMNAS
disponible = set (rango (1,10))
si S == Ninguno:
S = new_block ()
si es detallado: escriba S
mientras cierto:
Srow = append (append (S, new_block (), 1), new_block (), 1)
si test_rowcol (Srow):
si es detallado: imprima Srow
descanso
mientras cierto:
Scol = append (append (S, new_block (), 0), new_block (), 0)
si test_rowcol (Scol):
Scol = append (Scol [3:], ceros ((6,6), int), 1)
si es detallado: imprimir Scol
descanso
S = agregar (Srow, Scol, 0)
# PARTE 2: LLENE EL RESTO DE LA RED DE LA PARTE 1. [3:, 3:]
si es detallado: escriba ‘.’,
mientras cierto:
S [3: 6,3: 6] = new_block ()
si test_rowcol (S [: 6,: 6]):
descanso
mientras cierto:
S [6:, 6:] = new_block ()
si test_rowcol (S):
descanso
para i en rango (3,9):
para j en el rango (3,9):
si S [i, j] == 0:
subset = available.difference (set (S [i])) .difference (set (S [:, j]))
si len (subconjunto) == 1:
S [i, j] = subset.pop ()
más:
S [3:, 3:] = 0
return generate_grid (S, detallado)
si es detallado: imprimir ‘\ n’, S
devoluciones

def reduce_options (tablero, Pcube):

fila, col = where (tablero == 0)
playoption = []
para i en rango (9):
para j en el rango (9):
si el tablero [i, j]! = 0:
Pcube [i, j, Pcube [i, j]! = Tablero [i, j]] * = 0

para i, j en zip (fila, col):
excluir = conjunto (tablero [i])
excluir = excluir.unión (tablero [:, j])
exclude = exclude.union (placa [i / 3 * 3: i / 3 * 3 + 3, j / 3 * 3: j / 3 * 3 + 3] .flat)
para cada en excluir:
Pcube [i, j, Pcube [i, j] == cada uno] = 0

para la capa en Pcube.T: # capas probables 1 a 9
para i en rango (9):
rowsfilled = sum (capa [i,: 3])> 0, sum (capa [i, 3: 6])> 0, sum (capa [i, 6:])> 0
si suma (filas rellenas) == 1:
rowsfilled = repetir (rowsfilled, 3)
capa [i / 3 * 3 + (i + 1)% 3, filas rellenas] * = 0
capa [i / 3 * 3 + (i + 2)% 3, filas rellenas] * = 0
capa = capa.T
para i en rango (9):
rowsfilled = sum (capa [i,: 3])> 0, sum (capa [i, 3: 6])> 0, sum (capa [i, 6:])> 0
si suma (filas rellenas) == 1:
rowsfilled = repetir (rowsfilled, 3)
capa [i / 3 * 3 + (i + 1)% 3, filas rellenas] * = 0
capa [i / 3 * 3 + (i + 2)% 3, filas rellenas] * = 0

# print str (Pcube.T) .replace (‘0’, ‘~’)

para i, j en zip (fila, col):
if count_nonzero (Pcube [i, j]) == 1:
playoption.append ((i, j, sum (Pcube [i, j])))
volver playoption

def generate_game (S, detallado = Falso):
gametest = S.copy ()

para cada uno en el rango (200):
i = random.randint (81)
temp = gametest.flat [i]
gametest.flat [i] = 0

si no es Soluble (prueba de juego):
gametest.flat [i] = temp
prueba de juego de regreso

def isSolvable (juego de prueba):
tablero = testgame.copy ()
P = unos ((9,9,9), int)
para i en un rango (9):
P [:,:, i] * = i + 1
print ‘GAME \ n’, str (tablero) .replace (‘0’, ‘_’)
orden de juego = []
laststate = sum (P)
while sum (tablero == 0)> 0:
# REDUCIR LAS OPCIONES PARA CADA AGUJERO
playoptions = reduce_options (tablero, P)
imprimir playoptions
# print str (tablero) .replace (‘0’, ‘_’)
para i, j, v en playoptions:
tablero [i, j] = v
thisstate = sum (P)
si thisstate == laststate:
descanso
más:
laststate = thisstate
devuelve Verdadero si suma (tablero == 0) == 0 más Falso

def main ():
“” “Descripción de main ()” “”
solución = generate_grid (detallado = Verdadero)
sudoku = generate_game (solución, verbose = True)
imprimir ‘Solución \ n’, solución
print ‘Sudoku \ n’, str (sudoku) .replace (‘0’, ‘_’)
print sum (sudoku == 0), ‘espacios en blanco (‘, int (sum (sudoku == 0) /. 81), ‘%)’

if __name__ == ‘__main__’:
principal()