From 53629f4d566101c6c1b890d1e604648a12a579ba Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sat, 7 Oct 2017 09:20:49 -0700
Subject: [PATCH 01/53] Empty Sudoku board, with a pretty printing __str__()

---
 sudoku.py | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 sudoku.py

diff --git a/sudoku.py b/sudoku.py
new file mode 100644
index 0000000..4354bf2
--- /dev/null
+++ b/sudoku.py
@@ -0,0 +1,37 @@
+#!env python3
+# Eryn Wells <eryn@erynwells.me>
+'''
+A Sudoku puzzle solver.
+'''
+
+import math
+
+class Sudoku:
+    def __init__(self, size=9):
+        dim = math.sqrt(size)
+        if dim != int(dim):
+            raise ValueError('Board size must have an integral square root.')
+        self.dimension = int(dim)
+        self.size = size
+        self.board = bytearray(b'\x00' * (size * size))
+
+    def __str__(self):
+        field_width = len(str(self.size))
+        dim = int(math.sqrt(self.size))
+        lines = []
+        spacer = '+' + '+'.join(['-' * (field_width * dim) for _ in range(dim)]) + '+'
+        for line in range(self.size):
+            chunks = []
+            for i in range(dim):
+                fields = []
+                for j in range(dim):
+                    idx = line * self.size + i * dim + j
+                    fields.append('{{board[{i}]:^{width}}}'.format(i=idx, width=field_width))
+                chunks.append(''.join(fields))
+            if (line % dim) == 0:
+                lines.append(spacer)
+            lines.append('|' + '|'.join(chunks) + '|')
+        lines.append(spacer)
+        fmt = '\n'.join(lines)
+        out = fmt.format(board=[str(n) if n != 0 else ' ' for n in self.board])
+        return out

From 2feef04ad9e03c39e1addd02ba42dfa5b7f2041c Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sat, 7 Oct 2017 10:39:19 -0700
Subject: [PATCH 02/53] Working on the solved property

---
 sudoku.py | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/sudoku.py b/sudoku.py
index 4354bf2..d07c787 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -15,6 +15,21 @@ class Sudoku:
         self.size = size
         self.board = bytearray(b'\x00' * (size * size))
 
+    @property
+    def solved(self):
+        def _check_group(group):
+            values = sorted([self.board[i] for i in group])
+            is_complete = values == list(range(1, self.size+1))
+            return is_complete
+        
+        sz = self.size
+        sz2 = sz ** 2
+        dim = int(math.sqrt(self.size))
+
+        rows = [range(i * sz, i * sz + sz) for i in range(sz)]
+        cols = [range(i, sz2, sz) for i in range(sz)]
+        # TODO: WIP
+
     def __str__(self):
         field_width = len(str(self.size))
         dim = int(math.sqrt(self.size))
@@ -33,5 +48,6 @@ class Sudoku:
             lines.append('|' + '|'.join(chunks) + '|')
         lines.append(spacer)
         fmt = '\n'.join(lines)
-        out = fmt.format(board=[str(n) if n != 0 else ' ' for n in self.board])
+        str_board = [str(n) if n != 0 else ' ' for n in self.board]
+        out = fmt.format(board=str_board)
         return out

From f98a0f4f75acba5fb05823efca5e253e55aa0838 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sat, 7 Oct 2017 12:24:41 -0700
Subject: [PATCH 03/53] Quick implement rows, columns, and square

---
 sudoku.py | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index d07c787..fc8411a 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -4,6 +4,7 @@
 A Sudoku puzzle solver.
 '''
 
+import itertools
 import math
 
 class Sudoku:
@@ -15,21 +16,41 @@ class Sudoku:
         self.size = size
         self.board = bytearray(b'\x00' * (size * size))
 
+    @property
+    def rows(self):
+        sz = self.size
+        return [range(i * sz, i * sz + sz) for i in range(sz)]
+
+    @property
+    def columns(self):
+        sz = self.size
+        sz2 = sz ** 2
+        return [range(i, sz2, sz) for i in range(sz)]
+
     @property
     def solved(self):
         def _check_group(group):
             values = sorted([self.board[i] for i in group])
             is_complete = values == list(range(1, self.size+1))
             return is_complete
-        
+
         sz = self.size
         sz2 = sz ** 2
         dim = int(math.sqrt(self.size))
-
-        rows = [range(i * sz, i * sz + sz) for i in range(sz)]
-        cols = [range(i, sz2, sz) for i in range(sz)]
         # TODO: WIP
 
+    def square(self, x, y):
+        dim = int(math.sqrt(self.size))
+        if (x < 0 or x >= dim) or (y < 0 or y >= dim):
+            raise IndexError('Invalid coordinates for square: ({}, {})'.format(x, y))
+        offset_x = x * dim
+        offset_y = y * dim
+        def _range(i):
+            start = offset_x + i * self.size
+            return range(start, start + dim)
+        ranges = itertools.chain(*[_range(i) for i in range(dim)])
+        return ranges
+
     def __str__(self):
         field_width = len(str(self.size))
         dim = int(math.sqrt(self.size))

From 01428e39728c65c3868c03a53daa82581bdd86b4 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 07:23:03 -0700
Subject: [PATCH 04/53] Fix squares; add dimension property; add some tests

---
 sudoku.py | 21 ++++++++++++++++-----
 test.py   | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 5 deletions(-)
 create mode 100644 test.py

diff --git a/sudoku.py b/sudoku.py
index fc8411a..8f05749 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -12,10 +12,14 @@ class Sudoku:
         dim = math.sqrt(size)
         if dim != int(dim):
             raise ValueError('Board size must have an integral square root.')
-        self.dimension = int(dim)
+        self._dimension = int(dim)
         self.size = size
         self.board = bytearray(b'\x00' * (size * size))
 
+    @property
+    def dimension(self):
+        return self._dimension
+
     @property
     def rows(self):
         sz = self.size
@@ -27,6 +31,11 @@ class Sudoku:
         sz2 = sz ** 2
         return [range(i, sz2, sz) for i in range(sz)]
 
+    @property
+    def squares(self):
+        dim = self.dimension
+        return [self.square(x, y) for y in range(dim) for x in range(dim)]
+
     @property
     def solved(self):
         def _check_group(group):
@@ -40,14 +49,16 @@ class Sudoku:
         # TODO: WIP
 
     def square(self, x, y):
-        dim = int(math.sqrt(self.size))
+        dim = self.dimension
         if (x < 0 or x >= dim) or (y < 0 or y >= dim):
             raise IndexError('Invalid coordinates for square: ({}, {})'.format(x, y))
-        offset_x = x * dim
-        offset_y = y * dim
+
+        offset = (x * dim, y * dim * self.size)
+
         def _range(i):
-            start = offset_x + i * self.size
+            start = (offset[1] + i * self.size) + offset[0]
             return range(start, start + dim)
+
         ranges = itertools.chain(*[_range(i) for i in range(dim)])
         return ranges
 
diff --git a/test.py b/test.py
new file mode 100644
index 0000000..38805d6
--- /dev/null
+++ b/test.py
@@ -0,0 +1,53 @@
+#!env python3
+# Eryn Wells <eryn@erynwells.me>
+'''
+Unit tests for the Sudoku module.
+'''
+
+import unittest
+import sudoku
+
+class Sudoku4Tests(unittest.TestCase):
+    def setUp(self):
+        self.board = sudoku.Sudoku(size=4)
+
+    def test_that_board_is_sane(self):
+        self.assertEqual(self.board.size, 4)
+        self.assertEqual(len(self.board.board), 4**2)
+        self.assertEqual(self.board.dimension, 2)
+
+    def test_rows(self):
+        expected_rows = [
+            [ 0,  1,  2,  3],
+            [ 4,  5,  6,  7],
+            [ 8,  9, 10, 11],
+            [12, 13, 14, 15]
+        ]
+        for (row, exrow) in zip(self.board.rows, expected_rows):
+            row_list = list(row)
+            with self.subTest(row=row_list, ex=exrow):
+                self.assertEqual(row_list, exrow)
+
+    def test_columns(self):
+        expected_columns = [
+            [0, 4,  8, 12],
+            [1, 5,  9, 13],
+            [2, 6, 10, 14],
+            [3, 7, 11, 15]
+        ]
+        for (col, excol) in zip(self.board.columns, expected_columns):
+            col_list = list(col)
+            with self.subTest(col=col_list, ex=excol):
+                self.assertEqual(col_list, excol)
+
+    def test_squares(self):
+        expected_squares = [
+            [ 0,  1,  4,  5],
+            [ 2,  3,  6,  7],
+            [ 8,  9, 12, 13],
+            [10, 11, 14, 15]
+        ]
+        for (sq, exsq) in zip(self.board.squares, expected_squares):
+            sq_list = list(sq)
+            with self.subTest(sq=sq_list, ex=exsq):
+                self.assertEqual(sq_list, exsq)

From 5ebe1f58ffbecf3f8fecdbf96c518c44c244cb26 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 07:56:23 -0700
Subject: [PATCH 05/53] Add index_* properties for returning ranges of indexes

---
 sudoku.py | 46 ++++++++++++++++++++++++++++++++--------------
 test.py   |  9 +++++----
 2 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 8f05749..f664846 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -22,31 +22,49 @@ class Sudoku:
 
     @property
     def rows(self):
-        sz = self.size
-        return [range(i * sz, i * sz + sz) for i in range(sz)]
+        return self._apply_index_range_list(self.index_rows)
 
     @property
     def columns(self):
-        sz = self.size
-        sz2 = sz ** 2
-        return [range(i, sz2, sz) for i in range(sz)]
+        return self._apply_index_range_list(self.index_columns)
 
     @property
     def squares(self):
-        dim = self.dimension
-        return [self.square(x, y) for y in range(dim) for x in range(dim)]
+        return self._apply_index_range_list(self.index_squares)
+
+    def _apply_index_range_list(self, ranges):
+        return (self._apply_index_range(r) for r in ranges)
+
+    def _apply_index_range(self, rng):
+        return (self.board[i] for i in rng)
 
     @property
-    def solved(self):
-        def _check_group(group):
-            values = sorted([self.board[i] for i in group])
-            is_complete = values == list(range(1, self.size+1))
-            return is_complete
+    def index_rows(self):
+        '''
+        Return a list of ranges of indexes into the board, each
+        defining a row.
+        '''
+        sz = self.size
+        return (range(i * sz, i * sz + sz) for i in range(sz))
 
+    @property
+    def index_columns(self):
+        '''
+        Return a list of ranges of indexes into the board, each
+        defining a column.
+        '''
         sz = self.size
         sz2 = sz ** 2
-        dim = int(math.sqrt(self.size))
-        # TODO: WIP
+        return (range(i, sz2, sz) for i in range(sz))
+
+    @property
+    def index_squares(self):
+        '''
+        Return a list of ranges of indexes into the board, each
+        defining a square.
+        '''
+        dim = self.dimension
+        return (self.square(x, y) for y in range(dim) for x in range(dim))
 
     def square(self, x, y):
         dim = self.dimension
diff --git a/test.py b/test.py
index 38805d6..ab827b4 100644
--- a/test.py
+++ b/test.py
@@ -7,10 +7,11 @@ Unit tests for the Sudoku module.
 import unittest
 import sudoku
 
-class Sudoku4Tests(unittest.TestCase):
+class Sudoku4TestCase(unittest.TestCase):
     def setUp(self):
         self.board = sudoku.Sudoku(size=4)
 
+class Sudoku4BasicTests(Sudoku4TestCase):
     def test_that_board_is_sane(self):
         self.assertEqual(self.board.size, 4)
         self.assertEqual(len(self.board.board), 4**2)
@@ -23,7 +24,7 @@ class Sudoku4Tests(unittest.TestCase):
             [ 8,  9, 10, 11],
             [12, 13, 14, 15]
         ]
-        for (row, exrow) in zip(self.board.rows, expected_rows):
+        for (row, exrow) in zip(self.board.index_rows, expected_rows):
             row_list = list(row)
             with self.subTest(row=row_list, ex=exrow):
                 self.assertEqual(row_list, exrow)
@@ -35,7 +36,7 @@ class Sudoku4Tests(unittest.TestCase):
             [2, 6, 10, 14],
             [3, 7, 11, 15]
         ]
-        for (col, excol) in zip(self.board.columns, expected_columns):
+        for (col, excol) in zip(self.board.index_columns, expected_columns):
             col_list = list(col)
             with self.subTest(col=col_list, ex=excol):
                 self.assertEqual(col_list, excol)
@@ -47,7 +48,7 @@ class Sudoku4Tests(unittest.TestCase):
             [ 8,  9, 12, 13],
             [10, 11, 14, 15]
         ]
-        for (sq, exsq) in zip(self.board.squares, expected_squares):
+        for (sq, exsq) in zip(self.board.index_squares, expected_squares):
             sq_list = list(sq)
             with self.subTest(sq=sq_list, ex=exsq):
                 self.assertEqual(sq_list, exsq)

From 3fabd4b42014c1cae66eced4b9534b084c08a098 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 08:00:45 -0700
Subject: [PATCH 06/53] Rough, probably incomplete solved property

---
 sudoku.py | 9 +++++++++
 test.py   | 4 ++++
 2 files changed, 13 insertions(+)

diff --git a/sudoku.py b/sudoku.py
index f664846..c97e071 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -66,6 +66,15 @@ class Sudoku:
         dim = self.dimension
         return (self.square(x, y) for y in range(dim) for x in range(dim))
 
+    @property
+    def solved(self):
+        expected = set(range(self.size))
+        return all([
+            all(expected == set(row) for row in self.rows),
+            all(expected == set(col) for col in self.columns),
+            all(expected == set(sqr) for sqr in self.squares)
+        ])
+
     def square(self, x, y):
         dim = self.dimension
         if (x < 0 or x >= dim) or (y < 0 or y >= dim):
diff --git a/test.py b/test.py
index ab827b4..cfe6354 100644
--- a/test.py
+++ b/test.py
@@ -52,3 +52,7 @@ class Sudoku4BasicTests(Sudoku4TestCase):
             sq_list = list(sq)
             with self.subTest(sq=sq_list, ex=exsq):
                 self.assertEqual(sq_list, exsq)
+
+class Sudoku4SolvedTests(Sudoku4TestCase):
+    def test_that_an_empty_board_is_not_solved(self):
+        self.assertFalse(self.board.solved)

From b5ac48bc1095bcc2066a12e45c567f1a1154afcc Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 08:04:29 -0700
Subject: [PATCH 07/53] Little bit o' cleanup

---
 sudoku.py | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index c97e071..f6239ab 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -22,27 +22,20 @@ class Sudoku:
 
     @property
     def rows(self):
-        return self._apply_index_range_list(self.index_rows)
+        return self._apply_index_ranges(self.index_rows)
 
     @property
     def columns(self):
-        return self._apply_index_range_list(self.index_columns)
+        return self._apply_index_ranges(self.index_columns)
 
     @property
     def squares(self):
-        return self._apply_index_range_list(self.index_squares)
-
-    def _apply_index_range_list(self, ranges):
-        return (self._apply_index_range(r) for r in ranges)
-
-    def _apply_index_range(self, rng):
-        return (self.board[i] for i in rng)
+        return self._apply_index_ranges(self.index_squares)
 
     @property
     def index_rows(self):
         '''
