def traiteSaisieGrille(self, csock, donnejesRecues):
self.ejnoncej = ''
# 11=3&12=1&13=&...&98=&99=&raz=raz
if 'raz=raz' in donnejesRecues:
self.afficheSaisieGrille(csock)
return
# 11=3&12=1&13=&...&98=&99=&soumettre=soumettre
match = re.search('(11=.*)&soumettre=soumettre', donnejesRecues)
if not match:
print('saisie-grille INCONNU')
self.afficheSaisieGrille(csock)
return
for affectation in match.group(1).split('&'):
# 12=1 ou 13=
valeur = affectation.split('=')[1]
if valeur == '': self.ejnoncej += '.'
else: self.ejnoncej += valeur
# max 81 + 8 virgules
if len(self.ejnoncej) == 89: break
# insertion barre sejparation
if len(self.ejnoncej) % 10 == 9: self.ejnoncej += '|'
if len(self.ejnoncej) != 89:
print('saisie-grille ERRONNÉE ({})'.format(len(self.ejnoncej)))
self.afficheSaisieGrille(csock)
return
# avec le programme de calcul maintenant
lignes = self.ejnoncej.replace('|', ',')
lignes = lignes.replace('.', '0')
self.sudoku = Sudoku(lignes)
# affiche
self.afficheEnTeste(csock)
self.afficheTitreEtSaisie(csock)
self.afficheCalculPartiel(csock)
self.afficheValeursPossibles(csock)
self.afficheQueue(csock)
def test_hardest(self):
grid = [
[8,0,0,0,0,0,0,0,0],
[0,0,3,6,0,0,0,0,0],
[0,7,0,0,9,0,2,0,0],
[0,5,0,0,0,7,0,0,0],
[0,0,0,0,4,5,7,0,0],
[0,0,0,1,0,0,0,3,0],
[0,0,1,0,0,0,0,6,8],
[0,0,8,5,0,0,0,1,0],
[0,9,0,0,0,0,4,0,0]
]
expected = [
[8,1,2,7,5,3,6,4,9],
[9,4,3,6,8,2,1,7,5],
[6,7,5,4,9,1,2,8,3],
[1,5,4,2,3,7,8,9,6],
[3,6,9,8,4,5,7,2,1],
[2,8,7,1,6,9,5,3,4],
[5,2,1,9,7,4,3,6,8],
[4,3,8,5,2,6,9,1,7],
[7,9,6,3,1,8,4,5,2]
]
sudoku = Sudoku()
actual = sudoku.solve((3, 3), grid)
self.assertEquals(actual, expected)
class SudokuTestCase4(unittest.TestCase):
def setUp(self):
self.sudoku = Sudoku([
[2, 0, 6, 4, 0, 0, 0, 5, 3],
[0, 0, 0, 2, 7, 5, 0, 9, 6],
[5, 1, 7, 0, 3, 0, 0, 0, 4],
[0, 3, 9, 8, 0, 0, 5, 1, 0],
[7, 5, 0, 1, 0, 6, 3, 0, 0],
[1, 0, 0, 0, 5, 3, 0, 6, 2],
[0, 7, 0, 0, 6, 2, 4, 8, 0],
[0, 0, 1, 3, 4, 0, 2, 0, 5],
[4, 2, 8, 0, 1, 0, 6, 0, 0]
])
def test_valid_solution(self):
self.sudoku.solve()
solution = np.array([
[2, 9, 6, 4, 8, 1, 7, 5, 3],
[8, 4, 3, 2, 7, 5, 1, 9, 6],
[5, 1, 7, 6, 3, 9, 8, 2, 4],
[6, 3, 9, 8, 2, 4, 5, 1, 7],
[7, 5, 2, 1, 9, 6, 3, 4, 8],
[1, 8, 4, 7, 5, 3, 9, 6, 2],
[3, 7, 5, 9, 6, 2, 4, 8, 1],
[9, 6, 1, 3, 4, 8, 2, 7, 5],
[4, 2, 8, 5, 1, 7, 6, 3, 9]
])
equality = {i == j for i, j in zip(
self.sudoku.puzzle.flatten(), solution.flatten())}
self.assertTrue(True in equality and False not in equality)
class Juego(object):
def __init__(self, nombre, dif = int):
"""
Constructor de la clase Juego. Aquí se almacena toda la información
correspondiente a un juego de sudoku.
@param nombre, nombre del jugador.
@param dif, dificultad del juego.
@author Iván Aveiga
"""
self.nombre = nombre
self.dif = dif
self.time = 0
self.hints = 5
self.juego = Sudoku() #tablero a jugar
self.tablero = Sudoku() #tablero lleno
self.create(dif)
def create(self, dif = int):
"""
Crea un nuevo tablero de 9x9 enteros
@param dif, dificultad del juego.
"""
g = Generator()
g.poblar_board()
self.tablero.parse(g.board)
g.gen_puzzle(dif)
self.juego.parse(g.puzzle)
def test_Sudoku_4_gano(self):
sudoku = Sudoku([["4", "2", "3", "1"],
["1", "3", "2", "4"],
["3", "1", "4", "2"],
["2", "4", "1", "3"]])
self.assertTrue(sudoku.gano())
def __init__(self, file_name, cnf_filename=None):
if cnf_filename is None:
#-- Set up and load in puzzle
self.sudoku = Sudoku()
self.puzzle_name = str(file_name[:-4])
self.solution_filename = self.puzzle_name + ".sol"
self.cnf_filename = self.puzzle_name + ".cnf"
self.sudoku.load(file_name)
self.sudoku.generate_cnf(self.cnf_filename)
else:
self.puzzle_name = str(file_name[:-4])
self.solution_filename = self.puzzle_name + ".sol"
self.cnf_filename = cnf_filename
#-- Load in clauses
clauses = []
with open(self.cnf_filename, 'r') as cnf:
lines = cnf.readlines()
for line in lines:
clause = list(map(int, line.rstrip('\n').strip().split(' ')))
clauses.append(clause)
#-- Make sudoku variables
variables = [
int(''.join(str(x) for x in var))
for var in itertools.product(range(1, 10), repeat=3)
]
#-- Set up generic class
super().__init__(variables, clauses, problem_name='Sudoku')
def impossible_test(self):
# impossible
puzzles = [
# From https://norvig.com/sudoku.html -> column 4, no 1 possible because of triple 5-6 doubles and triple 1s
'.....5.8....6.1.43..........1.5........1.6...3.......553.....61........4.........',
# obvious doubles
'12.......34...............5...........5..........................................',
'11.......34...............5......................................................',
]
for puzzle in puzzles:
puzzle = str2grid(puzzle)
s = Sudoku(puzzle)
s.flush_candidates()
self.assertFalse(s.check_possible()[0])
# possible
puzzles = [
'280070309600104007745080006064830100102009800000201930006050701508090020070402050',
'000010030009005008804006025000000600008004000120087000300900200065008000900000000',
'1.....................................5..........................................',
]
for puzzle in [puzzles[1]]:
puzzle = str2grid(puzzle)
s = Sudoku(puzzle)
s.flush_candidates()
self.assertTrue(s.check_possible()[0])
def __init__(self,line,verbose=False):
Sudoku.__init__(self,line,verbose) #initialize a basic sudoku object
self.sn=int(math.sqrt(self.n))
self.conflict=[] #conflict[row][col]-->cells in conflict with [row][col]
for row in range(self.n): #[row][cel] encoded as integer row*self.n+col
ROW=[]
for col in range(self.n):
setrowcol=self.computeConflicts(row,col)
ROW.append(setrowcol)
self.conflict.append(ROW)
self.forbidden=[] #forbidden[row][col]-->digits forbidden for [row][col]
for row in range(self.n):
ROW=[]
for col in range(self.n):
ROW.append([])
self.forbidden.append(ROW)
#no digit is forbidden at the beginning
#now we look at the instance and some digits are forbidden for some cells
for row in range(self.n):
for col in range(self.n):
if self.instance[row][col]!=0:
for x in self.conflict[row][col]:
rx=x/self.n; cx=x%self.n
self.forbidden[rx][cx].append(self.instance[row][col])
def test(self):
grid = [
[5, 3, 0, 0, 7, 0, 0, 0, 0],
[6, 0, 0, 1, 9, 5, 0, 0, 0],
[0, 9, 8, 0, 0, 0, 0, 6, 0],
[8, 0, 0, 0, 6, 0, 0, 0, 3],
[4, 0, 0, 8, 0, 3, 0, 0, 1],
[7, 0, 0, 0, 2, 0, 0, 0, 6],
[0, 6, 0, 0, 0, 0, 2, 8, 0],
[0, 0, 0, 4, 1, 9, 0, 0, 5],
[0, 0, 0, 0, 8, 0, 0, 7, 9]
]
expected = [
[5, 3, 4, 6, 7, 8, 9, 1, 2],
[6, 7, 2, 1, 9, 5, 3, 4, 8],
[1, 9, 8, 3, 4, 2, 5, 6, 7],
[8, 5, 9, 7, 6, 1, 4, 2, 3],
[4, 2, 6, 8, 5, 3, 7, 9, 1],
[7, 1, 3, 9, 2, 4, 8, 5, 6],
[9, 6, 1, 5, 3, 7, 2, 8, 4],
[2, 8, 7, 4, 1, 9, 6, 3, 5],
[3, 4, 5, 2, 8, 6, 1, 7, 9]
]
sudoku = Sudoku()
actual = sudoku.solve((3, 3), grid)
self.assertEquals(actual, expected)
def run(self, problem):
print("초기 시작")
print("스도쿠 문제번호 : ")
print("스도쿠 난이도 : ")
temp = np.array(list(map(int, list(problem)))).reshape(3, 3, 3, 3)
self.helpArray = Sudoku(
np.array([[SubBlock(subblock) for subblock in subblocks]
for subblocks in temp]))
print("helpArray: ")
self.helpArray.printSudoku()
self.manager = Manager(self.helpArray)
count = self.gaCount
while not self.end: # and self.gaCount < 3:
print("세대 : ", self.gaCount)
print("fitness : ", self.manager.fmin)
print("best solution: ")
self.manager.sudokuPool[0].printSudoku()
if count > 2000:
self.restart()
count = 1
self.end = self.manager.nextGeneration()
self.gaCount = self.gaCount + 1
count += 1
self.print()
def __init__(self, line, verbose=False):
Sudoku.__init__(self, line, verbose) #initialize a basic sudoku object
self.sn = int(math.sqrt(self.n))
self.conflict = [
] #conflict[row][col]-->cells in conflict with [row][col]
for row in range(
self.n): #[row][cel] encoded as integer row*self.n+col
ROW = []
for col in range(self.n):
setrowcol = self.computeConflicts(row, col)
ROW.append(setrowcol)
self.conflict.append(ROW)
self.forbidden = [
] #forbidden[row][col]-->digits forbidden for [row][col]
for row in range(self.n):
ROW = []
for col in range(self.n):
ROW.append([])
self.forbidden.append(ROW)
#no digit is forbidden at the beginning
#now we look at the instance and some digits are forbidden for some cells
for row in range(self.n):
for col in range(self.n):
if self.instance[row][col] != 0:
for x in self.conflict[row][col]:
rx = x / self.n
cx = x % self.n
self.forbidden[rx][cx].append(self.instance[row][col])
def sudoku(fname):
f_path = os.path.join(app.config['UPLOAD_FOLDER'], fname)
# create sudokuimage object
sdku_img = SudokuImage(f_path)
# this would be a good point to check if the
# image was processed correctly. The number of rows/cols
# not equal to 10 is a good indication of failure.
#
# the object is set so that self.rows/cols = False if the
# length is not equal to 10.
if sdku_img.rows and sdku_img.cols:
sudoku_grid = np.zeros((9,9), dtype = int)
# note: empty cells will be denoted by 0
print 'ENTER THE FOR LOOP'
# use knn to predict the value of non-empty sdku_img cells
for cell in sdku_img.predict_cells():
sudoku_grid[cell[0], cell[1]] = cell[2]
print 'MAKES IT OUT OF THE FOR LOOP'
no_failure = True
solved_grid = sudoku_grid.copy()
if request.method == 'POST':
sdku = Sudoku(solved_grid) # create sudoku object
no_failure, solution = sdku.solve() # solve sudoku
# if sudoku cant be solved, redirect with error message
if not no_failure:
flash("Oops, I am having trouble with your Sudoku! Let's try this again.")
return redirect(url_for('sudokusolver'))
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploaded_sudokus/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
# initial rendering to user, before they hit submit
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploaded_sudokus/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
else:
flash("Oops, I am having trouble with your Sudoku! Take a clearer photo and try again.")
return redirect(url_for('sudokusolver'))
def solveProblem(self, problem: Sudoku):
# Fill in all the possible tiles with educated predictions.
while True:
if self.applyNakedSingle(problem):
continue
if self.applyNakedTuple(problem):
continue
break
# Check if we find the solution after applying Sudoku.
if self.goalTest(problem):
return problem
# Save updated state of the problem before making guesses with candidates.
beforeUpdateProblem = copy.deepcopy(problem)
# Backtrack from populated sudoku problem
tile = self.findMostConstrainedTile(problem)
for index in range(len(tile.candidates)):
if not problem.isConflicting(tile.candidates[index],
rowIndex=tile.rowIndex,
colIndex=tile.colIndex):
problem.assignValue(value=tile.candidates[index],
row=tile.rowIndex,
col=tile.colIndex)
updatedProblem = self.solveProblem(problem)
if self.goalTest(updatedProblem):
return updatedProblem
else:
problem = beforeUpdateProblem
tile = problem.state[tile.rowIndex][tile.colIndex]
# No candidates, Hit dead end
return None
def setUp(self):
self.user4 = Interfaz()
self.user9 = Interfaz()
lista4 = [["4", "x", "3", "1"], ["x", "3", "x", "x"],
["3", "1", "x", "2"], ["x", "4", "x", "x"]]
self.user4.tam = 4
self.user4.level = "1"
self.user4.game = Sudoku(lista4)
lista9 = [["5", "3", "x", "x", "7", "x", "x", "x", "x"],
["6", "x", "x", "x", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]]
self.user9.tam = 9
self.user9.level = "1"
self.user9.game = Sudoku(lista9)
def index():
# delete old input and output images
if os.path.exists(INPUT_IMAGE_PATH):
os.remove(INPUT_IMAGE_PATH)
if os.path.exists(OUTPUT_IMAGE_PATH):
os.remove(OUTPUT_IMAGE_PATH)
if request.method == 'POST':
image = request.files['image']
if image and allowed_image(image.filename):
image.save(INPUT_IMAGE_PATH)
sudoku = Sudoku(img_path=INPUT_IMAGE_PATH)
status = sudoku.get_status()
if status == 'solved':
sudoku.save_solved_image(OUTPUT_IMAGE_PATH)
return render_template('index.html',
input_img=True,
output_img=True)
else:
return render_template('index.html',
input_img=True,
status=status)
else:
return render_template('index.html', error=True)
return render_template('index.html')
def __init__(self,line): Sudoku.__init__(self,line) self.conflict=[] for x in range(self.n): self.conflict.append([]) for x in range(self.n): # inizializzo matrice dei conflitti for y in range(self.n): self.conflict[x].append([]) """ inizializza la sottogriglia dei confitti""" for row in range(self.n): for col in range(self.n): for x in range(self.sn): for y in self.instance[(row/self.sn)*self.sn+x][(col/self.sn)*self.sn:(col/self.sn)*self.sn+self.sn]: if (y!=0 and y!= self.instance[row][col]): self.conflict[row][col].append(y) """ inizializza la colonna dei confitti""" k = ((row/self.sn)*self.sn)+(row%self.sn)+1 while((row/self.sn) == (k/self.sn)): k=k+1 if(k<=self.n): while( k < self.n): if(self.instance[k][col]!=0): self.conflict[row][col].append(self.instance[k][col]) k=k+1 k = ((row/self.sn)*self.sn)+(row%self.sn)-1 while ((row/self.sn)==(k/self.sn)): k=k-1 if(k > 0): while (k>0): if(self.instance[k][col]!=0): self.conflict[row][col].append(self.instance[k][col]) k=k-1 if(self.instance[k][col]!=0): self.conflict[row][col].append(self.instance[k][col]) """inizializza la riga dei confitti""" k = ((col/self.sn)*self.sn)+(col%self.sn)+1 while((col/self.sn) == (k/self.sn)): k=k+1 if(k<=self.n): while( k < self.n): if(self.instance[row][k]!=0): self.conflict[row][col].append(self.instance[row][k]) k=k+1 k = ((col/self.sn)*self.sn)+(col%self.sn)-1 while ((col/self.sn)==(k/self.sn)): k=k-1 if(k > 0): while (k>0): if(self.instance[row][k]!=0): self.conflict[row][col].append(self.instance[row][k]) k=k-1 if(self.instance[row][k]!=0): self.conflict[row][col].append(self.instance[row][k])
def test_sudoku_4x4(self):
esperado = np.array([[2, 1, 3, 4],
[4, 3, 1, 2],
[1, 4, 2, 3],
[3, 2, 4, 1]])
sudoku = Sudoku(self.tablero_4x4)
self.assertTrue(sudoku.solve_sudoku())
self.assertEqual(esperado.any(),(sudoku.sudoku).any(),msg="Compara Resultado esperado con el resultado obtenido, True--> si son iguales, False-->si no lo son")
def setUp(self):
self.table = ["53xx7xxxx", "6xx195xxx", "x98xxxx6x",
"8xxx6xxx3", "4xx8x3xx1", "7xxx2xxx6",
"x6xxxx28x", "xxx419xx5", "xxxx8xx79"]
self.sudoku = Sudoku(self.table, 9)
self.ori_pos = ["00", "01", "04", "10", "13", "14", "15", "21", "22",
"27", "30", "34", "38", "40", "43", "45", "48", "50",
"54", "58", "61", "66", "67", "73", "74", "75", "78",
"84", "87", "88"]
def sudoku(fname):
f_path = os.path.join(application.config['UPLOAD_FOLDER'], fname)
# create sudokuimage object
sdku_img = SudokuImage(f_path)
# catch any initial image processing errors
# if len(rows/cols) != 10, the object sets them to false
if sdku_img.rows and sdku_img.cols:
sudoku_grid = np.zeros((9,9), dtype = int)
# note: empty cells will be denoted by 0
# use knn to predict the value of non-empty sdku_img cells
for cell in sdku_img.predict_cells():
sudoku_grid[cell[0], cell[1]] = cell[2]
no_failure = True
solved_grid = sudoku_grid.copy()
if request.method == 'POST':
sdku = Sudoku(solved_grid) # create sudoku object
no_failure, solution = sdku.solve() # solve sudoku
# if sudoku cant be solved, redirect with error message
# typically this is due to bad prediction
if not no_failure:
flash("Oops, I am having trouble processing your Sudoku! Take a clearer photo and try again.")
return redirect(url_for('sudokusolver'))
# render when everything goes according to plan
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploads/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
# initial rendering to user, before they hit submit
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploads/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
else:
# this is rendered when the image can't be processed initially
flash("Oops, I am having trouble processing your Sudoku! Take a clearer photo and try again.")
return redirect(url_for('sudokusolver'))
def sudoku(fname):
f_path = os.path.join(application.config['UPLOAD_FOLDER'], fname)
# create sudokuimage object
sdku_img = SudokuImage(f_path)
# catch any initial image processing errors
# if len(rows/cols) != 10, the object sets them to false
if sdku_img.rows and sdku_img.cols:
sudoku_grid = np.zeros((9,9), dtype = int)
# note: empty cells will be denoted by 0
# use knn to predict the value of non-empty sdku_img cells
for cell in sdku_img.predict_cells():
sudoku_grid[cell[0], cell[1]] = cell[2]
no_failure = True
solved_grid = sudoku_grid.copy()
if request.method == 'POST':
sdku = Sudoku(solved_grid) # create sudoku object
no_failure, solution = sdku.solve() # solve sudoku
# if sudoku cant be solved, redirect with error message
# typically this is due to bad prediction
if not no_failure:
flash("Oops, I am having trouble processing your Sudoku! Take a clearer photo and try again.")
return redirect(url_for('sudokusolver'))
# render when everything goes according to plan
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploads/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
# initial rendering to user, before they hit submit
return render_template('sudoku_image.html',image =
url_for('static',
filename = 'uploads/'+fname),
initial_sudoku = sudoku_grid,
solved_sudoku = solved_grid)
else:
# this is rendered when the image can't be processed initially
flash("Oops, I am having trouble processing your Sudoku! Take a clearer photo and try again.")
return redirect(url_for('sudokusolver'))
def check_row_test(self):
grid = [[1, 2, 3, 4, 5, 6, 7, 8, 9], [2, 0, 0, 0, 0, 0, 0, 0, 0],
[3, 3, 0, 0, 0, 0, 0, 0, 0], [4, 0, 0, 0, 0, 0, 0, 0, 0],
[5, 0, 0, 0, 0, 0, 0, 0, 0], [6, 0, 0, 0, 0, 0, 0, 0, 0],
[7, 0, 0, 0, 0, 0, 0, 0, 0], [8, 0, 0, 0, 0, 0, 0, 0, 0],
[9, 0, 0, 0, 0, 0, 0, 0, 0]]
s = Sudoku(grid)
self.assertTrue(s.no_duplicates(grid[0]))
self.assertTrue(s.no_duplicates(grid[1]))
self.assertFalse(s.no_duplicates(grid[2]))
def ingresar_tamaño_tablero(self):#se ingresa el tamaño del tablero
self.tamaño = 0
while self.tamaño != "9" and self.tamaño != "4":
self.tamaño = input("Ingrese el tamaño del tablero (4/9)\n")
if self.tamaño != "9" and self.tamaño != "4":
print("Ingrese el tamaño del tablero nuevamente\n")
self.tamaño = int(self.tamaño)
self.board = api(int(self.tamaño))
self.game = Sudoku(self.board)
def test_position_originals(self):
self.table = ["53xx7xxxx", "6xx195xxx", "x98xxxx6x",
"8xxx6xxx3", "4xx8x3xx1", "7xxx2xxx6",
"x6xxxx28x", "xxx419xx5", "xxxx8xx79"]
self.sudoku = Sudoku(self.table, 9)
self.assertEqual(self.sudoku.ori_pos,
["00", "01", "04", "10", "13", "14", "15", "21", "22",
"27", "30", "34", "38", "40", "43", "45", "48", "50",
"54", "58", "61", "66", "67", "73", "74", "75", "78",
"84", "87", "88"])
def test_Sudoku_Gano(self):
sudoku = Sudoku([["4", "1", "3", "8", "2", "5", "6", "7", "9"],
["5", "6", "7", "1", "4", "9", "8", "3", "2"],
["2", "8", "9", "7", "3", "6", "1", "4", "5"],
["1", "9", "5", "4", "6", "2", "7", "8", "3"],
["7", "2", "6", "9", "8", "3", "5", "1", "4"],
["3", "4", "8", "5", "1", "7", "2", "9", "6"],
["8", "5", "1", "6", "9", "4", "3", "2", "7"],
["9", "7", "2", "3", "5", "8", "4", "6", "1"],
["6", "3", "4", "2", "7", "1", "9", "5", "8"]])
self.assertTrue(sudoku.gano())
def test_Sudoku_Zona(self):
sudoku = Sudoku([["5", "3", "x", "x", "x", "7", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_numero(2, 2, 5))
def test_Sudoku_Perdio(self):
sudoku = Sudoku([["5", "3", "x", "x", "x", "7", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.gano())
def test_Sudoku_Valores_Fijos(self):
sudoku = Sudoku([["5", "3", "x", "x", "7", "x", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "3", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_numero(0, 0, 1))
def find_options_test(self):
grid = [[5, 3, 0, 0, 7, 0, 0, 0, 0], [6, 0, 0, 1, 9, 5, 0, 0, 0],
[0, 9, 8, 0, 0, 0, 0, 6, 0], [8, 0, 0, 0, 6, 0, 0, 0, 3],
[4, 0, 0, 8, 0, 3, 0, 0, 1], [7, 0, 0, 0, 2, 0, 0, 0, 6],
[0, 6, 0, 0, 0, 0, 2, 8, 0], [0, 0, 0, 4, 1, 9, 0, 0, 5],
[0, 0, 0, 0, 8, 0, 0, 7, 9]]
s = Sudoku(grid)
self.assertEqual(s.find_options(0, 2), {1, 2, 4})
self.assertEqual(s.find_options(4, 4), {5})
self.assertEqual(s.find_options(5, 1), {1, 5})
self.assertEqual(s.find_options(8, 6), {1, 3, 4, 6})
def test_Sudoku_Columna_2(self):
sudoku = Sudoku([["5", "3", "x", "x", "x", "7", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_numero(0, 8, 9))
def test_fill(self):
sudoku = Sudoku(easy_grid)
sudoku.fill()
self.assertEqual(sudoku.solved, True)
self.assertEqual(sudoku.feasible, True)
original_values = True
for i in range(sudoku.size):
for j in range(sudoku.size):
val = easy_grid[i][j]
equal = (val == 0 or val == sudoku.grid[i][j])
original_values = original_values and equal
self.assertEqual(original_values, True)
def test_Sudoku_Ingrasar_valor_sobre_valor_fijo(self):
sudoku = Sudoku([["5", "3", "x", "x", "x", "7", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_valor(0, 0, 3))
def test_Sudoku_Repetido_en_Fila_1(self):
sudoku = Sudoku([["5", "3", "x", "x", "x", "7", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_valor(1, 3, 5))
def test_Sudoku_Repetido_en_Columna_3(self):
sudoku = Sudoku([["5", "3", "x", "x", "7", "x", "x", "x", "x"],
["6", "x", "x", "1", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "3", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.assertFalse(sudoku.ingresar_valor(6, 4, 2))
def test_solve(self):
sudoku = Sudoku(test_grid)
solved = sudoku.solve()
self.assertEqual(solved.valid, True)
self.assertEqual(solved.feasible, True)
self.assertEqual(solved.solved, True)
original_values = True
for i in range(sudoku.size):
for j in range(sudoku.size):
val = test_grid[i][j]
equal = (val == 0 or val == solved.grid[i][j])
original_values = original_values and equal
self.assertEqual(original_values, True)
def test_sudoku_9x9(self):
esperado = np.array( [[6, 7, 2, 1, 5, 4, 9, 3, 8],
[3, 5, 4, 2, 8, 9, 1, 6, 7],
[8, 1, 9, 3, 7, 6, 2, 5, 4],
[7, 2, 1, 6, 4, 3, 8, 9, 5],
[9, 4, 8, 5, 1, 2, 3, 7, 6],
[5, 6, 3, 8, 9, 7, 4, 1, 2],
[4, 8, 5, 7, 3, 1, 6, 2, 9],
[2, 3, 7, 9, 6, 8, 5, 4, 1],
[1, 9, 6, 4, 2, 5, 7, 8, 3]])
sudoku = Sudoku(self.tablero_9x9)
self.assertTrue(sudoku.solve_sudoku())
self.assertEqual(esperado.any(),(sudoku.sudoku).any(),msg="Compara Resultado esperado con el resultado obtenido, True--> si son iguales, False-->si no lo son")
class Interfaz():
def ingresar_tamaño_tablero(self):#se ingresa el tamaño del tablero
self.tamaño = 0
while self.tamaño != "9" and self.tamaño != "4":
self.tamaño = input("Ingrese el tamaño del tablero (4/9)\n")
if self.tamaño != "9" and self.tamaño != "4":
print("Ingrese el tamaño del tablero nuevamente\n")
self.tamaño = int(self.tamaño)
self.board = api(int(self.tamaño))
self.game = Sudoku(self.board)
def ingresar_posicion(self, fila, columna, valor): #se verifica que exista la posicion en la que la persona va a ingresar el valor
if (fila > 0 and fila <= self.tamaño and columna > 0 and columna <= self.tamaño and valor > 0 and valor <= self.tamaño):
return True
else:
return False
def ingresar_valor(self, numero, x, y):
try:
if int(x) > self.tamaño:
return False
elif int(y) > self.tamaño:
return False
elif numero != "x":
if int(numero) > 0 and int(numero) < self.tamaño+1:
return True
return True
except Exception as w:
print(w)
return False
def pedir_valores(self):
self.numero = input("Ingrese el valor")
self.fila = input("Escoja fila")
self.columna = input("Escoja columna")
print("")
def jugar(self):
self.ingresar_tamaño_tablero()
print("")
print(self.game.imprimir_tablero())
while not self.game.win():
self.pedir_valores()
if self.ingresar_valor(self.fila, self.columna, self.numero):
self.game.ingresar_valor(int(self.fila)-1, int(self.columna)-1, self.numero)
print(self.game.imprimir_tablero())
else:
print("INGRESE UN VALOR CORRECTO")
def ingresar_dimension(self):
self.tamaño = 0
#Para ingresear la dimension del tablero
while self.tamaño != "9" and self.tamaño != "4":
self.tamaño = input("Ingrese el tamaño del tablero (4/9)\n")
if self.tamaño != "9" and self.tamaño != "4":
print(
"EL TAMAÑO DEL TABLERO NO ES CORRECTO \nIngrese el tamaño del tablero nuevamente...\n"
)
self.tamaño = int(self.tamaño)
self.tablero = api(int(self.tamaño))
self.game = Sudoku(self.tablero)
def __init__(self, nombre, dif = int):
"""
Constructor de la clase Juego. Aquí se almacena toda la información
correspondiente a un juego de sudoku.
@param nombre, nombre del jugador.
@param dif, dificultad del juego.
@author Iván Aveiga
"""
self.nombre = nombre
self.dif = dif
self.time = 0
self.hints = 5
self.juego = Sudoku() #tablero a jugar
self.tablero = Sudoku() #tablero lleno
self.create(dif)
def setUp(self):
self.sudoku9 = Sudoku([["5", "3", "x", "x", "7", "x", "x", "x", "x"],
["6", "x", "x", "x", "9", "5", "x", "x", "x"],
["x", "9", "8", "x", "x", "x", "x", "6", "x"],
["8", "x", "x", "x", "6", "x", "x", "x", "3"],
["4", "x", "x", "8", "x", "3", "x", "x", "1"],
["7", "x", "x", "x", "2", "x", "x", "x", "6"],
["x", "6", "x", "x", "x", "x", "2", "8", "x"],
["x", "x", "x", "4", "1", "9", "x", "x", "5"],
["x", "x", "x", "x", "8", "x", "x", "7", "9"]])
self.sudoku4 = Sudoku([["4", "x", "3", "1"],
["x", "3", "x", "x"],
["3", "1", "x", "2"],
["x", "4", "x", "x"]])
def setUp(self):
self.sudoku = Sudoku([
[8, 0, 0, 0, 5, 4, 0, 6, 0],
[0, 9, 0, 0, 3, 2, 0, 0, 0],
[0, 0, 4, 0, 6, 7, 0, 3, 1],
[0, 0, 2, 7, 0, 0, 0, 0, 5],
[4, 6, 0, 2, 0, 5, 0, 1, 8],
[1, 0, 0, 0, 0, 8, 7, 0, 0],
[2, 1, 0, 4, 8, 0, 9, 0, 0],
[0, 0, 0, 5, 7, 0, 0, 4, 0],
[0, 4, 0, 6, 2, 0, 0, 0, 3]
])
def setUp(self):
self.sudoku = Sudoku([
[2, 0, 6, 4, 0, 0, 0, 5, 3],
[0, 0, 0, 2, 7, 5, 0, 9, 6],
[5, 1, 7, 0, 3, 0, 0, 0, 4],
[0, 3, 9, 8, 0, 0, 5, 1, 0],
[7, 5, 0, 1, 0, 6, 3, 0, 0],
[1, 0, 0, 0, 5, 3, 0, 6, 2],
[0, 7, 0, 0, 6, 2, 4, 8, 0],
[0, 0, 1, 3, 4, 0, 2, 0, 5],
[4, 2, 8, 0, 1, 0, 6, 0, 0]
])
def setUp(self):
self.sudoku = Sudoku([
[0, 3, 5, 2, 9, 0, 8, 6, 4],
[0, 8, 2, 4, 1, 0, 7, 0, 3],
[7, 6, 4, 3, 8, 0, 0, 9, 0],
[2, 1, 8, 7, 3, 9, 0, 4, 0],
[0, 0, 0, 8, 0, 4, 2, 3, 0],
[0, 4, 3, 0, 5, 2, 9, 7, 0],
[4, 0, 6, 5, 7, 1, 0, 0, 9],
[3, 5, 9, 0, 2, 8, 4, 1, 7],
[8, 0, 0, 9, 0, 0, 5, 2, 6]
])
def setUp(self):
self.sudoku = Sudoku([
[0, 0, 0, 0, 5, 6, 4, 0, 0],
[6, 0, 7, 0, 0, 1, 0, 8, 9],
[0, 1, 0, 0, 0, 0, 0, 6, 0],
[7, 2, 0, 3, 0, 9, 0, 5, 0],
[1, 3, 0, 0, 6, 0, 0, 7, 2],
[0, 9, 0, 1, 0, 7, 0, 4, 3],
[0, 7, 0, 0, 0, 0, 0, 9, 0],
[8, 5, 0, 9, 0, 0, 3, 0, 6],
[0, 0, 1, 5, 8, 0, 0, 0, 0]
])
class SudokuTestCase3(unittest.TestCase):
"""
Tests the validity of the sudoku solver algorithms, in making sure that
the solution puzzle that it obtains is correct
"""
def setUp(self):
self.sudoku = Sudoku([
[8, 0, 0, 0, 5, 4, 0, 6, 0],
[0, 9, 0, 0, 3, 2, 0, 0, 0],
[0, 0, 4, 0, 6, 7, 0, 3, 1],
[0, 0, 2, 7, 0, 0, 0, 0, 5],
[4, 6, 0, 2, 0, 5, 0, 1, 8],
[1, 0, 0, 0, 0, 8, 7, 0, 0],
[2, 1, 0, 4, 8, 0, 9, 0, 0],
[0, 0, 0, 5, 7, 0, 0, 4, 0],
[0, 4, 0, 6, 2, 0, 0, 0, 3]
])
def test_sudoku_valid_solution(self):
self.sudoku.solve()
solution = np.array([
[8, 7, 3, 1, 5, 4, 2, 6, 9],
[6, 9, 1, 8, 3, 2, 5, 7, 4],
[5, 2, 4, 9, 6, 7, 8, 3, 1],
[3, 8, 2, 7, 1, 6, 4, 9, 5],
[4, 6, 7, 2, 9, 5, 3, 1, 8],
[1, 5, 9, 3, 4, 8, 7, 2, 6],
[2, 1, 6, 4, 8, 3, 9, 5, 7],
[9, 3, 8, 5, 7, 1, 6, 4, 2],
[7, 4, 5, 6, 2, 9, 1, 8, 3],
])
equality = {i == j for i, j in zip(
self.sudoku.puzzle.flatten(), solution.flatten())}
self.assertTrue(True in equality and False not in equality)
class SudokuTestCase(unittest.TestCase):
"""
Tests the validity of the solve() method on the challenge problem to
check whether the solved puzzle matches the correct solution
"""
def setUp(self):
self.sudoku = Sudoku([
[0, 3, 5, 2, 9, 0, 8, 6, 4],
[0, 8, 2, 4, 1, 0, 7, 0, 3],
[7, 6, 4, 3, 8, 0, 0, 9, 0],
[2, 1, 8, 7, 3, 9, 0, 4, 0],
[0, 0, 0, 8, 0, 4, 2, 3, 0],
[0, 4, 3, 0, 5, 2, 9, 7, 0],
[4, 0, 6, 5, 7, 1, 0, 0, 9],
[3, 5, 9, 0, 2, 8, 4, 1, 7],
[8, 0, 0, 9, 0, 0, 5, 2, 6]
])
def test_sudoku_puzzle_not_solved(self):
self.assertFalse(self.sudoku.isSolved())
def test_sudoku_puzzle_solved(self):
self.sudoku.solve()
self.assertTrue(self.sudoku.isSolved())
def test_sudoku_valid_solution(self):
self.sudoku.solve()
solution = np.array([[1, 3, 5, 2, 9, 7, 8, 6, 4],
[9, 8, 2, 4, 1, 6, 7, 5, 3],
[7, 6, 4, 3, 8, 5, 1, 9, 2],
[2, 1, 8, 7, 3, 9, 6, 4, 5],
[5, 9, 7, 8, 6, 4, 2, 3, 1],
[6, 4, 3, 1, 5, 2, 9, 7, 8],
[4, 2, 6, 5, 7, 1, 3, 8, 9],
[3, 5, 9, 6, 2, 8, 4, 1, 7],
[8, 7, 1, 9, 4, 3, 5, 2, 6]])
equality = {i == j for i, j in zip(
self.sudoku.puzzle.flatten(), solution.flatten())}
self.assertTrue(True in equality and False not in equality)
class SudokuTestCase2(unittest.TestCase):
"""
Tests the validity of the solve() method of the Sudoku class to
make sure that the ending puzzle matches the correct solution
"""
def setUp(self):
self.sudoku = Sudoku([
[0, 0, 0, 0, 5, 6, 4, 0, 0],
[6, 0, 7, 0, 0, 1, 0, 8, 9],
[0, 1, 0, 0, 0, 0, 0, 6, 0],
[7, 2, 0, 3, 0, 9, 0, 5, 0],
[1, 3, 0, 0, 6, 0, 0, 7, 2],
[0, 9, 0, 1, 0, 7, 0, 4, 3],
[0, 7, 0, 0, 0, 0, 0, 9, 0],
[8, 5, 0, 9, 0, 0, 3, 0, 6],
[0, 0, 1, 5, 8, 0, 0, 0, 0]
])
def test_sudoku_solved(self):
self.sudoku.solve()
self.sudoku.isSolved()
def test_sudoku_valid_solution(self):
self.sudoku.solve()
solution = np.array([
[2, 8, 9, 7, 5, 6, 4, 3, 1],
[6, 4, 7, 2, 3, 1, 5, 8, 9],
[3, 1, 5, 4, 9, 8, 2, 6, 7],
[7, 2, 6, 3, 4, 9, 1, 5, 8],
[1, 3, 4, 8, 6, 5, 9, 7, 2],
[5, 9, 8, 1, 2, 7, 6, 4, 3],
[4, 7, 3, 6, 1, 2, 8, 9, 5],
[8, 5, 2, 9, 7, 4, 3, 1, 6],
[9, 6, 1, 5, 8, 3, 7, 2, 4],
])
equality = {i == j for i, j in zip(
self.sudoku.puzzle.flatten(), solution.flatten())}
self.assertTrue(True in equality and False not in equality)
def parse_grid(s):
"""Parse a grid from a string.
Assumes the string reads the grid line by line,
and contains 81 numerical characters.
"""
s = s.strip()
if not (len(s) == 81 and s.isdigit()):
raise Exception("The grid does not have the right length or contains" +
" non-number characters.")
return [map(int, list(s[i:i+9])) for i in range(0, len(s), 9)]
if __name__ == '__main__':
parser = ArgumentParser(description="Solve a Sudoku.")
parser.add_argument('grid',
help="The grid, read line by line as a string of 81 " +
"numerical characters. Zeroes represent empty '" +
"cells.")
grid = parse_grid(parser.parse_args().grid)
sdk = Sudoku(grid)
print "\n-- original grid -- \n"
print sdk
print "-- solved grid -- \n"
t_ini = time.time()
solved = sdk.solve()
t_end = time.time()
print solved
print "solved in %.2f sec." % (t_end - t_ini)
def test_sudoku_son(self):
sudoku = Sudoku(test_grid)
son = sudoku.sudoku_son(1, 2, 3)
self.assertEqual(son.grid[1][2], 3)
def sudokuMasSolve(level):
s = Sudoku(level)
return s.asd()
def getSudoku(level): s = Sudoku(level) return s.toSudokubumSemilla()
supported action: \n\
* print: print in console the sudoku values \n\
* solve: solve the sudoku \n\
* generate: generate a new sudoku puzzle")
sudo = None
for arg in sys.argv[1::2]:
idx = sys.argv.index(arg) + 1
if len(sys.argv) <= idx:
raise Exception("Specify a value for the action : " + arg)
argvalue = sys.argv[idx]
if arg == "-n":
sudo = Sudoku(int(argvalue))
if arg == "-v":
index = 0
cells_number = sudo.dimension ** 2
for value in str(argvalue).split(","):
x = index // cells_number
y = index - ((index // cells_number) * cells_number)
sudo.set_value(x, y, value)
index += 1
if arg == "-a":
if argvalue == "print":
sudo.print()
elif argvalue == "solve":
sudo.print()
:return: priority list of (([list of node solutions],row<int>,column<int>))
"""
onesList = oldSudoku.getDepthOf(1)
totalList = []
totalList.extend(onesList)
for i in list(range(1+1,oldSudoku.getSize()+1)):
totalList.extend(oldSudoku.getDepthOf(i))
return totalList
def _SmallestToLargetList(self, oldSudoku):
totalList = []
for i in xrange(oldSudoku.getSize()+1):
totalList.extend(oldSudoku.getDepthOf(i))
return totalList
class DeadEndError(Exception):
""" NODE Exception Class """
def __init__(self,value):
self.value = value
def __str__(self):
return repr(self.value)
print "Starting"
s = Sudoku.Sudoku(9,Sudoku.makeSudokuBoard('Sudoku/Board01.txt'))
solver = SudokuCSP(s)
solver.solve()
def test_check_square(self):
sudoku = Sudoku(test_grid)
for i in range(sudoku.size):
self.assertEqual(sudoku.check_square(i), True)
def test_find_disjunction(self):
sudoku = Sudoku(test_grid)
i, j, l = sudoku.find_disjunction()
self.assertEqual(i, 2)
self.assertEqual(j, 8)
self.assertEqual(l, [5, 7])
def solve_puzzle(p):
c = Sudoku(p)
c.solve_board()
return c.board_to_list()
import base64
from Sudoku import Sudoku
s = Sudoku()
#s.generate()
s.setValues([
[0, 7, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 3, 5, 9, 0, 2],
[0, 0, 5, 0, 0, 0, 0, 3, 0],
[0, 0, 0, 0, 6, 1, 0, 0, 7],
[0, 0, 8, 0, 4, 0, 0, 0, 1],
[0, 0, 9, 0, 0, 0, 0, 0, 0],
[1, 0, 3, 6, 0, 0, 2, 5, 8],
[0, 0, 7, 0, 0, 0, 3, 0, 0],
[5, 6, 0, 2, 0, 0, 0, 0 ,0]
])
s.resolve()
#s.setValues([
# [0, 2, 7, 0, 0, 0, 4, 3, 8],
# [0, 0, 8, 4, 5, 0, 0, 0, 9],
# [9, 0, 1, 0, 0, 2, 0, 6, 5],
#
# [7, 0, 0, 0, 0, 6, 0, 0, 0],
# [0, 0, 6, 3, 9, 8, 0, 1, 7],
# [0, 0, 0, 0, 4, 0, 9, 0, 0],
#
# [2, 0, 4, 1, 6, 0, 0, 0, 0],
def test_possible_values(self):
sudoku = Sudoku(test_grid)
self.assertEqual(sudoku.possible_values(0, 0), [3, 4, 5, 7, 9])
def main():
num_of_flags = len(argv) -1
sudoku = Sudoku();
if num_of_flags > 0:
if '-' in argv[1]: # is correct flag
flag = argv[1]
flag = flag[1:]
if FROM_FILE_TO_FILE == flag: # flag -f
if num_of_flags > 2:
if not sudoku.init_from_file(argv[2]):
exit("File " + argv[2] + " not exist.")
try:
f = open(argv[3], "w")
except(IOError):
exit("File error.")
else:
if not sudoku.init_from_file():
exit("File sudoku.txt not exist.");
try:
f = open("answer.txt", "w")
except(IOError):
exit("File error.")
st = time.time()
answer = Sudoku.format_sudoku_answer( sudoku.solve() )
f.write(answer)
print "Time elapsed: {0} s. ".format(time.time() - st)
elif FROM_CONST_TO_FILE == flag: # flag -c
sudoku.init_from_string(SUDOKU)
st = time.time()
answer = Sudoku.format_sudoku_answer( sudoku.solve() )
if num_of_flags > 1:
try:
f = open(argv[2], "w")
except(IOError):
exit("File error.")
else:
try:
f = open("answer.txt", "w")
except(IOError):
exit("File error.")
f.write(answer)
print "Time elapsed: {0} s. ".format(time.time() - st)
elif FROM_FILE_TO_DISLAY == flag: # flag -d
if num_of_flags > 1:
if not sudoku.init_from_file(argv[2]):
exit("File " + argv[2] + " not exist.");
else:
if not sudoku.init_from_file():
exit("File sudoku.txt not exist.");
st = time.time()
answer = Sudoku.format_sudoku_answer( sudoku.solve() )
print "ANSWER:\n", answer
print "Time elapsed: {0} s. ".format(time.time() - st)
elif FROM_CONST_TO_DISPALY == flag: # flag -e
sudoku.init_from_string(SUDOKU)
st = time.time()
answer = Sudoku.format_sudoku_answer( sudoku.solve() )
print "ANSWER:\n", answer
print "Time elapsed: {0} s. ".format(time.time() - st)
elif HELP[0] == flag or HELP[1] == flag:
display_help();
else:
exit("Incorect flag. Use SudokuSolver.py -help")
else:
exit("Incorect flag. Use SudokuSolver.py -help")
else:
if not sudoku.init_from_file():
exit("File sudoku.txt not exist.");
try:
f = open("answer.txt", "w")
except(IOError):
exit("File error.")
st = time.time()
answer = Sudoku.format_sudoku_answer( sudoku.solve() )
f.write(answer)
print "Time elapsed: {0} s. ".format(time.time() - st)
return 0
parser.add_option(
'-i', '--input-file', action="store", type="string",
dest="inputFile",
help="Specify file where sudoku puzzle is stored")
parser.add_option('-o', '--output-file', action='store', type="string",
dest="outputFile",
help="Specify a file to store the solved sudoku")
parser.add_option('-v', '--verbose', action="store_true", dest="verbose",
help="For a verbose output of the solving process")
(options, args) = parser.parse_args()
if options.inputFile is None:
parser.print_help()
else:
# Get file contents
sudokuPuzzle = SudokuIO.readFromFile(options.inputFile)
# Initialize Sudoku solver
sudoku = Sudoku(sudokuPuzzle)
#Verbose output
if options.verbose:
print("Initial Puzzle")
print(sudoku.puzzle)
# Call to solve method
sudoku.solve()
# Verbose output
if options.verbose:
print("Solved puzzle")
print(sudoku.puzzle)
# if -o option selected
if options.outputFile:
SudokuIO.writeToFile(sudoku.puzzle, options.outputFile)
