/.idea

This is a sudoku generating application. It generates a sudoku puzzle with a unique solution

of varying difficulties according to the requested difficulty.

This was one of my projects for a math modeling class in college.

This is not being actively developed, though there are certainly

improvements that could be made.

This project relies on numpy for performant array operations. `pip install numpy`.

Yep, lots of sudoku generators exist. Something cool that makes this one unique is

the concept of board density in relation to difficulty. The basic idea is that the

more disjoint the set of starting cells is, the more difficult the puzzle will be

to solve. This goes beyond the normal measure of "less starting cells is more difficult"

and begins to consider what particular configurations of those starting cells makes for

the most difficult puzzle.

python sudoku_generator.py base.txt <difficulty>

- easy

- <pre>

6|_|4|_|_|1|_|7|9

_|8|7|6|_|_|1|_|_

5|_|3|9|_|8|2|_|_

2|4|_|_|_|_|5|6|_

8|7|_|3|6|5|_|_|2

3|_|_|_|1|4|_|9|8

1|3|_|7|_|9|6|5|_

7|9|_|_|5|6|_|2|1

_|_|5|1|2|_|_|8|7

</pre>

- medium

- <pre>

_|_|_|_|_|_|_|7|8

5|_|_|7|_|_|_|4|2

9|_|8|4|_|6|_|_|1

_|_|6|2|3|1|7|_|_

_|_|3|_|_|7|4|5|6

7|8|9|_|_|_|_|_|_

2|1|_|9|7|_|3|_|_

8|9|_|_|5|_|2|1|_

_|6|_|_|4|_|8|_|7

</pre>

- hard

- <pre>

_|_|_|_|_|_|_|5|_

_|8|9|5|_|_|1|_|_

5|_|_|4|1|2|_|_|_

_|_|_|_|7|9|4|2|_

_|6|_|_|_|_|7|8|_

8|9|_|_|4|6|_|_|_

9|_|8|6|_|_|_|_|_

_|_|_|3|2|1|_|_|7

3|_|2|_|8|_|5|_|4

</pre>

- extreme

- <pre>

_|4|_|_|1|_|9|_|_

_|_|5|_|_|_|6|_|4

_|7|_|_|2|_|_|1|_

3|_|_|_|9|_|4|_|5

9|8|_|_|_|_|1|_|_

_|_|_|1|3|_|_|_|_

5|_|3|2|_|_|_|7|_

_|_|_|3|_|6|_|4|1

_|_|2|8|_|_|_|_|6

</pre>

import random

from Cell import Cell

class Board:

# intializing a board

def __init__(self, numbers=None):

# we keep list of cells and dictionaries to point to each cell

# by various locations

self.rows = {}

self.columns = {}

self.boxes = {}

self.cells = []

# looping rows

for row in xrange(0, 9):

# looping columns

for col in xrange(0, 9):

# calculating box

box = 3 * (row / 3) + (col / 3)

# creating cell instance

cell = Cell(row, col, box)

# if initial set is given, set cell value

if not numbers is None:

cell.value = numbers.pop(0)

else:

cell.value = 0

# initializing dictionary keys and corresponding lists

# if they are not initialized

if not row in self.rows:

self.rows[row] = []

if not col in self.columns:

self.columns[col] = []

if not box in self.boxes:

self.boxes[box] = []

# adding cells to each list

self.rows[row].append(cell)

self.columns[col].append(cell)

self.boxes[box].append(cell)

self.cells.append(cell)

# returning cells in puzzle that are not set to zero

def get_used_cells(self):

return [x for x in self.cells if x.value != 0]

# returning cells in puzzle that are set to zero

def get_unused_cells(self):

return [x for x in self.cells if x.value == 0]

# returning all possible values that could be assigned to the

# cell provided as argument

def get_possibles(self, cell):

all = self.rows[cell.row] + self.columns[cell.col] + self.boxes[cell.box]

excluded = set([x.value for x in all if x.value!=0 and x.value != cell.value])

results = [x for x in range(1, 10) if x not in excluded]

return results

# calculates the density of a specific cell's context

def get_density(self,cell):

all = self.rows[cell.row] + self.columns[cell.col] + self.boxes[cell.box]

if cell.value != 0: all.remove(cell)

return len([x for x in set(all) if x.value != 0])/20.0

# gets complement of possibles, values that cell cannot be

def get_excluded(self,cell):

all = self.rows[cell.row] + self.columns[cell.col] + self.boxes[cell.box]

excluded = set([x.value for x in all if x.value!=0 and x.value != cell.value])

# swaps two rows

def swap_row(self, row_index1, row_index2, allow=False):

if allow or row_index1 / 3 == row_index2 / 3:

for x in range(0, len(self.rows[row_index2])):

temp = self.rows[row_index1][x].value

self.rows[row_index1][x].value = self.rows[row_index2][x].value

self.rows[row_index2][x].value = temp

else:

raise Exception('Tried to swap non-familial rows.')

# swaps two columns