-        Return a list of ranges of indexes into the board, each
-        defining a row.
+        Return an iterable of ranges of indexes into the board, each defining a row.
         '''
         sz = self.size
         return (range(i * sz, i * sz + sz) for i in range(sz))
@@ -50,8 +43,7 @@ class Sudoku:
     @property
     def index_columns(self):
         '''
-        Return a list of ranges of indexes into the board, each
-        defining a column.
+        Return an iterable of ranges of indexes into the board, each defining a column.
         '''
         sz = self.size
         sz2 = sz ** 2
@@ -60,8 +52,7 @@ class Sudoku:
     @property
     def index_squares(self):
         '''
-        Return a list of ranges of indexes into the board, each
-        defining a square.
+        Return an iterable of ranges of indexes into the board, each defining a square.
         '''
         dim = self.dimension
         return (self.square(x, y) for y in range(dim) for x in range(dim))
@@ -89,6 +80,9 @@ class Sudoku:
         ranges = itertools.chain(*[_range(i) for i in range(dim)])
         return ranges
 
+    def _apply_index_ranges(self, ranges):
+        return ((self.board[i] for i in rng) for r in ranges)
+
     def __str__(self):
         field_width = len(str(self.size))
         dim = int(math.sqrt(self.size))

From 5696c087d8ec2ac543be64124679ce3d19dda05f Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 08:06:34 -0700
Subject: [PATCH 08/53] Add a TODO

---
 sudoku.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sudoku.py b/sudoku.py
index f6239ab..985b295 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -57,6 +57,8 @@ class Sudoku:
         dim = self.dimension
         return (self.square(x, y) for y in range(dim) for x in range(dim))
 
+    # TODO: Break the above into helper methods that produce a single thing given an index.
+
     @property
     def solved(self):
         expected = set(range(self.size))

From eae05487b9fbd9ac39f164e3b2c5e7613261a481 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 08:26:18 -0700
Subject: [PATCH 09/53] Add puzzles and puzzles.py from the old branch

---
 puzzles.py         | 34 +++++++++++++++++
 puzzles/euler.txt  | 50 ++++++++++++++++++++++++
 puzzles/norvig.txt | 95 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 179 insertions(+)
 create mode 100644 puzzles.py
 create mode 100644 puzzles/euler.txt
 create mode 100644 puzzles/norvig.txt

diff --git a/puzzles.py b/puzzles.py
new file mode 100644
index 0000000..4a9b788
--- /dev/null
+++ b/puzzles.py
@@ -0,0 +1,34 @@
+#!env python3
+# Eryn Wells <eryn@erynwells.me>
+'''
+Parser for puzzles in the ./puzzles directory.
+'''
+
+import sudoku
+
+euler = []
+norvig = []
+
+def parse_puzzle_files():
+    global euler, norvig
+
+    print('Parsing Euler puzzles')
+    euler = list(_get_puzzles('puzzles/euler.txt'))
+
+    print('Parsing Norvig puzzles')
+    norvig = list(_get_puzzles('puzzles/norvig.txt'))
+
+def _get_puzzles(filename):
+    with open(filename, 'r') as f:
+        puzzles = f.readlines()
+    return (_parse_puzzle(p) for p in puzzles if p)
+
+def _parse_puzzle(puzzle):
+    puzzle = puzzle.strip()
+    if len(puzzle) == 81:
+        print("Parsing  '{}'".format(puzzle))
+        board = (int('0' if x == '.' else x) for x in puzzle)
+        return sudoku.Sudoku(initial=board)
+    else:
+        print("Skipping '{}'".format(puzzle))
+        return None
diff --git a/puzzles/euler.txt b/puzzles/euler.txt
new file mode 100644
index 0000000..b0bb576
--- /dev/null
+++ b/puzzles/euler.txt
@@ -0,0 +1,50 @@
+003020600900305001001806400008102900700000008006708200002609500800203009005010300
+200080300060070084030500209000105408000000000402706000301007040720040060004010003
+000000907000420180000705026100904000050000040000507009920108000034059000507000000
+030050040008010500460000012070502080000603000040109030250000098001020600080060020
+020810740700003100090002805009040087400208003160030200302700060005600008076051090
+100920000524010000000000070050008102000000000402700090060000000000030945000071006
+043080250600000000000001094900004070000608000010200003820500000000000005034090710
+480006902002008001900370060840010200003704100001060049020085007700900600609200018
+000900002050123400030000160908000000070000090000000205091000050007439020400007000
+001900003900700160030005007050000009004302600200000070600100030042007006500006800
+000125400008400000420800000030000095060902010510000060000003049000007200001298000
+062340750100005600570000040000094800400000006005830000030000091006400007059083260
+300000000005009000200504000020000700160000058704310600000890100000067080000005437
+630000000000500008005674000000020000003401020000000345000007004080300902947100080
+000020040008035000000070602031046970200000000000501203049000730000000010800004000
+361025900080960010400000057008000471000603000259000800740000005020018060005470329
+050807020600010090702540006070020301504000908103080070900076205060090003080103040
+080005000000003457000070809060400903007010500408007020901020000842300000000100080
+003502900000040000106000305900251008070408030800763001308000104000020000005104800
+000000000009805100051907420290401065000000000140508093026709580005103600000000000
+020030090000907000900208005004806500607000208003102900800605007000309000030020050
+005000006070009020000500107804150000000803000000092805907006000030400010200000600
+040000050001943600009000300600050002103000506800020007005000200002436700030000040
+004000000000030002390700080400009001209801307600200008010008053900040000000000800
+360020089000361000000000000803000602400603007607000108000000000000418000970030014
+500400060009000800640020000000001008208000501700500000000090084003000600060003002
+007256400400000005010030060000508000008060200000107000030070090200000004006312700
+000000000079050180800000007007306800450708096003502700700000005016030420000000000
+030000080009000500007509200700105008020090030900402001004207100002000800070000090
+200170603050000100000006079000040700000801000009050000310400000005000060906037002
+000000080800701040040020030374000900000030000005000321010060050050802006080000000
+000000085000210009960080100500800016000000000890006007009070052300054000480000000
+608070502050608070002000300500090006040302050800050003005000200010704090409060701
+050010040107000602000905000208030501040070020901080406000401000304000709020060010
+053000790009753400100000002090080010000907000080030070500000003007641200061000940
+006080300049070250000405000600317004007000800100826009000702000075040190003090600
+005080700700204005320000084060105040008000500070803010450000091600508007003010600
+000900800128006400070800060800430007500000009600079008090004010003600284001007000
+000080000270000054095000810009806400020403060006905100017000620460000038000090000
+000602000400050001085010620038206710000000000019407350026040530900020007000809000
+000900002050123400030000160908000000070000090000000205091000050007439020400007000
+380000000000400785009020300060090000800302009000040070001070500495006000000000092
+000158000002060800030000040027030510000000000046080790050000080004070100000325000
+010500200900001000002008030500030007008000500600080004040100700000700006003004050
+080000040000469000400000007005904600070608030008502100900000005000781000060000010
+904200007010000000000706500000800090020904060040002000001607000000000030300005702
+000700800006000031040002000024070000010030080000060290000800070860000500002006000
+001007090590080001030000080000005800050060020004100000080000030100020079020700400
+000003017015009008060000000100007000009000200000500004000000020500600340340200000
+300200000000107000706030500070009080900020004010800050009040301000702000000008006
diff --git a/puzzles/norvig.txt b/puzzles/norvig.txt
new file mode 100644
index 0000000..a68d542
--- /dev/null
+++ b/puzzles/norvig.txt
@@ -0,0 +1,95 @@
+4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......
+52...6.........7.13...........4..8..6......5...........418.........3..2...87.....
+6.....8.3.4.7.................5.4.7.3..2.....1.6.......2.....5.....8.6......1....
+48.3............71.2.......7.5....6....2..8.............1.76...3.....4......5....
+....14....3....2...7..........9...3.6.1.............8.2.....1.4....5.6.....7.8...
+......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
+6.2.5.........3.4..........43...8....1....2........7..5..27...........81...6.....
+.524.........7.1..............8.2...3.....6...9.5.....1.6.3...........897........
+6.2.5.........4.3..........43...8....1....2........7..5..27...........81...6.....
+.923.........8.1...........1.7.4...........658.........6.5.2...4.....7.....9.....
+6..3.2....5.....1..........7.26............543.........8.15........4.2........7..
+.6.5.1.9.1...9..539....7....4.8...7.......5.8.817.5.3.....5.2............76..8...
+..5...987.4..5...1..7......2...48....9.1.....6..2.....3..6..2.......9.7.......5..
+3.6.7...........518.........1.4.5...7.....6.....2......2.....4.....8.3.....5.....
+1.....3.8.7.4..............2.3.1...........958.........5.6...7.....8.2...4.......
+6..3.2....4.....1..........7.26............543.........8.15........4.2........7..
+....3..9....2....1.5.9..............1.2.8.4.6.8.5...2..75......4.1..6..3.....4.6.
+45.....3....8.1....9...........5..9.2..7.....8.........1..4..........7.2...6..8..
+.237....68...6.59.9.....7......4.97.3.7.96..2.........5..47.........2....8.......
+..84...3....3.....9....157479...8........7..514.....2...9.6...2.5....4......9..56
+.98.1....2......6.............3.2.5..84.........6.........4.8.93..5...........1..
+..247..58..............1.4.....2...9528.9.4....9...1.........3.3....75..685..2...
+4.....8.5.3..........7......2.....6.....5.4......1.......6.3.7.5..2.....1.9......
+.2.3......63.....58.......15....9.3....7........1....8.879..26......6.7...6..7..4
+1.....7.9.4...72..8.........7..1..6.3.......5.6..4..2.........8..53...7.7.2....46
+4.....3.....8.2......7........1...8734.......6........5...6........1.4...82......
+.......71.2.8........4.3...7...6..5....2..3..9........6...7.....8....4......5....
+6..3.2....4.....8..........7.26............543.........8.15........8.2........7..
+.47.8...1............6..7..6....357......5....1..6....28..4.....9.1...4.....2.69.
+......8.17..2........5.6......7...5..1....3...8.......5......2..4..8....6...3....
+38.6.......9.......2..3.51......5....3..1..6....4......17.5..8.......9.......7.32
+...5...........5.697.....2...48.2...25.1...3..8..3.........4.7..13.5..9..2...31..
+.2.......3.5.62..9.68...3...5..........64.8.2..47..9....3.....1.....6...17.43....
+.8..4....3......1........2...5...4.69..1..8..2...........3.9....6....5.....2.....
+..8.9.1...6.5...2......6....3.1.7.5.........9..4...3...5....2...7...3.8.2..7....4
+4.....5.8.3..........7......2.....6.....5.8......1.......6.3.7.5..2.....1.8......
+1.....3.8.6.4..............2.3.1...........958.........5.6...7.....8.2...4.......
+1....6.8..64..........4...7....9.6...7.4..5..5...7.1...5....32.3....8...4........
+249.6...3.3....2..8.......5.....6......2......1..4.82..9.5..7....4.....1.7...3...
+...8....9.873...4.6..7.......85..97...........43..75.......3....3...145.4....2..1
+...5.1....9....8...6.......4.1..........7..9........3.8.....1.5...2..4.....36....
+......8.16..2........7.5......6...2..1....3...8.......2......7..3..8....5...4....
+.476...5.8.3.....2.....9......8.5..6...1.....6.24......78...51...6....4..9...4..7
+.....7.95.....1...86..2.....2..73..85......6...3..49..3.5...41724................
+.4.5.....8...9..3..76.2.....146..........9..7.....36....1..4.5..6......3..71..2..
+.834.........7..5...........4.1.8..........27...3.....2.6.5....5.....8........1..
+..9.....3.....9...7.....5.6..65..4.....3......28......3..75.6..6...........12.3.8
+.26.39......6....19.....7.......4..9.5....2....85.....3..2..9..4....762.........4
+2.3.8....8..7...........1...6.5.7...4......3....1............82.5....6...1.......
+6..3.2....1.....5..........7.26............843.........8.15........8.2........7..
+1.....9...64..1.7..7..4.......3.....3.89..5....7....2.....6.7.9.....4.1....129.3.
+.........9......84.623...5....6...453...1...6...9...7....1.....4.5..2....3.8....9
+.2....5938..5..46.94..6...8..2.3.....6..8.73.7..2.........4.38..7....6..........5
+9.4..5...25.6..1..31......8.7...9...4..26......147....7.......2...3..8.6.4.....9.
+...52.....9...3..4......7...1.....4..8..453..6...1...87.2........8....32.4..8..1.
+53..2.9...24.3..5...9..........1.827...7.........981.............64....91.2.5.43.
+1....786...7..8.1.8..2....9........24...1......9..5...6.8..........5.9.......93.4
+....5...11......7..6.....8......4.....9.1.3.....596.2..8..62..7..7......3.5.7.2..
+.47.2....8....1....3....9.2.....5...6..81..5.....4.....7....3.4...9...1.4..27.8..
+......94.....9...53....5.7..8.4..1..463...........7.8.8..7.....7......28.5.26....
+.2......6....41.....78....1......7....37.....6..412....1..74..5..8.5..7......39..
+1.....3.8.6.4..............2.3.1...........758.........7.5...6.....8.2...4.......
+2....1.9..1..3.7..9..8...2.......85..6.4.........7...3.2.3...6....5.....1.9...2.5
+..7..8.....6.2.3...3......9.1..5..6.....1.....7.9....2........4.83..4...26....51.
+...36....85.......9.4..8........68.........17..9..45...1.5...6.4....9..2.....3...
+34.6.......7.......2..8.57......5....7..1..2....4......36.2..1.......9.......7.82
+......4.18..2........6.7......8...6..4....3...1.......6......2..5..1....7...3....
+.4..5..67...1...4....2.....1..8..3........2...6...........4..5.3.....8..2........
+.......4...2..4..1.7..5..9...3..7....4..6....6..1..8...2....1..85.9...6.....8...3
+8..7....4.5....6............3.97...8....43..5....2.9....6......2...6...7.71..83.2
+.8...4.5....7..3............1..85...6.....2......4....3.26............417........
+....7..8...6...5...2...3.61.1...7..2..8..534.2..9.......2......58...6.3.4...1....
+......8.16..2........7.5......6...2..1....3...8.......2......7..4..8....5...3....
+.2..........6....3.74.8.........3..2.8..4..1.6..5.........1.78.5....9..........4.
+.52..68.......7.2.......6....48..9..2..41......1.....8..61..38.....9...63..6..1.9
+....1.78.5....9..........4..2..........6....3.74.8.........3..2.8..4..1.6..5.....
+1.......3.6.3..7...7...5..121.7...9...7........8.1..2....8.64....9.2..6....4.....
+4...7.1....19.46.5.....1......7....2..2.3....847..6....14...8.6.2....3..6...9....
+......8.17..2........5.6......7...5..1....3...8.......5......2..3..8....6...4....
+963......1....8......2.5....4.8......1....7......3..257......3...9.2.4.7......9..
+15.3......7..4.2....4.72.....8.........9..1.8.1..8.79......38...........6....7423
+..........5724...98....947...9..3...5..9..12...3.1.9...6....25....56.....7......6
+....75....1..2.....4...3...5.....3.2...8...1.......6.....1..48.2........7........
+6.....7.3.4.8.................5.4.8.7..2.....1.3.......2.....5.....7.9......1....
+....6...4..6.3....1..4..5.77.....8.5...8.....6.8....9...2.9....4....32....97..1..
+.32.....58..3.....9.428...1...4...39...6...5.....1.....2...67.8.....4....95....6.
+...5.3.......6.7..5.8....1636..2.......4.1.......3...567....2.8..4.7.......2..5..
+.5.3.7.4.1.........3.......5.8.3.61....8..5.9.6..1........4...6...6927....2...9..
+..5..8..18......9.......78....4.....64....9......53..2.6.........138..5....9.714.
+..........72.6.1....51...82.8...13..4.........37.9..1.....238..5.4..9.........79.
+...658.....4......12............96.7...3..5....2.8...3..19..8..3.6.....4....473..
+.2.3.......6..8.9.83.5........2...8.7.9..5........6..4.......1...1...4.22..7..8.9
+.5..9....1.....6.....3.8.....8.4...9514.......3....2..........4.8...6..77..15..6.
+.....2.......7...17..3...9.8..7......2.89.6...13..6....9..5.824.....891..........
+3...8.......7....51..............36...2..4....7...........6.13..452...........8..

From 5a32743d7bc7a3526119a506fe4994328b7dc344 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Sun, 8 Oct 2017 08:26:34 -0700
Subject: [PATCH 10/53] Add initial arg to Sudoku.__init__()

---
 sudoku.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 985b295..a10cfd2 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -8,13 +8,16 @@ import itertools
 import math
 
 class Sudoku:
-    def __init__(self, size=9):
+    def __init__(self, size=9, initial=None):
         dim = math.sqrt(size)
         if dim != int(dim):
             raise ValueError('Board size must have an integral square root.')
         self._dimension = int(dim)
         self.size = size
-        self.board = bytearray(b'\x00' * (size * size))
+        if initial:
+            self.board = bytearray(initial)[:9**2]
+        else:
+            self.board = bytearray(b'\x00' * (size * size))
 
     @property
     def dimension(self):

From 88f0e07c06a16f87a52fd2608688722b87984499 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 9 Oct 2017 15:03:33 -0700
Subject: [PATCH 11/53] Copy pasta error

---
 sudoku.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sudoku.py b/sudoku.py
index a10cfd2..84c967f 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -86,7 +86,7 @@ class Sudoku:
         return ranges
 
     def _apply_index_ranges(self, ranges):
-        return ((self.board[i] for i in rng) for r in ranges)
+        return ((self.board[i] for i in r) for r in ranges)
 
     def __str__(self):
         field_width = len(str(self.size))

From 3017b1e92386ccf370335c0fabbe76308025d28b Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 09:53:55 -0700
Subject: [PATCH 12/53] Rename initial init attribute to board; make self.board
 -> _board

---
 puzzles.py |  2 +-
 sudoku.py  | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/puzzles.py b/puzzles.py
index 4a9b788..a2e1fb3 100644
--- a/puzzles.py
+++ b/puzzles.py
@@ -28,7 +28,7 @@ def _parse_puzzle(puzzle):
     if len(puzzle) == 81:
         print("Parsing  '{}'".format(puzzle))
         board = (int('0' if x == '.' else x) for x in puzzle)
-        return sudoku.Sudoku(initial=board)
+        return sudoku.Sudoku(board=board)
     else:
         print("Skipping '{}'".format(puzzle))
         return None
diff --git a/sudoku.py b/sudoku.py
index 84c967f..aa25fb6 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -8,16 +8,16 @@ import itertools
 import math
 
 class Sudoku:
-    def __init__(self, size=9, initial=None):
+    def __init__(self, size=9, board=None):
         dim = math.sqrt(size)
         if dim != int(dim):
             raise ValueError('Board size must have an integral square root.')
         self._dimension = int(dim)
         self.size = size
-        if initial:
-            self.board = bytearray(initial)[:9**2]
+        if board:
+            self._board = bytearray(board)[:size**2]
         else:
-            self.board = bytearray(b'\x00' * (size * size))
+            self._board = bytearray(b'\x00' * (size * size))
 
     @property
     def dimension(self):
@@ -86,7 +86,7 @@ class Sudoku:
         return ranges
 
     def _apply_index_ranges(self, ranges):
-        return ((self.board[i] for i in r) for r in ranges)
+        return ((self._board[i] for i in r) for r in ranges)
 
     def __str__(self):
         field_width = len(str(self.size))
@@ -106,6 +106,6 @@ class Sudoku:
             lines.append('|' + '|'.join(chunks) + '|')
         lines.append(spacer)
         fmt = '\n'.join(lines)
-        str_board = [str(n) if n != 0 else ' ' for n in self.board]
+        str_board = [str(n) if n != 0 else ' ' for n in self._board]
         out = fmt.format(board=str_board)
         return out

From 93a4fecb2667983d9f437c09119f63c8583f03fc Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 09:55:09 -0700
Subject: [PATCH 13/53] Add helpers to get rows, cols, and squares for
 particular coordinates

---
 sudoku.py | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index aa25fb6..7115db5 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -41,7 +41,7 @@ class Sudoku:
         Return an iterable of ranges of indexes into the board, each defining a row.
         '''
         sz = self.size
