def generar_sudokus_en_csv(self, dimension, cantidad):
# ejemplo: 3*3, es dimension 9--> que seria 9*9, 81 casilleros
try:
if not 0 < cantidad < 10 and type(cantidad) == int:
raise Cantidad_tableros_incorrecta_exception
if not (0 < dimension and type(dimension) is int and raiz_cuadrada(dimension) / int(
raiz_cuadrada(dimension)) == 1):
raise Dimension_incorrecta_exception(dimension)
cantidad_casilleros = dimension * dimension
cantidad_de_valores_random = cantidad_casilleros // 3
for num_tableros in range(cantidad):
tablero = self._generar_tablero_en_matriz(dimension)
# rellenar con valores random
for i in range(cantidad_de_valores_random):
fila_random, columna_random = random.randint(0, dimension - 1), random.randint(0, dimension - 1)
valor_random = random.randint(0, dimension)
if Verificador_reglas().verificar_posicion_libre(tablero, valor_random,
(fila_random, columna_random), dimension):
tablero[fila_random][columna_random] = valor_random
# else:
# cantidad_de_valores_random+=1#si no se puede agregar en ese lugar, se suma un intento mas
csv_archivo = csv.writer(open("archivos/sudokus_generados.csv", "a", newline='')) # carpeta archivos
for i in range(dimension):
lista = tablero[i]
csv_archivo.writerow(lista)
except Dimension_incorrecta_exception as e:
print(e)
esperar(5)
except Cantidad_tableros_incorrecta_exception as e:
print(e)
esperar(5)
def _carga_archivo_y_resuelve(self,
archivo_entrada,
dimension,
num_linea_recuperacion=0):
'''recibe un archivo csv con los numeros separados por coma y otro parametro para
comprobar que la dimension de todos los tableros sea la correcta, debe ser un entero'''
try:
formato_error = '\033[4;31m'
if not (0 < dimension and type(dimension) is int
and raiz_cuadrada(dimension) /
int(raiz_cuadrada(dimension)) == 1):
raise Dimension_incorrecta_exception(dimension)
if not archivo_entrada.__contains__(".csv"):
raise Tipo_de_archivo_incorrecto_exception(archivo_entrada)
archivo = csv.reader(open(archivo_entrada, "r"), delimiter=",")
fila_temporal, tablero = list(), list()
num_linea = 0
for linea in archivo:
if num_linea_recuperacion != 0: # va a saltear las lineas necesarias
num_linea_recuperacion -= 1
continue
num_linea += 1
for numero in linea:
fila_temporal.append(int(numero))
tablero.append(fila_temporal) # agrega de a filas
fila_temporal = list()
if num_linea % dimension == 0: # cuando el tablero este completo, verifica y resuelve?. Hacer test
print('\033[1;33m' +
f"Sudoku N°:{int(archivo.line_num / dimension)}")
print('\033[1;33m' +
f"Linea de archivo N°:{archivo.line_num}")
# termina de cargar el tablero, y lo resuelve
if Verificador_reglas().verificar_tamaño_del_tablero(tablero, dimension) \
and Verificador_reglas().verificar_valores_predeterminados_correctos(tablero, dimension):
self._resolver(tablero, dimension, num_linea,
archivo_entrada)
elif not Verificador_reglas().verificar_tamaño_del_tablero(
tablero, dimension):
# raise Tablero_irregular_exception
print(
formato_error + Style.BRIGHT +
"El tablero debe tener la misma cantidad de filas y columnas, del mismo tamaño"
)
else:
print(
formato_error + Style.BRIGHT +
f"El tablero solo puede contener valores entre 0 y {dimension}"
)
tablero.clear()
except ValueError:
print("\033[4;31m" + Style.BRIGHT +
"El archivo solo debe contener numeros y el separador")
esperar(5)
except Tipo_de_archivo_incorrecto_exception as e:
print(e)
esperar(5)
except Dimension_incorrecta_exception as e:
print(e)
esperar(5)
def __init__(self, dimension):
# super()
if int(dimension) < 0:
self.mensaje = formato_error + Style.BRIGHT + 'El valor para indicar la dimension debe ser mayor que cero'
elif not raiz_cuadrada(dimension) / int(raiz_cuadrada(dimension)) == 1:
self.mensaje = formato_error + Style.BRIGHT + 'La raiz cuadrada del valor debe ser un entero'
elif type(dimension) is int: # "\033[4;31m" + Style.BRIGHT+
self.mensaje = formato_error + Style.BRIGHT + 'El valor ingresado para indicar la dimension debe ser un entero'
def _generar_tablero_en_matriz(self, dimension):
if not type(raiz_cuadrada(int(dimension))) is int:
# raise DimensionException
pass
tablero = list()
for i in range(dimension):
fila_temporal = list()
for j in range(dimension):
fila_temporal.append(0)
tablero.append(fila_temporal)
return tablero
def verificar_si_es_posible_colocar_en_submatriz(self, posicion, dimension,
tablero, valor_a_agregar):
''' Con dimension 9, hay 9 submatrices que a su vez tienen 9 posibles valores dentro
El valor a agregar no puede encontrarse ya en la submatriz '''
longitud_submatriz = int(
raiz_cuadrada(dimension)) # el metodo devuelve float
# serian las posiciones en la matriz mas grande que seria el sudoku completo
posicion_inicial_de_columna = (int(
posicion[1] / longitud_submatriz
)) * longitud_submatriz # ->pos 14 / 4 int le saca decimal
posicion_inicial_de_fila = (int(
posicion[0] / longitud_submatriz)) * longitud_submatriz
posicion_disponible = True
for fila in range(posicion_inicial_de_fila,
posicion_inicial_de_fila + longitud_submatriz):
for columna in range(
posicion_inicial_de_columna,
posicion_inicial_de_columna + longitud_submatriz):
if tablero[fila][columna] == valor_a_agregar:
posicion_disponible = False
return posicion_disponible
return posicion_disponible
def _mostrar_tablero_consola(self, tablero, dimension):
formato_separador_columna = '\033[0;31m'
long_submatriz = int(raiz_cuadrada(dimension))
self._pintar_separador_horizontal()
for i in range(dimension):
if i % long_submatriz == 0 and i != 0: # 3/3 6/3 9*9
self._pintar_separador_horizontal()
for j in range(dimension):
if j % long_submatriz == 0:
print(formato_separador_columna + " | " +
self.formato_predeterminado,
end="")
if j == dimension - 1:
print(str(tablero[i][j]) + " ", end="")
print(formato_separador_columna + "|" +
self.formato_predeterminado)
else:
print(str(tablero[i][j]) + " ", end="")
self._pintar_separador_horizontal()
print('\033[0;32m' + "___________________________________\n" +
self.formato_predeterminado)
from math import sqrt as raiz_cuadrada print(raiz_cuadrada(42))
from math import sqrt as raiz_cuadrada, pi as numero print(raiz_cuadrada(numero))
from math import sqrt as raiz_cuadrada, pi, e as euler print(raiz_cuadrada(pi)) print(raiz_cuadrada(euler))
def cargar():
lista = []
for x in range(10):
lista.append(raiz_cuadrada(random.randint(0, 20)))
pass
return lista
