Removed some extraneous code

Author: calebmadrigal

nqueens.py

@@ -1,4 +1,4 @@
-""" N-Queens solutions. """
+""" Backtracking solution to N-Queens problem. """
 
 __author__ = "Caleb Madrigal"
 __date__ = "2015-02-19"
@@ -22,25 +22,23 @@ def right_to_left_diagonals_valid(board):
      [ 56.  57.  58.  59.  60.  61.  62.  63.]]
 
     It checks right-to-left columns in 2 steps:
-    * First, it checks each right-to-left diagonal that begins with each element on the first row
+    * Step 1: it checks each right-to-left diagonal that begins with each element on the first row
       (skipping the first index, since that "diagonal" is just element[0]) So the indices
       of each start of each row-based diagonal are: 1, 2, 3, 4, 5, 6, 7. In order to find the
       indices of each subsequent element in each diagonal, it adds (size-1) to the initial
       diagonal. For example: if we are checking the right-to-left diagonal starting with index 2,
       the diagonal should be indices: 2, 9, 16 (each is separated by 7). In order to perform
       this math, the nxn matrix is flattened.
-    * Second, it does roughly the same thing for the right-to-left diagonals that start on the
+    * Step 2: it does roughly the same thing for the right-to-left diagonals that start on the
       far-right column (indices 15, 23, 31, 39, 47, 55, 63). """
 
     size = len(board)
     flat = board.reshape((1, size*size))[0]
-    # Check right-to-left diagonals
+
     for row_index in range(1, size):
-        #print("row_index:", row_index)
         index = row_index
         diag_sum = 0
         for diag_index in range(row_index+1):
-            #print("\tdiag_index: {0}, value: {1}".format(index, flat[index]))
             diag_sum += flat[index]
             index += (size - 1)
         if diag_sum > 1:
@@ -49,13 +47,11 @@ def right_to_left_diagonals_valid(board):
     col_diag_index = 0
     diag_lengths = list(range(size-1, 0, -1))
     for last_col_index in range(2*size-1, size*size-1, size):
-        #print("col_index:", last_col_index)
         index = last_col_index
         diag_sum = 0
         diag_len = diag_lengths[col_diag_index]
         col_diag_index += 1
         for diag_index in range(diag_len):
-            #print("\tdiag_index: {0}, value: {1}".format(index, flat[index]))
             diag_sum += flat[index]
             index += (size - 1)
         if diag_sum > 1:
@@ -80,43 +76,15 @@ def diags_valid(board):
     return right_to_left_diagonals_valid(board) and left_to_right_diagonals_valid(board)
 
 
-def rows_valid(board):
-    """ Returns True if there are no more than 1 "1" in any row; else False. """
-
-    for row in board:
-        if np.sum(row) > 1:
-            return False
-    return True
-
-
-def cols_valid(board):
-    """ Returns True if there are no more than 1 "1" in any column; else False. """
-
-    for col_index in range(len(board)):
-        if np.sum(board[:, col_index]) > 1:
-            return False
-    return True
-
-
-def is_valid(board):
-    """ Returns True if there are no more than 1 "1" in any row, column, or diagonal;
-    Else, it returns False. """
-
-    # We only have to check that the diagonals are valid, since the search
-    # algorithm doesn't put more than 1 queen on a given row or column
-    #return rows_valid(board) and cols_valid(board) and diags_valid(board)
-    return diags_valid(board)
-
-
 def print_board_indented(board, row):
     print('\t'*row + str(board).replace('\n', '\n'+('\t'*row)))
 
 
 def search(board, row=0, cols_taken=()):
-    """ In-place search for solution to n-queens. """
+    """ In-place search for solution to n-queens. Backtracking algorithm. """
 
     # Return if we are at the maximum depth and the solution is valid
-    if row == len(board) and is_valid(board):
+    if row == len(board) and diags_valid(board):
         return True
 
     # Otherwise, try each column and recursively work down the rows
@@ -127,7 +95,7 @@ def search(board, row=0, cols_taken=()):
         board[row][col] = 1
         print_board_indented(board, row)
 
-        if is_valid(board):
+        if diags_valid(board):
             if search(board, row+1, cols_taken + (col,)):
                 return True
             else:
@@ -149,3 +117,4 @@ def n_queens(size):
 if __name__ == '__main__':
     board_size = 8
     n_queens(board_size)
+

test/test_nqueens.py

@@ -9,29 +9,6 @@
 
 class NQueensTest(unittest.TestCase):
 
-    def testRowsValid(self):
-        zero_board = np.zeros((3, 3))
-        self.assertTrue(nqueens.rows_valid(zero_board))
-
-        bad_board = np.array([[1, 0, 1], [0, 0, 0], [0, 0, 0]])
-        self.assertFalse(nqueens.rows_valid(bad_board))
-
-        bad_board2 = np.array([[1, 0, 0], [0, 0, 0], [0, 1, 1]])
-        self.assertFalse(nqueens.rows_valid(bad_board2))
-
-        rows_good_board = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
-        self.assertTrue(nqueens.rows_valid(rows_good_board))
-
-        rows_good_board2 = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
-        self.assertTrue(nqueens.rows_valid(rows_good_board2))
-
-    def testColsValid(self):
-        good_board = np.zeros((3, 3))
-        self.assertTrue(nqueens.cols_valid(good_board))
-
-        bad_board = np.array([[0, 0, 0], [0, 1, 0], [0, 1, 0]])
-        self.assertFalse(nqueens.cols_valid(bad_board))
-
     def testDiagsValid(self):
         good_board = np.array([[0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 0]])
         self.assertTrue(nqueens.diags_valid(good_board))
@@ -42,10 +19,6 @@ def testDiagsValid(self):
         bad_board2 = np.array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
         self.assertFalse(nqueens.diags_valid(bad_board2))
 
-    def testBoardValid(self):
-        good_board = np.array([[0, 1, 0, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 0, 1, 0]])
-        self.assertTrue(nqueens.is_valid(good_board))
-        
 if __name__ == '__main__':
     unittest.main()