-        return (range(i * sz, i * sz + sz) for i in range(sz))
+        return (self._row(i, size) for i in range(sz))
 
     @property
     def index_columns(self):
@@ -50,7 +50,7 @@ class Sudoku:
         '''
         sz = self.size
         sz2 = sz ** 2
-        return (range(i, sz2, sz) for i in range(sz))
+        return (self._column(c, sz, sz2) for i in range(sz))
 
     @property
     def index_squares(self):
@@ -58,21 +58,16 @@ class Sudoku:
         Return an iterable of ranges of indexes into the board, each defining a square.
         '''
         dim = self.dimension
-        return (self.square(x, y) for y in range(dim) for x in range(dim))
+        return (self._square(x, y, dim) for y in range(dim) for x in range(dim))
 
     # TODO: Break the above into helper methods that produce a single thing given an index.
+    def _row(self, r, size):
+        return range(r * size, r * size + size)
 
-    @property
-    def solved(self):
-        expected = set(range(self.size))
-        return all([
-            all(expected == set(row) for row in self.rows),
-            all(expected == set(col) for col in self.columns),
-            all(expected == set(sqr) for sqr in self.squares)
-        ])
+    def _column(self, c, size, size2):
+        return range(c, size2, size)
 
-    def square(self, x, y):
-        dim = self.dimension
+    def _square(self, x, y, dim):
         if (x < 0 or x >= dim) or (y < 0 or y >= dim):
             raise IndexError('Invalid coordinates for square: ({}, {})'.format(x, y))
 
@@ -85,6 +80,15 @@ class Sudoku:
         ranges = itertools.chain(*[_range(i) for i in range(dim)])
         return ranges
 
+    @property
+    def solved(self):
+        expected = set(range(self.size))
+        return all([
+            all(expected == set(row) for row in self.rows),
+            all(expected == set(col) for col in self.columns),
+            all(expected == set(sqr) for sqr in self.squares)
+        ])
+
     def _apply_index_ranges(self, ranges):
         return ((self._board[i] for i in r) for r in ranges)
 

From 19a9bc9d3720d5f2936de0eb2112bb588fdaf8cc Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 09:55:34 -0700
Subject: [PATCH 14/53] Tweak the str printing a bit

---
 sudoku.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 7115db5..0888b56 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -94,9 +94,9 @@ class Sudoku:
 
     def __str__(self):
         field_width = len(str(self.size))
-        dim = int(math.sqrt(self.size))
+        dim = self.dimension
         lines = []
-        spacer = '+' + '+'.join(['-' * (field_width * dim) for _ in range(dim)]) + '+'
+        spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * dim) for _ in range(dim)]))
         for line in range(self.size):
             chunks = []
             for i in range(dim):
@@ -107,7 +107,7 @@ class Sudoku:
                 chunks.append(''.join(fields))
             if (line % dim) == 0:
                 lines.append(spacer)
