add functions implementation, update readme

Author: Matthias Nannt

README.md

@@ -3,17 +3,23 @@
 
 # Question 1 (Naked Twins)
 Q: How do we use constraint propagation to solve the naked twins problem?  
-A: *Student should provide answer here*
+A: When we have a naked twin in a unit (row, col, ...), we know that the values for the twins
+   can't be in other squares of this unit, so we delete the possibilities from these other squares. With this method
+   we can reduce the complexity of our grid and continue with our algorithm (eliminate/only_choice and search)
 
 # Question 2 (Diagonal Sudoku)
 Q: How do we use constraint propagation to solve the diagonal sudoku problem?  
-A: *Student should provide answer here*
+A: We take a look at the diagonals of the sudoku and eliminate the values of solved squares from their peers
+   (other squares in the unit).
+   With the only_choice method we take a look at the list of possible values for every square in the diagonals
+   and see if there is one number that can only be placed in one square. If its the case we assign this number as the
+   only solution for this square (and eliminate again).
 
 ### Install
 
 This project requires **Python 3**.
 
-We recommend students install [Anaconda](https://www.continuum.io/downloads), a pre-packaged Python distribution that contains all of the necessary libraries and software for this project. 
+We recommend students install [Anaconda](https://www.continuum.io/downloads), a pre-packaged Python distribution that contains all of the necessary libraries and software for this project.
 Please try using the environment we provided in the Anaconda lesson of the Nanodegree.
 
 ##### Optional: Pygame
@@ -35,4 +41,4 @@ To visualize your solution, please only assign values to the values_dict using t
 
 ### Data
 
-The data consists of a text file of diagonal sudokus for you to solve.
+The data consists of a text file of diagonal sudokus for you to solve.

solution.py

@@ -1,3 +1,24 @@
+# board setup
+
+rows = 'ABCDEFGHI'
+cols = '123456789'
+
+def cross(A, B):
+    "Cross product of elements in A and elements in B."
+    return [s+t for s in A for t in B]
+
+boxes = cross(rows, cols)
+
+row_units = [cross(r, cols) for r in rows]
+column_units = [cross(rows, c) for c in cols]
+square_units = [cross(rs, cs) for rs in ('ABC','DEF','GHI') for cs in ('123','456','789')]
+diagonal_units = [[(rows[i] + cols[i]) for i in range(9)], [(rows[::-1][i] + cols[i]) for i in range(9)]]
+unitlist = row_units + column_units + square_units + diagonal_units
+units = dict((s, [u for u in unitlist if s in u]) for s in boxes)
+peers = dict((s, set(sum(units[s],[]))-set([s])) for s in boxes)
+
+# board functionality
+
 assignments = []
 
 def assign_value(values, box, value):
@@ -22,41 +43,137 @@ def naked_twins(values):
     # Find all instances of naked twins
     # Eliminate the naked twins as possibilities for their peers
 
-def cross(A, B):
-    "Cross product of elements in A and elements in B."
-    pass
+    for unit in unitlist:
+        for box in unit:
+            if len(values[box]) == 2:
+                # check if there is a naked twin
+                naked_twins = False
+                other_boxes = unit.copy()
+                other_boxes.remove(box)
+                for other_box in other_boxes:
+                    if values[other_box] == values[box]:
+                        naked_twins = True
+                # eliminate other occurences if naked twin is present
+                if naked_twins:
+                    for other_box in other_boxes:
+                        if values[other_box] != values[box]:
+                            new_value = values[other_box].replace(values[box][0], '').replace(values[box][1], '')
+                            values = assign_value(values, other_box, new_value)
+
+    return values
+
 
 def grid_values(grid):
     """
     Convert grid into a dict of {square: char} with '123456789' for empties.
-    Args:
-        grid(string) - A grid in string form.
-    Returns:
-        A grid in dictionary form
+    Input: A grid in string form.
+    Output: A grid in dictionary form
             Keys: The boxes, e.g., 'A1'
             Values: The value in each box, e.g., '8'. If the box has no value, then the value will be '123456789'.
     """
-    pass
+    chars = []
+    digits = '123456789'
+    for c in grid:
+        if c in digits:
+            chars.append(c)
+        if c == '.':
+            chars.append(digits)
+    assert len(chars) == 81
+    return dict(zip(boxes, chars))
 
 def display(values):
     """
     Display the values as a 2-D grid.
-    Args:
-        values(dict): The sudoku in dictionary form
+    Input: The sudoku in dictionary form
+    Output: None
     """
-    pass
+    width = 1+max(len(values[s]) for s in boxes)
+    line = '+'.join(['-'*(width*3)]*3)
+    for r in rows:
+        print(''.join(values[r+c].center(width)+('|' if c in '36' else '')
+                      for c in cols))
+        if r in 'CF': print(line)
+    print
 
 def eliminate(values):
-    pass
+    """
+    Go through all the boxes, and whenever there is a box with a value, eliminate this value from the values of all its peers.
+    Input: A sudoku in dictionary form.
+    Output: The resulting sudoku in dictionary form.
+    """
+    for key, val in values.items():
+        if len(val) == 1:
+            for peer in peers[key]:
+                if (isinstance(values[peer], str) and val in values[peer]):
+                    values = assign_value(values, peer, values[peer].replace(val, ""))
+    return values
 
 def only_choice(values):
-    pass
+    """
+    Go through all the units, and whenever there is a unit with a value that only fits in one box, assign the value to this box.
+    Input: A sudoku in dictionary form.
+    Output: The resulting sudoku in dictionary form.
+    """
+    new_values = values.copy()
+
+    for unit in unitlist: # iterate over all units
+        for box in unit: # check every box in the unit
+            other_boxes = unit.copy()
+            other_boxes.remove(box)
+            if len(values[box]) > 1: # only check not already solved boxes
+                for num in values[box]: # for every number in that box
+                    other_boxes_with_num = 0
+                    for other_box in other_boxes: # check occurences in other boxes
+                        if num in values[other_box]:
+                            other_boxes_with_num += 1
+                    if other_boxes_with_num == 0: # if number was in no other box, assign number
+                        new_values = assign_value(new_values, box, num)
+
+    return new_values
 
 def reduce_puzzle(values):
-    pass
+    """
+    Iterate eliminate() and only_choice(). If at some point, there is a box with no available values, return False.
+    If the sudoku is solved, return the sudoku.
+    If after an iteration of both functions, the sudoku remains the same, return the sudoku.
+    Input: A sudoku in dictionary form.
+    Output: The resulting sudoku in dictionary form.
+    """
+    solved_values = [box for box in values.keys() if len(values[box]) == 1]
+    stalled = False
+    while not stalled:
+        solved_values_before = len([box for box in values.keys() if len(values[box]) == 1])
+        values = eliminate(values)
+        values = only_choice(values)
+        solved_values_after = len([box for box in values.keys() if len(values[box]) == 1])
+        stalled = solved_values_before == solved_values_after
+        if len([box for box in values.keys() if len(values[box]) == 0]):
+            return False
+    return values
 
 def search(values):
-    pass
+    "Using depth-first search and propagation, create a search tree and solve the sudoku."
+    # First, reduce the puzzle using the previous function
+    values = reduce_puzzle(values)
+
+    if not values:
+        return False
+    if all(len(values[s]) == 1 for s in boxes):
+        return values ## Solved!
+
+    # Choose one of the unfilled squares with the fewest possibilities
+    fewest_possibilities = {'square': 'A1', 'possibilites': 10}
+    for key, val in values.items():
+        if len(val) > 1 and len(val) < fewest_possibilities['possibilites']:
+            fewest_possibilities = {'square': key, 'possibilites': len(val)}
+
+    # Now use recursion to solve each one of the resulting sudokus, and if one returns a value (not False), return that answer!
+    for num in values[fewest_possibilities['square']]:
+        new_values = values.copy()
+        new_values[fewest_possibilities['square']] = num
+        result = search(new_values)
+        if result:
+            return result
 
 def solve(grid):
     """
@@ -68,6 +185,13 @@ def solve(grid):
         The dictionary representation of the final sudoku grid. False if no solution exists.
     """
 
+    values = grid_values(grid)
+    result = search(values)
+    return result
+
+
+
+
 if __name__ == '__main__':
     diag_sudoku_grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
     display(solve(diag_sudoku_grid))