def swap_column(self, col_index1, col_index2, allow=False):

if allow or col_index1 / 3 == col_index2 / 3:

for x in range(0, len(self.columns[col_index2])):

temp = self.columns[col_index1][x].value

self.columns[col_index1][x].value = self.columns[col_index2][x].value

self.columns[col_index2][x].value = temp

else:

raise Exception('Tried to swap non-familial columns.')

# swaps two stacks

def swap_stack(self, stack_index1, stack_index2):

for x in range(0, 3):

self.swap_column(stack_index1 * 3 + x, stack_index2 * 3 + x, True)

# swaps two bands

def swap_band(self, band_index1, band_index2):

for x in range(0, 3):

self.swap_row(band_index1 * 3 + x, band_index2 * 3 + x, True)

# copies the board

def copy(self):

b = Board()

for row in xrange(0,len(self.rows)):

for col in xrange(0,len(self.columns)):

b.rows[row][col].value=self.rows[row][col].value

return b

# returns string representation

def __str__(self):

output = []

for index, row in self.rows.iteritems():

my_set = map(str, [x.value for x in row])

new_set = []

for x in my_set:

if x == '0': new_set.append("_")

else: new_set.append(x)

output.append('|'.join(new_set))

return '\r\n'.join(output)

# exporting puzzle to a html table for prettier visualization

def html(self):

html = "<table>"

for index, row in self.rows.iteritems():

values = []

row_string = "<tr>"

for x in row:

if x.value == 0:

values.append(" ")

row_string += "<td>%s</td>"

else:

values.append(x.value)

row_string +="<td>%d</td>"

row_string += "</tr>"

html += row_string % tuple(values)

html += "</table>"

return html

class Cell:

# defining the cell, each cell keeps track of its own value and location

def __init__(self,row,col,box):

self.row = row

self.col = col

self.box = box

self.value = 0

# returns a string representation of cell (for debugging)

def __str__(self):

temp = (self.value,self.row,self.col,self.box)

return "Value: %d, Row: %d, Col: %d, Box: %d" % temp

from Board import *

from Solver import *

class Generator:

# constructor for generator, reads in a space delimited

def __init__(self, starting_file):

# opening file

f = open(starting_file)

# reducing file to a list of numbers

numbers = filter(lambda x: x in '123456789',list(reduce(lambda x,y:x+y,f.readlines())))

numbers = map(int,numbers)

# closing file

f.close()

# constructing board

self.board = Board(numbers)

# function randomizes an existing complete puzzle

def randomize(self, iterations):

# not allowing transformations on a partial puzzle

if len(self.board.get_used_cells())==81:

# looping through iterations

for x in range(0, iterations):

# to get a random column/row

case = random.randint(0, 3)

# to get a random band/stack

block = random.randint(0, 2) * 3

# in order to select which row and column we shuffle an array of

# indices and take both elements

options = range(0,3)

random.shuffle(options)

piece1, piece2 = options[0],options[1]

# pick case according to random to do transformation

if case == 0:

self.board.swap_row(block + piece1, block + piece2)

elif case == 1:

self.board.swap_column(block + piece1, block + piece2)

elif case == 2:

self.board.swap_stack(piece1, piece2)

elif case == 3:

self.board.swap_band(piece1, piece2)

else:

raise Exception('Rearranging partial board may compromise uniqueness.')

# method gets all possible values for a particular cell, if there is only one

# then we can remove that cell

def reduce_via_logical(self, cutoff = 81):

cells = self.board.get_used_cells()

random.shuffle(cells)

for cell in cells:

if len(self.board.get_possibles(cell)) == 1:

cell.value = 0

cutoff -= 1

if cutoff == 0:

break

# method attempts to remove a cell and checks that solution is still unique

def reduce_via_random(self, cutoff=81):

temp = self.board

existing = temp.get_used_cells()

# sorting used cells by density heuristic, highest to lowest

new_set = [(x,self.board.get_density(x)) for x in existing]

elements= [x[0] for x in sorted(new_set, key=lambda x: x[1], reverse=True)]

# for each cell in sorted list

for cell in elements:

original = cell.value

# get list of other values to try in its place

complement = [x for x in range(1,10) if x != original]

ambiguous = False

# check each value in list of other possibilities to try

for x in complement:

# set cell to value

cell.value = x

# create instance of solver

s = Solver(temp)

# if solver can fill every box and the solution is valid then

# puzzle becomes ambiguous after removing particular cell, so we can break out

if s.solve() and s.is_valid():

cell.value = original

ambiguous = True

break

# if every value was checked and puzzle remains unique, we can remove it

if not ambiguous:

cell.value = 0

cutoff -= 1

# if we ever meet the cutoff limit we can break out

if cutoff == 0:

break

# returns current state of generator including number of empty cells and a representation

# of the puzzle

def get_current_state(self):

template = "There are currently %d starting cells.\n\rCurrent puzzle state:\n\r\n\r%s\n\r"

return template % (len(self.board.get_used_cells()),self.board.__str__())