-            lines.append('|' + '|'.join(chunks) + '|')
+            lines.append('{0}{1}{0}'.format('|', '|'.join(chunks)))
         lines.append(spacer)
         fmt = '\n'.join(lines)
         str_board = [str(n) if n != 0 else ' ' for n in self._board]

From 00225aca444cd86f4a5a4589418ce6295af776ea Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 09:55:51 -0700
Subject: [PATCH 15/53] Add peers and index_peers for a given (x,y)

---
 sudoku.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/sudoku.py b/sudoku.py
index 0888b56..2d3904c 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -60,6 +60,16 @@ class Sudoku:
         dim = self.dimension
         return (self._square(x, y, dim) for y in range(dim) for x in range(dim))
 
+    def peers(self, x, y):
+        return {self._board[i] for i in self.index_peers(x, y) if self._board[i] != 0}
+
+    def index_peers(self, x, y):
+        dim = self.dimension
+        sz = self.size
+        sz2 = sz ** 2
+        sq_x, sq_y = int(x / dim), int(y / dim)
+        return set(self._row(y, sz)) | set(self._column(x, sz, sz2)) | set(self._square(sq_x, sq_y, dim))
+
     # TODO: Break the above into helper methods that produce a single thing given an index.
     def _row(self, r, size):
         return range(r * size, r * size + size)

From cf43b02aa933455b94f6b98e59085c3c816cc919 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 11:43:02 -0700
Subject: [PATCH 16/53] Add test_peers(); fix up some errors found

---
 sudoku.py |  5 ++---
 test.py   | 29 ++++++++++++++++++++++++++++-
 2 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 2d3904c..da25383 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -40,8 +40,7 @@ class Sudoku:
         '''
         Return an iterable of ranges of indexes into the board, each defining a row.
         '''
-        sz = self.size
-        return (self._row(i, size) for i in range(sz))
+        return (self._row(i, self.size) for i in range(self.size))
 
     @property
     def index_columns(self):
@@ -50,7 +49,7 @@ class Sudoku:
         '''
         sz = self.size
         sz2 = sz ** 2
-        return (self._column(c, sz, sz2) for i in range(sz))
+        return (self._column(i, sz, sz2) for i in range(sz))
 
     @property
     def index_squares(self):
diff --git a/test.py b/test.py
index cfe6354..0ee539b 100644
--- a/test.py
+++ b/test.py
@@ -14,7 +14,7 @@ class Sudoku4TestCase(unittest.TestCase):
 class Sudoku4BasicTests(Sudoku4TestCase):
     def test_that_board_is_sane(self):
         self.assertEqual(self.board.size, 4)
-        self.assertEqual(len(self.board.board), 4**2)
+        self.assertEqual(len(self.board._board), 4**2)
         self.assertEqual(self.board.dimension, 2)
 
     def test_rows(self):
@@ -53,6 +53,33 @@ class Sudoku4BasicTests(Sudoku4TestCase):
             with self.subTest(sq=sq_list, ex=exsq):
                 self.assertEqual(sq_list, exsq)
 
+    def test_peers(self):
+        expected_peers = {
+            (0,0): set([0, 1, 2, 3, 4, 8, 12, 5]),
+            (1,0): set([0, 1, 2, 3, 5, 9, 13, 4]),
+            (2,0): set([0, 1, 2, 3, 6, 10, 14, 7]),
+            (3,0): set([0, 1, 2, 3, 7, 11, 15, 6]),
+
+            (0,1): set([4, 5, 6, 7, 0, 8, 12, 1]),
+            (1,1): set([4, 5, 6, 7, 1, 9, 13, 0]),
+            (2,1): set([4, 5, 6, 7, 2, 10, 14, 3]),
+            (3,1): set([4, 5, 6, 7, 3, 11, 15, 2]),
+
+            (0,2): set([8, 9, 10, 11, 0, 4, 12, 13]),
+            (1,2): set([8, 9, 10, 11, 1, 5, 13, 12]),
+            (2,2): set([8, 9, 10, 11, 2, 6, 14, 15]),
+            (3,2): set([8, 9, 10, 11, 3, 7, 15, 14]),
+
+            (0,3): set([12, 13, 14, 15, 0, 4, 8, 9]),
+            (1,3): set([12, 13, 14, 15, 1, 5, 9, 8]),
+            (2,3): set([12, 13, 14, 15, 2, 6, 10, 11]),
+            (3,3): set([12, 13, 14, 15, 3, 7, 11, 10]),
+        }
+        for (coords, expeers) in expected_peers.items():
+            with self.subTest(coord=coords, ex=expeers):
+                peers = self.board.index_peers(*coords)
+                self.assertEqual(peers, expeers)
+
 class Sudoku4SolvedTests(Sudoku4TestCase):
     def test_that_an_empty_board_is_not_solved(self):
         self.assertFalse(self.board.solved)

From a9a01d3fd4fa544ce87ef9e12f7e546afc349888 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 11:59:29 -0700
Subject: [PATCH 17/53] Fix solved property

---
 sudoku.py | 9 +++------
 test.py   | 5 +++++
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index da25383..8fa2937 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -91,12 +91,9 @@ class Sudoku:
 
     @property
     def solved(self):
-        expected = set(range(self.size))
-        return all([
-            all(expected == set(row) for row in self.rows),
-            all(expected == set(col) for col in self.columns),
-            all(expected == set(sqr) for sqr in self.squares)
-        ])
+        expected = set(range(1, self.size + 1))
+        all_groups = itertools.chain(self.rows, self.columns, self.squares)
+        return all(expected == set(g) for g in all_groups)
 
     def _apply_index_ranges(self, ranges):
         return ((self._board[i] for i in r) for r in ranges)
diff --git a/test.py b/test.py
index 0ee539b..a9695dc 100644
--- a/test.py
+++ b/test.py
@@ -83,3 +83,8 @@ class Sudoku4BasicTests(Sudoku4TestCase):
 class Sudoku4SolvedTests(Sudoku4TestCase):
     def test_that_an_empty_board_is_not_solved(self):
         self.assertFalse(self.board.solved)
+
+    def test_simple_solution_is_solved(self):
+        board = (int(i) for i in '1234341221434321')
+        self.board = sudoku.Sudoku(4, board)
+        self.assertTrue(self.board.solved)

From 35647fc8c92ad1dedbc54b755f7fc18a7469f51c Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 12:43:18 -0700
Subject: [PATCH 18/53] Change the meaning of size

- size is the size of one side of a square
- row_size is the length of the grid on one side
- grid_size is the area of the grid
---
 sudoku.py | 93 +++++++++++++++++++++++++++++++------------------------
 test.py   | 27 ++++++++--------
 2 files changed, 65 insertions(+), 55 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 8fa2937..225f60b 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -8,20 +8,37 @@ import itertools
 import math
 
 class Sudoku:
-    def __init__(self, size=9, board=None):
-        dim = math.sqrt(size)
-        if dim != int(dim):
-            raise ValueError('Board size must have an integral square root.')
-        self._dimension = int(dim)
-        self.size = size
+    def __init__(self, size=3, board=None):
+        self._size = size
+        sz4 = size ** 4
         if board:
-            self._board = bytearray(board)[:size**2]
+            self._board = bytes(board)[:sz4]
         else:
-            self._board = bytearray(b'\x00' * (size * size))
+            self._board = bytes(sz4)
 
     @property
-    def dimension(self):
-        return self._dimension
+    def size(self):
+        return self._size
+
+    @property
+    def row_size(self):
+        return self.size ** 2
+
+    @property
+    def grid_size(self):
+        return self.size ** 4
+
+    @property
+    def all_squares(self):
+        return itertools.product(range(self.size), repeat=2)
+
+    @property
+    def possible_values(self):
+        '''
+        The set of valid values for any grid square, not accounting for values made invalid by already being
+        present in a peer of that square.
+        '''
+        return set(range(1, self.row_size + 1))
 
     @property
     def rows(self):
@@ -40,58 +57,52 @@ class Sudoku:
         '''
         Return an iterable of ranges of indexes into the board, each defining a row.
         '''
-        return (self._row(i, self.size) for i in range(self.size))
+        return (self._row(i) for i in range(self.row_size))
 
     @property
     def index_columns(self):
         '''
         Return an iterable of ranges of indexes into the board, each defining a column.
         '''
-        sz = self.size
-        sz2 = sz ** 2
-        return (self._column(i, sz, sz2) for i in range(sz))
+        return (self._column(i) for i in range(self.row_size))
 
     @property
     def index_squares(self):
         '''
         Return an iterable of ranges of indexes into the board, each defining a square.
         '''
-        dim = self.dimension
-        return (self._square(x, y, dim) for y in range(dim) for x in range(dim))
+        return (self._square(x, y) for (x,y) in self.all_squares)
 
     def peers(self, x, y):
         return {self._board[i] for i in self.index_peers(x, y) if self._board[i] != 0}
 
     def index_peers(self, x, y):
-        dim = self.dimension
         sz = self.size
-        sz2 = sz ** 2
-        sq_x, sq_y = int(x / dim), int(y / dim)
-        return set(self._row(y, sz)) | set(self._column(x, sz, sz2)) | set(self._square(sq_x, sq_y, dim))
+        sqx, sqy = int(x / sz), int(y / sz)
+        return set(self._row(y)) | set(self._column(x)) | set(self._square(sqx, sqy))
 
-    # TODO: Break the above into helper methods that produce a single thing given an index.
-    def _row(self, r, size):
-        return range(r * size, r * size + size)
+    def _row(self, r):
+        row_size = self.row_size
+        return range(r * row_size, r * row_size + row_size)
 
-    def _column(self, c, size, size2):
-        return range(c, size2, size)
+    def _column(self, c):
+        return range(c, self.grid_size, self.row_size)
 
-    def _square(self, x, y, dim):
-        if (x < 0 or x >= dim) or (y < 0 or y >= dim):
-            raise IndexError('Invalid coordinates for square: ({}, {})'.format(x, y))
-
-        offset = (x * dim, y * dim * self.size)
+    def _square(self, x, y):
+        size = self.size
+        row_size = self.row_size
+        offx, offy = (x * size, y * size * row_size)
 
         def _range(i):
-            start = (offset[1] + i * self.size) + offset[0]
-            return range(start, start + dim)
+            start = (offy + i * row_size) + offx
+            return range(start, start + size)
 
-        ranges = itertools.chain(*[_range(i) for i in range(dim)])
+        ranges = itertools.chain(*[_range(i) for i in range(size)])
         return ranges
 
     @property
     def solved(self):
-        expected = set(range(1, self.size + 1))
+        expected = self.possible_values
         all_groups = itertools.chain(self.rows, self.columns, self.squares)
         return all(expected == set(g) for g in all_groups)
 
@@ -99,19 +110,19 @@ class Sudoku:
         return ((self._board[i] for i in r) for r in ranges)
 
     def __str__(self):
-        field_width = len(str(self.size))
-        dim = self.dimension
+        field_width = len(str(max(self.possible_values)))
+        sz = self.size
         lines = []
-        spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * dim) for _ in range(dim)]))
+        spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * sz) for _ in range(sz)]))
         for line in range(self.size):
             chunks = []
-            for i in range(dim):
+            for i in range(sz):
                 fields = []
-                for j in range(dim):
-                    idx = line * self.size + i * dim + j
+                for j in range(sz):
+                    idx = line * self.size + i * sz + j
                     fields.append('{{board[{i}]:^{width}}}'.format(i=idx, width=field_width))
                 chunks.append(''.join(fields))
-            if (line % dim) == 0:
+            if (line % sz) == 0:
                 lines.append(spacer)
             lines.append('{0}{1}{0}'.format('|', '|'.join(chunks)))
         lines.append(spacer)
diff --git a/test.py b/test.py
index a9695dc..559998f 100644
--- a/test.py
+++ b/test.py
@@ -9,13 +9,12 @@ import sudoku
 
 class Sudoku4TestCase(unittest.TestCase):
     def setUp(self):
-        self.board = sudoku.Sudoku(size=4)
+        self.board = sudoku.Sudoku(size=2)
 
 class Sudoku4BasicTests(Sudoku4TestCase):
     def test_that_board_is_sane(self):
-        self.assertEqual(self.board.size, 4)
-        self.assertEqual(len(self.board._board), 4**2)
-        self.assertEqual(self.board.dimension, 2)
+        self.assertEqual(self.board.size, 2)
+        self.assertEqual(len(self.board._board), 2**4)
 
     def test_rows(self):
         expected_rows = [
@@ -42,16 +41,16 @@ class Sudoku4BasicTests(Sudoku4TestCase):
                 self.assertEqual(col_list, excol)
 
     def test_squares(self):
-        expected_squares = [
-            [ 0,  1,  4,  5],
-            [ 2,  3,  6,  7],
-            [ 8,  9, 12, 13],
-            [10, 11, 14, 15]
-        ]
-        for (sq, exsq) in zip(self.board.index_squares, expected_squares):
-            sq_list = list(sq)
-            with self.subTest(sq=sq_list, ex=exsq):
-                self.assertEqual(sq_list, exsq)
+        expected_squares = {
+            (0,0): set([ 0,  1,  4,  5]),
+            (1,0): set([ 2,  3,  6,  7]),
+            (0,1): set([ 8,  9, 12, 13]),
+            (1,1): set([10, 11, 14, 15]),
+        }
+        for (coord, exsq) in expected_squares.items():
+            with self.subTest(sq=coord, ex=exsq):
+                sq = set(self.board._square(*coord))
+                self.assertEqual(sq, exsq)
 
     def test_peers(self):
         expected_peers = {

From e5d00debc711bc020bc9d372ce0693a09d314fe0 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 12:51:11 -0700
Subject: [PATCH 19/53] Rename square -> box

---
 sudoku.py | 23 +++++++++++++----------
 test.py   | 12 ++++++------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 225f60b..a394b25 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -29,7 +29,10 @@ class Sudoku:
         return self.size ** 4
 
     @property
-    def all_squares(self):
+    def all_boxes(self):
+        '''
+        Iterator of xy-coordinates for every box in the grid.
+        '''
         return itertools.product(range(self.size), repeat=2)
 
     @property
@@ -49,8 +52,8 @@ class Sudoku:
         return self._apply_index_ranges(self.index_columns)
 
     @property
-    def squares(self):
-        return self._apply_index_ranges(self.index_squares)
+    def boxes(self):
+        return self._apply_index_ranges(self.index_boxes)
 
     @property
     def index_rows(self):
@@ -67,19 +70,19 @@ class Sudoku:
         return (self._column(i) for i in range(self.row_size))
 
     @property
-    def index_squares(self):
+    def index_boxes(self):
         '''
-        Return an iterable of ranges of indexes into the board, each defining a square.
+        Return an iterable of ranges of indexes into the board, each defining a box.
         '''
-        return (self._square(x, y) for (x,y) in self.all_squares)
+        return (self._box(x, y) for (x,y) in self.all_boxes)
 
     def peers(self, x, y):
         return {self._board[i] for i in self.index_peers(x, y) if self._board[i] != 0}
 
     def index_peers(self, x, y):
         sz = self.size
-        sqx, sqy = int(x / sz), int(y / sz)
-        return set(self._row(y)) | set(self._column(x)) | set(self._square(sqx, sqy))
+        box = int(x / sz), int(y / sz)
+        return set(self._row(y)) | set(self._column(x)) | set(self._box(*box))
 
     def _row(self, r):
         row_size = self.row_size
@@ -88,7 +91,7 @@ class Sudoku:
     def _column(self, c):
         return range(c, self.grid_size, self.row_size)
 
-    def _square(self, x, y):
+    def _box(self, x, y):
         size = self.size
         row_size = self.row_size
         offx, offy = (x * size, y * size * row_size)
@@ -103,7 +106,7 @@ class Sudoku:
     @property
     def solved(self):
         expected = self.possible_values
-        all_groups = itertools.chain(self.rows, self.columns, self.squares)
+        all_groups = itertools.chain(self.rows, self.columns, self.boxes)
         return all(expected == set(g) for g in all_groups)
 
     def _apply_index_ranges(self, ranges):
diff --git a/test.py b/test.py
index 559998f..09239ec 100644
--- a/test.py
+++ b/test.py
@@ -40,17 +40,17 @@ class Sudoku4BasicTests(Sudoku4TestCase):
             with self.subTest(col=col_list, ex=excol):
                 self.assertEqual(col_list, excol)
 
-    def test_squares(self):
-        expected_squares = {
+    def test_boxes(self):
+        expected_boxes = {
             (0,0): set([ 0,  1,  4,  5]),
             (1,0): set([ 2,  3,  6,  7]),
             (0,1): set([ 8,  9, 12, 13]),
             (1,1): set([10, 11, 14, 15]),
         }
-        for (coord, exsq) in expected_squares.items():
-            with self.subTest(sq=coord, ex=exsq):
-                sq = set(self.board._square(*coord))
-                self.assertEqual(sq, exsq)
+        for (coord, exbox) in expected_boxes.items():
+            with self.subTest(sq=coord, ex=exbox):
+                sq = set(self.board._box(*coord))
+                self.assertEqual(sq, exbox)
 
     def test_peers(self):
         expected_peers = {

From fb1066f71649260fe402a257c6056f0f39c79bf6 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 12:51:27 -0700
Subject: [PATCH 20/53] Fix the board size parameter in a test

---
 test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test.py b/test.py
index 09239ec..763fc45 100644
--- a/test.py
+++ b/test.py
@@ -85,5 +85,5 @@ class Sudoku4SolvedTests(Sudoku4TestCase):
 
     def test_simple_solution_is_solved(self):
         board = (int(i) for i in '1234341221434321')
-        self.board = sudoku.Sudoku(4, board)
+        self.board = sudoku.Sudoku(2, board)
         self.assertTrue(self.board.solved)

From a0594d1561fcc0e7c6cb1458ff848041d3f3a6d0 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 12:51:33 -0700
Subject: [PATCH 21/53] Add some doc strings

---
 sudoku.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index a394b25..1575002 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -18,14 +18,23 @@ class Sudoku:
 
     @property
     def size(self):
+        '''
+        The size of the board. This dictates the length of one side of the boxes that the board is subdivided into.
+        '''
         return self._size
 
     @property
     def row_size(self):
+        '''
+        The length of a row or column, or the area of a box in the grid.
+        '''
         return self.size ** 2
 
     @property
     def grid_size(self):
+        '''
+        The total number of squares in the grid.
+        '''
         return self.size ** 4
 
     @property
@@ -38,8 +47,8 @@ class Sudoku:
     @property
     def possible_values(self):
         '''
-        The set of valid values for any grid square, not accounting for values made invalid by already being
-        present in a peer of that square.
+        The set of valid values for any grid square. This method does not account for values made invalid by already
+        being present in a peer of a given square.
         '''
         return set(range(1, self.row_size + 1))
 

From ab927ee41d574489a93f29f974fa3c47beb81024 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Tue, 10 Oct 2017 12:54:33 -0700
Subject: [PATCH 22/53] Move some stuff around; add some docstrings

---
 sudoku.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index 1575002..13c56ef 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -64,6 +64,12 @@ class Sudoku:
     def boxes(self):
         return self._apply_index_ranges(self.index_boxes)
 
+    def peers(self, x, y):
+        '''
+        Return a set of values of the peers for a given square.
+        '''
+        return {self._board[i] for i in self.index_peers(x, y) if self._board[i] != 0}
+
     @property
     def index_rows(self):
         '''
@@ -85,11 +91,10 @@ class Sudoku:
         '''
         return (self._box(x, y) for (x,y) in self.all_boxes)
 
-    def peers(self, x, y):
-        return {self._board[i] for i in self.index_peers(x, y) if self._board[i] != 0}
-
     def index_peers(self, x, y):
-        sz = self.size
+        '''
+        Return a set of the peers, indexes into the board, for a given square.
+        '''
         box = int(x / sz), int(y / sz)
         return set(self._row(y)) | set(self._column(x)) | set(self._box(*box))
 

From e2eadf9da76a986143a81e3d96b9ff8478489ccb Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:49:18 -0700
Subject: [PATCH 23/53] Allow selecting and printing puzzles from the library
 to the command line

---
 puzzles.py | 43 +++++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/puzzles.py b/puzzles.py
index a2e1fb3..0c8431a 100644
--- a/puzzles.py
+++ b/puzzles.py
@@ -4,31 +4,54 @@
 Parser for puzzles in the ./puzzles directory.
 '''
 
+import argparse
 import sudoku
+import sys
 
 euler = []
 norvig = []
 
-def parse_puzzle_files():
+def parse_puzzle_files(quiet=True):
     global euler, norvig
 
-    print('Parsing Euler puzzles')
-    euler = list(_get_puzzles('puzzles/euler.txt'))
+    if not quiet:
+        print('Parsing Euler puzzles')
+    euler.extend(_get_puzzles('puzzles/euler.txt', quiet))
 
-    print('Parsing Norvig puzzles')
-    norvig = list(_get_puzzles('puzzles/norvig.txt'))
+    if not quiet:
+        print('Parsing Norvig puzzles')
+    norvig.extend(_get_puzzles('puzzles/norvig.txt', quiet))
 
-def _get_puzzles(filename):
+def _get_puzzles(filename, quiet):
     with open(filename, 'r') as f:
         puzzles = f.readlines()
-    return (_parse_puzzle(p) for p in puzzles if p)
+    return (_parse_puzzle(p, quiet) for p in puzzles if p)
 
-def _parse_puzzle(puzzle):
+def _parse_puzzle(puzzle, quiet):
     puzzle = puzzle.strip()
     if len(puzzle) == 81:
-        print("Parsing  '{}'".format(puzzle))
+        if not quiet:
+            print("Parsing  '{}'".format(puzzle))
         board = (int('0' if x == '.' else x) for x in puzzle)
         return sudoku.Sudoku(board=board)
     else:
-        print("Skipping '{}'".format(puzzle))
+        if not quiet:
+            print("Skipping '{}'".format(puzzle))
         return None
+
+def parse_args(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--euler', '-e', dest='library', action='store_const', const=euler, default=None)
+    parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
+    parser.add_argument('--verbose', '-v', action='store_true', default=False)
+    parser.add_argument('index', default=0, type=int)
+    return parser.parse_args(args)
+
+def main():
+    args = parse_args(sys.argv[1:])
+    parse_puzzle_files(quiet=not args.verbose)
+    print(args.library[args.index])
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())

From a34987e3db7616ebf6ec7eac75fbd12c7bc4adef Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:51:55 -0700
Subject: [PATCH 24/53] Print multiple indexes

---
 puzzles.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/puzzles.py b/puzzles.py
index 0c8431a..2a15d18 100644
--- a/puzzles.py
+++ b/puzzles.py
@@ -44,13 +44,14 @@ def parse_args(args):
     parser.add_argument('--euler', '-e', dest='library', action='store_const', const=euler, default=None)
     parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
     parser.add_argument('--verbose', '-v', action='store_true', default=False)
-    parser.add_argument('index', default=0, type=int)
+    parser.add_argument('indexes', metavar='N', nargs='+', type=int)
     return parser.parse_args(args)
 
 def main():
     args = parse_args(sys.argv[1:])
     parse_puzzle_files(quiet=not args.verbose)
-    print(args.library[args.index])
+    for i in args.indexes:
+        print(args.library[i])
     return 0
 
 if __name__ == '__main__':

From 6da7c2ecd6c9863d5030da5f0c750fd86b5f5576 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:52:27 -0700
Subject: [PATCH 25/53] Store indexes of clues as a set

---
 sudoku.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/sudoku.py b/sudoku.py
index 13c56ef..083ce86 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -13,8 +13,10 @@ class Sudoku:
         sz4 = size ** 4
         if board:
             self._board = bytes(board)[:sz4]
+            self._clues = set(i for i in range(len(self._board)) if self._board[i] != 0)
         else:
             self._board = bytes(sz4)
+            self._clues = set()
 
     @property
     def size(self):

From 9534f04a0892a43e176dd3722feeee15869ea3c9 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:52:53 -0700
Subject: [PATCH 26/53] Print the whole grid -- fallout from changing the
 meaning of size

---
 sudoku.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sudoku.py b/sudoku.py
index 083ce86..c8d6093 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -133,7 +133,7 @@ class Sudoku:
         sz = self.size
         lines = []
         spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * sz) for _ in range(sz)]))
-        for line in range(self.size):
+        for line in range(self.row_size):
             chunks = []
             for i in range(sz):
                 fields = []

From b8eda7709358a0ec88c2a8bf3fe3a670c6262433 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:53:17 -0700
Subject: [PATCH 27/53] Bold clues when printing the board

---
 sudoku.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/sudoku.py b/sudoku.py
index c8d6093..cd8d7cf 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -7,6 +7,9 @@ A Sudoku puzzle solver.
 import itertools
 import math
 
+BOLD_SEQUENCE = '\x1B[1m'
+UNBOLD_SEQUENCE = '\x1B[0m'
+
 class Sudoku:
     def __init__(self, size=3, board=None):
         self._size = size
@@ -139,7 +142,12 @@ class Sudoku:
                 fields = []
                 for j in range(sz):
                     idx = line * self.size + i * sz + j
-                    fields.append('{{board[{i}]:^{width}}}'.format(i=idx, width=field_width))
+                    if idx in self._clues:
+                        bold = BOLD_SEQUENCE
+                        unbold = UNBOLD_SEQUENCE
+                    else:
+                        bold = unbold = ''
+                    fields.append('{bold}{{board[{i}]:^{{width}}}}{unbold}'.format(i=idx, bold=bold, unbold=unbold))
                 chunks.append(''.join(fields))
             if (line % sz) == 0:
                 lines.append(spacer)
@@ -147,5 +155,5 @@ class Sudoku:
         lines.append(spacer)
         fmt = '\n'.join(lines)
         str_board = [str(n) if n != 0 else ' ' for n in self._board]
-        out = fmt.format(board=str_board)
+        out = fmt.format(board=str_board, width=field_width)
         return out

From f12263b1976ee23fca5932d591c6d9c87ce8f885 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:53:25 -0700
Subject: [PATCH 28/53] Stub of a solve() method

---
 sudoku.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/sudoku.py b/sudoku.py
index cd8d7cf..ebea6fb 100644
--- a/sudoku.py
+++ b/sudoku.py
@@ -128,6 +128,9 @@ class Sudoku:
         all_groups = itertools.chain(self.rows, self.columns, self.boxes)
         return all(expected == set(g) for g in all_groups)
 
+    def solve(self, solver):
+        return solver.solve(self)
+
     def _apply_index_ranges(self, ranges):
         return ((self._board[i] for i in r) for r in ranges)
 

From c0021ac2c210a911fa85de7874ed779bb6080e05 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:58:31 -0700
Subject: [PATCH 29/53] Make a sudoku package

---
 sudoku.py => sudoku/__init__.py | 0
 puzzles.py => sudoku/puzzles.py | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename sudoku.py => sudoku/__init__.py (100%)
 rename puzzles.py => sudoku/puzzles.py (100%)

diff --git a/sudoku.py b/sudoku/__init__.py
similarity index 100%
rename from sudoku.py
rename to sudoku/__init__.py
diff --git a/puzzles.py b/sudoku/puzzles.py
similarity index 100%
rename from puzzles.py
rename to sudoku/puzzles.py

From ed419300925f3a80487713f6dfedc2c318c2583e Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 15:59:14 -0700
Subject: [PATCH 30/53] Oops broke the tests

---
 sudoku/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index ebea6fb..30a3536 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -100,7 +100,7 @@ class Sudoku:
         '''
         Return a set of the peers, indexes into the board, for a given square.
         '''
-        box = int(x / sz), int(y / sz)
+        box = int(x / self.size), int(y / self.size)
         return set(self._row(y)) | set(self._column(x)) | set(self._box(*box))
 
     def _row(self, r):

From 7809c38104e4b0286ce4b6880b909944fe943bd9 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 16:03:45 -0700
Subject: [PATCH 31/53] Allow specifying path to puzzles library

By default look in the current directory for a puzzles/ directory.
---
 sudoku/puzzles.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/sudoku/puzzles.py b/sudoku/puzzles.py
index 2a15d18..78404ef 100644
--- a/sudoku/puzzles.py
+++ b/sudoku/puzzles.py
@@ -5,22 +5,22 @@ Parser for puzzles in the ./puzzles directory.
 '''
 
 import argparse
-import sudoku
+import os.path
 import sys
 
 euler = []
 norvig = []
 
-def parse_puzzle_files(quiet=True):
+def parse_puzzle_files(path, quiet=True):
     global euler, norvig
 
     if not quiet:
         print('Parsing Euler puzzles')
-    euler.extend(_get_puzzles('puzzles/euler.txt', quiet))
+    euler.extend(_get_puzzles(os.path.join(path, 'euler.txt'), quiet))
 
     if not quiet:
         print('Parsing Norvig puzzles')
-    norvig.extend(_get_puzzles('puzzles/norvig.txt', quiet))
+    norvig.extend(_get_puzzles(os.path.join(path, 'norvig.txt'), quiet))
 
 def _get_puzzles(filename, quiet):
     with open(filename, 'r') as f:
@@ -33,7 +33,7 @@ def _parse_puzzle(puzzle, quiet):
         if not quiet:
             print("Parsing  '{}'".format(puzzle))
         board = (int('0' if x == '.' else x) for x in puzzle)
-        return sudoku.Sudoku(board=board)
+        return Sudoku(board=board)
     else:
         if not quiet:
             print("Skipping '{}'".format(puzzle))
@@ -44,12 +44,13 @@ def parse_args(args):
     parser.add_argument('--euler', '-e', dest='library', action='store_const', const=euler, default=None)
     parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
     parser.add_argument('--verbose', '-v', action='store_true', default=False)
+    parser.add_argument('--library', '-l', dest='path', default='./puzzles')
     parser.add_argument('indexes', metavar='N', nargs='+', type=int)
     return parser.parse_args(args)
 
 def main():
     args = parse_args(sys.argv[1:])
-    parse_puzzle_files(quiet=not args.verbose)
+    parse_puzzle_files(args.path, quiet=not args.verbose)
     for i in args.indexes:
         print(args.library[i])
     return 0

From 0976ec8bb57916e2e7df7d41cf9b4744725c1dc6 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 16:04:14 -0700
Subject: [PATCH 32/53] Move puzzles back up a level

---
 sudoku/puzzles.py => puzzles.py | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename sudoku/puzzles.py => puzzles.py (100%)

diff --git a/sudoku/puzzles.py b/puzzles.py
similarity index 100%
rename from sudoku/puzzles.py
rename to puzzles.py

From 301a56904cffefc564cd6904c8096cd37304cafb Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 16:05:10 -0700
Subject: [PATCH 33/53] Relative import Sudoku symbol

---
 puzzles.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/puzzles.py b/puzzles.py
index 78404ef..cb229ba 100644
--- a/puzzles.py
+++ b/puzzles.py
@@ -8,6 +8,8 @@ import argparse
 import os.path
 import sys
 
+from sudoku import Sudoku
+
 euler = []
 norvig = []
 

From 77456d51142e819c68247dcdd81eae50654d1e0c Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 16:07:33 -0700
Subject: [PATCH 34/53] Add solvers package

---
 sudoku/solvers/__init__.py | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 sudoku/solvers/__init__.py

diff --git a/sudoku/solvers/__init__.py b/sudoku/solvers/__init__.py
new file mode 100644
index 0000000..de3672c
--- /dev/null
+++ b/sudoku/solvers/__init__.py
@@ -0,0 +1,8 @@
+# Eryn Wells <eryn@erynwells.me>
+'''
+'''
+
+class Solver:
+    def solve(self, sudoku):
+        # TODO: Any subclass of Solver should implement this.
+        raise NotImplementedError

From e329208db9cb3e77cd5eb66931d27440599aa1c1 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:40:39 -0700
Subject: [PATCH 35/53] Rewrite the printer to be cleaner

---
 sudoku/__init__.py | 61 ++++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 30a3536..30cd255 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -42,6 +42,13 @@ class Sudoku:
         '''
         return self.size ** 4
 
+    @property
+    def all_squares(self):
+        '''
+        Iterator of xy-coordinates for every square in the grid.
+        '''
+        return itertools.product(range(self.row_size), repeat=2)
+
     @property
     def all_boxes(self):
         '''
@@ -131,32 +138,38 @@ class Sudoku:
     def solve(self, solver):
         return solver.solve(self)
 
+    def _xy_to_idx(self, x, y):
+        return y * self.row_size + x
+
     def _apply_index_ranges(self, ranges):
         return ((self._board[i] for i in r) for r in ranges)
 
     def __str__(self):
         field_width = len(str(max(self.possible_values)))
-        sz = self.size
-        lines = []
-        spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * sz) for _ in range(sz)]))
-        for line in range(self.row_size):
-            chunks = []
-            for i in range(sz):
-                fields = []
-                for j in range(sz):
-                    idx = line * self.size + i * sz + j
-                    if idx in self._clues:
-                        bold = BOLD_SEQUENCE
-                        unbold = UNBOLD_SEQUENCE
-                    else:
-                        bold = unbold = ''
-                    fields.append('{bold}{{board[{i}]:^{{width}}}}{unbold}'.format(i=idx, bold=bold, unbold=unbold))
-                chunks.append(''.join(fields))
-            if (line % sz) == 0:
-                lines.append(spacer)
-            lines.append('{0}{1}{0}'.format('|', '|'.join(chunks)))
-        lines.append(spacer)
-        fmt = '\n'.join(lines)
-        str_board = [str(n) if n != 0 else ' ' for n in self._board]
-        out = fmt.format(board=str_board, width=field_width)
-        return out
+        spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * self.size) for _ in range(self.size)]))
+
+        fmt = ''
+        for (y,x) in self.all_squares:
+            if x == 0:
+                if y % self.size == 0:
+                    if y != 0:
+                        fmt += '\n'
+                    fmt += '{spacer}'
+                fmt += '\n'
+
+            if x % self.size == 0:
+                fmt += '|'
+
+            idx = self._xy_to_idx(x,y)
+            if idx in self._clues:
+                bold = BOLD_SEQUENCE
+                unbold = UNBOLD_SEQUENCE
+            else:
+                bold = unbold = ''
+            fmt += '{bold}{{board[{i}]:^{{width}}}}{unbold}'.format(i=idx, bold=bold, unbold=unbold)
+
+            if x == (self.row_size - 1):
+                fmt += '|'
+        fmt += '\n{spacer}'
+
+        return fmt.format(board=[str(i) if i != 0 else ' ' for i in self._board], spacer=spacer, width=field_width)

From 15492696619c7925d5d213998da1e7ede0c90961 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:41:32 -0700
Subject: [PATCH 36/53] Mutable squares, immutable clues set

---
 sudoku/__init__.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 30cd255..701ba39 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -15,11 +15,11 @@ class Sudoku:
         self._size = size
         sz4 = size ** 4
         if board:
-            self._board = bytes(board)[:sz4]
-            self._clues = set(i for i in range(len(self._board)) if self._board[i] != 0)
+            self._board = bytearray(board)[:sz4]
+            self._clues = frozenset(i for i in range(len(self._board)) if self._board[i] != 0)
         else:
-            self._board = bytes(sz4)
-            self._clues = set()
+            self._board = bytearray(sz4)
+            self._clues = frozenset()
 
     @property
     def size(self):

From f7b6fb053f64f05cc8de756ef1327f3614f45022 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:42:11 -0700
Subject: [PATCH 37/53] Memoize possible_values set

---
 sudoku/__init__.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 701ba39..fd29b5f 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -20,6 +20,7 @@ class Sudoku:
         else:
             self._board = bytearray(sz4)
             self._clues = frozenset()
+        self._possible_values = None
 
     @property
     def size(self):
@@ -62,7 +63,9 @@ class Sudoku:
         The set of valid values for any grid square. This method does not account for values made invalid by already
         being present in a peer of a given square.
         '''
-        return set(range(1, self.row_size + 1))
+        if not self._possible_values:
+            self._possible_values = set(range(1, self.row_size + 1))
+        return self._possible_values
 
     @property
     def rows(self):

From 181bc7d61e79949ea1ca2e063b6d9053babcc8b4 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:43:15 -0700
Subject: [PATCH 38/53] Remove idx from peer set

---
 sudoku/__init__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index fd29b5f..cbe5b38 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -110,8 +110,9 @@ class Sudoku:
         '''
         Return a set of the peers, indexes into the board, for a given square.
         '''
+        idx = self._xy_to_idx(x, y)
         box = int(x / self.size), int(y / self.size)
-        return set(self._row(y)) | set(self._column(x)) | set(self._box(*box))
+        return (set(self._row(y)) | set(self._column(x)) | set(self._box(*box))) - {idx}
 
     def _row(self, r):
         row_size = self.row_size

From 7a0e31858fdc622f3a5be88fac8d54fdc863151d Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:43:42 -0700
Subject: [PATCH 39/53] Add __repr__ to Sudoku

---
 sudoku/__init__.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index cbe5b38..659739c 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -148,6 +148,11 @@ class Sudoku:
     def _apply_index_ranges(self, ranges):
         return ((self._board[i] for i in r) for r in ranges)
 
+    def __repr__(self):
+        return "{}(size={}, board='{}')".format(self.__class__.__name__,
+                                                self.size,
+                                                ''.join(str(i) for i in self._board))
+
     def __str__(self):
         field_width = len(str(max(self.possible_values)))
         spacer = '{0}{1}{0}'.format('+', '+'.join(['-' * (field_width * self.size) for _ in range(self.size)]))

From 9ebabd4b56c637abf1d04ce5f3475fd80a07323d Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:44:19 -0700
Subject: [PATCH 40/53] Add square setter to Sudoku

---
 sudoku/__init__.py | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 659739c..d9f4311 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -142,6 +142,22 @@ class Sudoku:
     def solve(self, solver):
         return solver.solve(self)
 
+    def set(self, x, y, value):
+        idx = self._xy_to_idx(x, y)
+        if idx in self._clues:
+            raise SquareIsClue('Cannot set clue square ({},{})'.format(x, y))
+
+        if value not in self.possible_values:
+            raise ValueError('{} not in set of possible values {}'.format(value, self.possible_values))
+
+        peers = self.peers(x, y)
+        if peers == self.possible_values:
+            raise NoPossibleValues('Peer set for ({},{}) contains all possible values'.format(x, y))
+        if value in peers:
+            raise ValueExistsInPeers('{} already exists in the peer set for ({},{})'.format(value, x, y))
+
+        self._board[idx] = value
+
     def _xy_to_idx(self, x, y):
         return y * self.row_size + x
 
@@ -182,3 +198,15 @@ class Sudoku:
         fmt += '\n{spacer}'
 
         return fmt.format(board=[str(i) if i != 0 else ' ' for i in self._board], spacer=spacer, width=field_width)
+
+class SudokuError(Exception):
+    pass
+
+class SquareIsClue(SudokuError):
+    pass
+
+class NoPossibleValues(SudokuError):
+    pass
+
+class ValueExistsInPeers(SudokuError):
+    pass

From 189589c0e614268cd990ecce1922d88563a152b5 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:44:41 -0700
Subject: [PATCH 41/53] solve() takes a function that solves the puzzle

---
 sudoku/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index d9f4311..1c52a20 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -140,7 +140,7 @@ class Sudoku:
         return all(expected == set(g) for g in all_groups)
 
     def solve(self, solver):
-        return solver.solve(self)
+        return solver(self)
 
     def set(self, x, y, value):
         idx = self._xy_to_idx(x, y)

From 65f4453e786dea7361b051a84d85df127cffe9fb Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:45:00 -0700
Subject: [PATCH 42/53] Attempt #1 at a backtracking solver

---
 sudoku/solvers/__init__.py    |  6 ++---
 sudoku/solvers/backtracker.py | 48 +++++++++++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 4 deletions(-)
 create mode 100644 sudoku/solvers/backtracker.py

diff --git a/sudoku/solvers/__init__.py b/sudoku/solvers/__init__.py
index de3672c..becaaba 100644
--- a/sudoku/solvers/__init__.py
+++ b/sudoku/solvers/__init__.py
@@ -1,8 +1,6 @@
 # Eryn Wells <eryn@erynwells.me>
 '''
+A library of Sudoku solvers.
 '''
 
-class Solver:
-    def solve(self, sudoku):
-        # TODO: Any subclass of Solver should implement this.
-        raise NotImplementedError
+from . import backtracker
diff --git a/sudoku/solvers/backtracker.py b/sudoku/solvers/backtracker.py
new file mode 100644
index 0000000..62cd01e
--- /dev/null
+++ b/sudoku/solvers/backtracker.py
@@ -0,0 +1,48 @@
+# Eryn Wells <eryn@erynwells.me>
+
+from .. import SquareIsClue, ValueExistsInPeers, NoPossibleValues
+
+class Backtrack(Exception):
+    pass
+
+def solve(sudoku):
+    '''
+    Implements a recursive backtracking Sudoku solver.
+    '''
+    return _solve_square(sudoku, 0, 0)
+
+def _solve_square(sudoku, x, y):
+    for value in sudoku.possible_values:
+        try:
+            print('({},{}) trying {}'.format(x, y, value))
+            sudoku.set(x, y, value)
+        except SquareIsClue:
+            # Do nothing with this square; continue on to the next square below.
+            print('({},{}) square is clue'.format(x,y))
+            pass
+        except ValueExistsInPeers:
+            print('({},{}) value exists in peer set'.format(x,y))
+            # Try next value.
+            continue
+        except NoPossibleValues:
+            # Need to backtrack.
+            print('({},{}) backtracking'.format(x,y))
+            raise Backtrack()
+
+        next_coord = _next_coord(sudoku, x, y)
+        if not next_coord:
+            break
+
+        try:
+            _solve_square(sudoku, *next_coord)
+        except Backtrack:
+            continue
+    return sudoku
+
+def _next_coord(sudoku, x, y):
+    x += 1
+    if x >= sudoku.row_size:
+        (x, y) = (0, y + 1)
+    if y >= sudoku.row_size:
+        return None
+    return (x, y)

From d25a320c30d026bf1f0bb8ac32b92e42866bb2b4 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:45:46 -0700
Subject: [PATCH 43/53] puzzle script takes an algorithm to use to solve the
 given puzzles

---
 puzzles.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/puzzles.py b/puzzles.py
index cb229ba..3db054f 100644
--- a/puzzles.py
+++ b/puzzles.py
@@ -9,6 +9,7 @@ import os.path
 import sys
 
 from sudoku import Sudoku
+from sudoku.solvers import backtracker
 
 euler = []
 norvig = []
@@ -44,9 +45,10 @@ def _parse_puzzle(puzzle, quiet):
 def parse_args(args):
     parser = argparse.ArgumentParser()
     parser.add_argument('--euler', '-e', dest='library', action='store_const', const=euler, default=None)
-    parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
-    parser.add_argument('--verbose', '-v', action='store_true', default=False)
     parser.add_argument('--library', '-l', dest='path', default='./puzzles')
+    parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
+    parser.add_argument('--solver', '-s', default=None)
+    parser.add_argument('--verbose', '-v', action='store_true', default=False)
     parser.add_argument('indexes', metavar='N', nargs='+', type=int)
     return parser.parse_args(args)
 
@@ -54,7 +56,12 @@ def main():
     args = parse_args(sys.argv[1:])
     parse_puzzle_files(args.path, quiet=not args.verbose)
     for i in args.indexes:
-        print(args.library[i])
+        puzzle = args.library[i]
+        print(puzzle)
+        if args.solver is not None:
+            if args.solver == 'backtracking':
+                puzzle.solve(backtracker.solve)
+            print(puzzle)
     return 0
 
 if __name__ == '__main__':

From 387ccacb8de0ce95528c94135103df626edef2fc Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 19:46:16 -0700
Subject: [PATCH 44/53] Print some stuff after setting a value

---
 sudoku/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 1c52a20..9d94255 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -157,6 +157,7 @@ class Sudoku:
             raise ValueExistsInPeers('{} already exists in the peer set for ({},{})'.format(value, x, y))
 
         self._board[idx] = value
+        print('({},{}) <- {} (p:{}) {!r}'.format(x, y, value, peers, self))
 
     def _xy_to_idx(self, x, y):
         return y * self.row_size + x

From a9a331df91df44b871f3f0251add02270bc89feb Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 20:24:09 -0700
Subject: [PATCH 45/53] Move actual square setter to _set

---
 sudoku/__init__.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 9d94255..0865e3f 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -143,10 +143,6 @@ class Sudoku:
         return solver(self)
 
     def set(self, x, y, value):
-        idx = self._xy_to_idx(x, y)
-        if idx in self._clues:
-            raise SquareIsClue('Cannot set clue square ({},{})'.format(x, y))
-
         if value not in self.possible_values:
             raise ValueError('{} not in set of possible values {}'.format(value, self.possible_values))
 
@@ -156,8 +152,17 @@ class Sudoku:
         if value in peers:
             raise ValueExistsInPeers('{} already exists in the peer set for ({},{})'.format(value, x, y))
 
+        self._set(x, y, value)
+
+    def unset(self, x, y):
+        self._set(x, y, 0)
+
+    def _set(self, x, y, value):
+        idx = self._xy_to_idx(x, y)
+        if idx in self._clues:
+            raise SquareIsClue('Cannot set clue square ({},{})'.format(x, y))
         self._board[idx] = value
-        print('({},{}) <- {} (p:{}) {!r}'.format(x, y, value, peers, self))
+        print('({},{}) <- {} {!r}'.format(x, y, value, self))
 
     def _xy_to_idx(self, x, y):
         return y * self.row_size + x

From 3b380b17d281cd60465a55a39dd9047a6a915c2e Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 20:25:11 -0700
Subject: [PATCH 46/53] Take care of some edge cases in the backtracker

---
 sudoku/solvers/backtracker.py | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/sudoku/solvers/backtracker.py b/sudoku/solvers/backtracker.py
index 62cd01e..fd0f6a0 100644
--- a/sudoku/solvers/backtracker.py
+++ b/sudoku/solvers/backtracker.py
@@ -12,21 +12,21 @@ def solve(sudoku):
     return _solve_square(sudoku, 0, 0)
 
 def _solve_square(sudoku, x, y):
+    should_backtrack = False
     for value in sudoku.possible_values:
+        should_backtrack = False
         try:
-            print('({},{}) trying {}'.format(x, y, value))
             sudoku.set(x, y, value)
         except SquareIsClue:
             # Do nothing with this square; continue on to the next square below.
-            print('({},{}) square is clue'.format(x,y))
             pass
         except ValueExistsInPeers:
-            print('({},{}) value exists in peer set'.format(x,y))
             # Try next value.
+            should_backtrack = True
             continue
         except NoPossibleValues:
             # Need to backtrack.
-            print('({},{}) backtracking'.format(x,y))
+            sudoku.unset(x, y)
             raise Backtrack()
 
         next_coord = _next_coord(sudoku, x, y)
@@ -34,9 +34,19 @@ def _solve_square(sudoku, x, y):
             break
 
         try:
-            _solve_square(sudoku, *next_coord)
+            return _solve_square(sudoku, *next_coord)
         except Backtrack:
+            should_backtrack = True
             continue
+
+    if should_backtrack:
+        # Unhandled backtrack. Pop out of this one too.
+        try:
+            sudoku.unset(x, y)
+        except SquareIsClue:
+            pass
+        raise Backtrack()
+
     return sudoku
 
 def _next_coord(sudoku, x, y):

From a7dda24015c5c6c8f5d99459e0020d063366fa19 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Wed, 11 Oct 2017 20:53:10 -0700
Subject: [PATCH 47/53] Print stuff in backtracking module only; clean up the
 \r stuff

---
 sudoku/__init__.py            | 1 -
 sudoku/solvers/backtracker.py | 9 ++++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 0865e3f..92d92ae 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -162,7 +162,6 @@ class Sudoku:
         if idx in self._clues:
             raise SquareIsClue('Cannot set clue square ({},{})'.format(x, y))
         self._board[idx] = value
-        print('({},{}) <- {} {!r}'.format(x, y, value, self))
 
     def _xy_to_idx(self, x, y):
         return y * self.row_size + x
diff --git a/sudoku/solvers/backtracker.py b/sudoku/solvers/backtracker.py
index fd0f6a0..d58fad2 100644
--- a/sudoku/solvers/backtracker.py
+++ b/sudoku/solvers/backtracker.py
@@ -26,8 +26,10 @@ def _solve_square(sudoku, x, y):
             continue
         except NoPossibleValues:
             # Need to backtrack.
-            sudoku.unset(x, y)
-            raise Backtrack()
+            should_backtrack = True
+            break
+
+        print('\r{!r}'.format(sudoku), end='', flush=True)
 
         next_coord = _next_coord(sudoku, x, y)
         if not next_coord:
@@ -40,13 +42,14 @@ def _solve_square(sudoku, x, y):
             continue
 
     if should_backtrack:
-        # Unhandled backtrack. Pop out of this one too.
         try:
             sudoku.unset(x, y)
         except SquareIsClue:
             pass
         raise Backtrack()
 
+    print()
+
     return sudoku
 
 def _next_coord(sudoku, x, y):

From 1186305712b30c7ffa634009246420fc984d2896 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Thu, 12 Oct 2017 12:29:49 -0700
Subject: [PATCH 48/53] Clean up puzzles.py interface

---
 puzzles.py | 41 ++++++++++++++++++++---------------------
 1 file changed, 20 insertions(+), 21 deletions(-)
 mode change 100644 => 100755 puzzles.py

diff --git a/puzzles.py b/puzzles.py
old mode 100644
new mode 100755
index 3db054f..1d7dc00
--- a/puzzles.py
+++ b/puzzles.py
@@ -8,22 +8,16 @@ import argparse
 import os.path
 import sys
 
-from sudoku import Sudoku
-from sudoku.solvers import backtracker
+from sudoku import Sudoku, solvers
 
 euler = []
 norvig = []
 
-def parse_puzzle_files(path, quiet=True):
-    global euler, norvig
-
+def parse_puzzle_library(path, quiet=True):
     if not quiet:
-        print('Parsing Euler puzzles')
-    euler.extend(_get_puzzles(os.path.join(path, 'euler.txt'), quiet))
-
-    if not quiet:
-        print('Parsing Norvig puzzles')
-    norvig.extend(_get_puzzles(os.path.join(path, 'norvig.txt'), quiet))
+        print('Parsing puzzles in {}'.format(path))
+    puzzles = _get_puzzles(path, quiet)
+    return puzzles
 
 def _get_puzzles(filename, quiet):
     with open(filename, 'r') as f:
@@ -44,23 +38,28 @@ def _parse_puzzle(puzzle, quiet):
 
 def parse_args(args):
     parser = argparse.ArgumentParser()
-    parser.add_argument('--euler', '-e', dest='library', action='store_const', const=euler, default=None)
-    parser.add_argument('--library', '-l', dest='path', default='./puzzles')
-    parser.add_argument('--norvig', '-n', dest='library', action='store_const', const=norvig, default=None)
-    parser.add_argument('--solver', '-s', default=None)
-    parser.add_argument('--verbose', '-v', action='store_true', default=False)
-    parser.add_argument('indexes', metavar='N', nargs='+', type=int)
+    parser.add_argument('--solver', '-s', default=None,
+                        help='The solver to use to solve this puzzle.')
+    parser.add_argument('--verbose', '-v', action='store_true', default=False,
+                        help='Print extra information when parsing puzzle libraries.')
+    parser.add_argument('library',
+                        help='A library file containing puzzles, one per line.')
+    parser.add_argument('indexes', metavar='N', nargs='+', type=int,
+                        help='0-based indexes of puzzles in the library')
     return parser.parse_args(args)
 
 def main():
     args = parse_args(sys.argv[1:])
-    parse_puzzle_files(args.path, quiet=not args.verbose)
+    puzzle_library = list(parse_puzzle_library(args.library, quiet=not args.verbose))
     for i in args.indexes:
-        puzzle = args.library[i]
+        puzzle = puzzle_library[i]
         print(puzzle)
         if args.solver is not None:
-            if args.solver == 'backtracking':
-                puzzle.solve(backtracker.solve)
+            try:
+                solver = getattr(solvers, args.solver)
+                puzzle.solve(solver.solve)
+            except AttributeError:
+                print('No solver named {}'.format(args.solver))
             print(puzzle)
     return 0
 

From fba52c7f090518420819dc127c80e06148af2de3 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 16 Oct 2017 12:23:42 -0700
Subject: [PATCH 49/53] Add Sudoku.possible_values_for_square()

---
 sudoku/__init__.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 92d92ae..a693408 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -67,6 +67,10 @@ class Sudoku:
             self._possible_values = set(range(1, self.row_size + 1))
         return self._possible_values
 
+    def possible_values_for_square(self, x, y):
+        peers = self.peers(x, y)
+        return self.possible_values - peers
+
     @property
     def rows(self):
         return self._apply_index_ranges(self.index_rows)

From 137e4e643691899e21932412e367e4c51ea30850 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 16 Oct 2017 12:24:02 -0700
Subject: [PATCH 50/53] Add Sudoku.get() -> value of board at (x,y)

---
 sudoku/__init__.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index a693408..130b175 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -146,6 +146,11 @@ class Sudoku:
     def solve(self, solver):
         return solver(self)
 
+    def get(self, x, y):
+        idx = self._xy_to_idx(x, y)
+        value = self._board[idx]
+        return None if value == 0 else value
+
     def set(self, x, y, value):
         if value not in self.possible_values:
             raise ValueError('{} not in set of possible values {}'.format(value, self.possible_values))

From c9a86d0fdc4e0f6607873cac4c447c46c2dca524 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 16 Oct 2017 12:25:30 -0700
Subject: [PATCH 51/53] Add dlx solver (this is still a WIP)

The solver builds the constraint matrix. I have not fully verified its correctness, nor does the thing actually do the thing yet.
---
 sudoku/solvers/__init__.py |   2 +-
 sudoku/solvers/dlx.py      | 137 +++++++++++++++++++++++++++++++++++++
 2 files changed, 138 insertions(+), 1 deletion(-)
 create mode 100644 sudoku/solvers/dlx.py

diff --git a/sudoku/solvers/__init__.py b/sudoku/solvers/__init__.py
index becaaba..2f2ffed 100644
--- a/sudoku/solvers/__init__.py
+++ b/sudoku/solvers/__init__.py
@@ -3,4 +3,4 @@
 A library of Sudoku solvers.
 '''
 
-from . import backtracker
+from . import backtracker, dlx
diff --git a/sudoku/solvers/dlx.py b/sudoku/solvers/dlx.py
new file mode 100644
index 0000000..e3657e0
--- /dev/null
+++ b/sudoku/solvers/dlx.py
@@ -0,0 +1,137 @@
+# Eryn Wells <eryn@erynwells.me>
+
+from collections import namedtuple
+from enum import Enum
+from .. import SquareIsClue, ValueExistsInPeers, NoPossibleValues
+
+class Backtrack(Exception):
+    pass
+
+class ConstraintKind(Enum):
+    CELL = 1
+    ROW = 2
+    COL = 3
+    BOX = 4
+
+Constraint = namedtuple('CellConstraint', ['kind', 'index', 'value'])
+Possibility= namedtuple('Possibility', ['row', 'col', 'value'])
+
+class Node:
+    '''
+    A doubly-linked list node that is a member of two distinct lists. One list is the row it is a member of. The other
+    list is the column it is a member of.
+    '''
+    def __init__(self):
+        # Horizontal linked list. West is "previous", east is "next".
+        self.west = self.east = self
+        # Vertical linked list. North is "previous", south is "next".
+        self.north = self.south = self
+
+    def insert_after_in_row(self, node):
+        self._insert(node, 'west', 'east')
+
+    def insert_before_in_col(self, node):
+        self._insert(node, 'south', 'north')
+
+    def iterate_row(self):
+        return self._iterate('east')
+
+    def iterate_col(self):
+        return self._iterate('south')
+
+    def _insert(self, node, prev_attr, next_attr):
+        self_east = getattr(self, next_attr)    # Save my old next node
+        setattr(self, next_attr, node)          # My next points to the new node
+        setattr(node, next_attr, self_east)     # New node's next points to the old next
+        setattr(node, prev_attr, self)          # New node's prev points to me
+        if self_east:
+            setattr(self_east, prev_attr, node) # Old next's prev points to the new node
+
+    def _iterate(self, next_attr):
+        cur = self
+        while cur:
+            yield cur
+            cur = getattr(cur, next_attr)
+            if cur == self:
+                break
+
+class Header(Node):
+    '''
+    A column header, including a count of the number of rows in this column.
+    '''
+    def __init__(self, constraint):
+        Node.__init__(self)
+        self.constraint = constraint
+        self.number_of_rows = 0
+
+    def append(self, node):
+        self.insert_before_in_col(node)
+        self.number_of_rows += 1
+        node.header = self
+
+class Cell(Node):
+    '''
+    A cell in the DLX matrix.
+    '''
+    def __init__(self, possibility):
+        super(Cell, self).__init__()
+        self.header = None
+        self.possibility = possibility
+
+    def __repr__(self):
+        return '{}({})'.format(self.__class__.__name__, self.possibility)
+
+def solve(sudoku):
+    '''
+    Implements DLX, Don Knuth's Dancing Links version of Algorithm X, for solving exact cover problems.
+    '''
+    # TODO: Construct the matrix based on the provided sudoku.
+    # TODO: Perform the algorithm on the matrix.
+    # TODO: With the solution from running the algorithm above, fill in the sudoku.
+    return sudoku
+
+def _build_matrix(sudoku):
+    # 1. Create headers for all columns.
+    headers = _build_headers(sudoku)
+    _build_rows(sudoku, headers)
+    return headers
+
+def _build_headers(sudoku):
+    head = None
+    cur = None
+
+    def _insert_header(data):
+        header = Header(data)
+        if cur:
+            cur.insert_after_in_row(header)
+        return header
+
+    # Cell constraints
+    for i in range(sudoku.grid_size):
+        cur = _insert_header(Constraint(ConstraintKind.CELL, i, None))
+
+    # Row, Col, and Box constraints
+    for kind in (ConstraintKind.ROW, ConstraintKind.COL, ConstraintKind.BOX):
+        for i in range(sudoku.row_size):
+            for value in sudoku.possible_values:
+                cur = _insert_header(Constraint(kind, i, value))
+
+    # Head points to the first column header
+    head = cur.east
+
+    return head
+
+def _build_rows(sudoku, headers):
+    for (index, coords) in enumerate(sudoku.all_squares):
+        board_value = sudoku.get(*coords)
+        possibilities = {board_value} if board_value else sudoku.possible_values_for_square(*coords)
+        for value in possibilities:
+            cur = None
+            for col in headers.iterate_row():
+                if col.constraint.index != index:
+                    continue
+                cell = Cell(Possibility(*coords, value))
+                col.append(cell)
+                if cur:
+                    cur.insert_after_in_row(cell)
+                cur = cell

From 3689ac69748b8540f659e71db2109663d97803a2 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 16 Oct 2017 12:40:00 -0700
Subject: [PATCH 52/53] Move existing test file alongside the sudoku
 __init__.py

---
 test.py => sudoku/test.py | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)
 rename test.py => sudoku/test.py (72%)

diff --git a/test.py b/sudoku/test.py
similarity index 72%
rename from test.py
rename to sudoku/test.py
index 763fc45..b8fccd2 100644
--- a/test.py
+++ b/sudoku/test.py
@@ -54,25 +54,25 @@ class Sudoku4BasicTests(Sudoku4TestCase):
 
     def test_peers(self):
         expected_peers = {
-            (0,0): set([0, 1, 2, 3, 4, 8, 12, 5]),
-            (1,0): set([0, 1, 2, 3, 5, 9, 13, 4]),
-            (2,0): set([0, 1, 2, 3, 6, 10, 14, 7]),
-            (3,0): set([0, 1, 2, 3, 7, 11, 15, 6]),
+            (0,0): set([1, 2, 3, 4,  8, 12, 5]),
+            (1,0): set([0, 2, 3, 5,  9, 13, 4]),
+            (2,0): set([0, 1, 3, 6, 10, 14, 7]),
+            (3,0): set([0, 1, 2, 7, 11, 15, 6]),
 
-            (0,1): set([4, 5, 6, 7, 0, 8, 12, 1]),
-            (1,1): set([4, 5, 6, 7, 1, 9, 13, 0]),
-            (2,1): set([4, 5, 6, 7, 2, 10, 14, 3]),
-            (3,1): set([4, 5, 6, 7, 3, 11, 15, 2]),
+            (0,1): set([5, 6, 7, 0,  8, 12, 1]),
+            (1,1): set([4, 6, 7, 1,  9, 13, 0]),
+            (2,1): set([4, 5, 7, 2, 10, 14, 3]),
+            (3,1): set([4, 5, 6, 3, 11, 15, 2]),
 
-            (0,2): set([8, 9, 10, 11, 0, 4, 12, 13]),
-            (1,2): set([8, 9, 10, 11, 1, 5, 13, 12]),
-            (2,2): set([8, 9, 10, 11, 2, 6, 14, 15]),
-            (3,2): set([8, 9, 10, 11, 3, 7, 15, 14]),
+            (0,2): set([9, 10, 11, 0, 4, 12, 13]),
+            (1,2): set([8, 10, 11, 1, 5, 13, 12]),
+            (2,2): set([8,  9, 11, 2, 6, 14, 15]),
+            (3,2): set([8,  9, 10, 3, 7, 15, 14]),
 
-            (0,3): set([12, 13, 14, 15, 0, 4, 8, 9]),
-            (1,3): set([12, 13, 14, 15, 1, 5, 9, 8]),
-            (2,3): set([12, 13, 14, 15, 2, 6, 10, 11]),
-            (3,3): set([12, 13, 14, 15, 3, 7, 11, 10]),
+            (0,3): set([13, 14, 15, 0, 4, 8, 9]),
+            (1,3): set([12, 14, 15, 1, 5, 9, 8]),
+            (2,3): set([12, 13, 15, 2, 6, 10, 11]),
+            (3,3): set([12, 13, 14, 3, 7, 11, 10]),
         }
         for (coords, expeers) in expected_peers.items():
             with self.subTest(coord=coords, ex=expeers):

From 2529533661da0d229d00651f3599c30cf8d57b79 Mon Sep 17 00:00:00 2001
From: Eryn Wells <eryn@erynwells.me>
Date: Mon, 16 Oct 2017 12:40:29 -0700
Subject: [PATCH 53/53] Adjust possible_values_for_square to behave like dlx
 expects

---
 sudoku/__init__.py    | 8 ++++++--
 sudoku/solvers/dlx.py | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/sudoku/__init__.py b/sudoku/__init__.py
index 130b175..3cb0572 100644
--- a/sudoku/__init__.py
+++ b/sudoku/__init__.py
@@ -68,8 +68,12 @@ class Sudoku:
         return self._possible_values
 
     def possible_values_for_square(self, x, y):
-        peers = self.peers(x, y)
-        return self.possible_values - peers
+        value = self.get(x, y)
+        if value:
+            return {value}
+        else:
+            peers = self.peers(x, y)
+            return self.possible_values - peers
 
     @property
     def rows(self):
diff --git a/sudoku/solvers/dlx.py b/sudoku/solvers/dlx.py
index e3657e0..39e4b98 100644
--- a/sudoku/solvers/dlx.py
+++ b/sudoku/solvers/dlx.py
@@ -124,7 +124,7 @@ def _build_headers(sudoku):
 def _build_rows(sudoku, headers):
     for (index, coords) in enumerate(sudoku.all_squares):
         board_value = sudoku.get(*coords)
-        possibilities = {board_value} if board_value else sudoku.possible_values_for_square(*coords)
+        possibilities = sudoku.possible_values_for_square(*coords)
         for value in possibilities:
             cur = None
             for col in headers.iterate_row():