Enhance readability of N Queens

Author: Hardvan

Diff for: backtracking/n_queens.py

@@ -9,6 +9,7 @@
 """
 from __future__ import annotations
 
+# Create a list to store solutions
 solution = []
 
 
@@ -17,50 +18,56 @@ def is_safe(board: list[list[int]], row: int, column: int) -> bool:
     This function returns a boolean value True if it is safe to place a queen there
     considering the current state of the board.
 
-    Parameters :
-    board(2D matrix) : board
-    row ,column : coordinates of the cell on a board
+    Parameters:
+    board (2D matrix): The chessboard
+    row, column: Coordinates of the cell on the board
 
-    Returns :
+    Returns:
     Boolean Value
 
     """
-    for i in range(len(board)):
+    
+    n = len(board) # Size of the board
+    
+    # Check if there is any queen in the same row
+    for i in range(n):
         if board[row][i] == 1:
             return False
-    for i in range(len(board)):
+    # Check if there is any queen in the same column
+    for i in range(n):
         if board[i][column] == 1:
             return False
+    # Check if there is any queen in the left upper diagonal
     for i, j in zip(range(row, -1, -1), range(column, -1, -1)):
         if board[i][j] == 1:
             return False
-    for i, j in zip(range(row, -1, -1), range(column, len(board))):
+    # Check if there is any queen in the right upper diagonal
+    for i, j in zip(range(row, -1, -1), range(column, n)):
         if board[i][j] == 1:
             return False
     return True
 
 
 def solve(board: list[list[int]], row: int) -> bool:
     """
-    It creates a state space tree and calls the safe function until it receives a
+    This function creates a state space tree and calls the safe function until it receives a
     False Boolean and terminates that branch and backtracks to the next
     possible solution branch.
     """
     if row >= len(board):
         """
-        If the row number exceeds N we have board with a successful combination
+        If the row number exceeds N, we have a board with a successful combination
         and that combination is appended to the solution list and the board is printed.
-
         """
         solution.append(board)
         printboard(board)
         print()
         return True
     for i in range(len(board)):
         """
-        For every row it iterates through each column to check if it is feasible to
+        For every row, it iterates through each column to check if it is feasible to
         place a queen there.
-        If all the combinations for that particular branch are successful the board is
+        If all the combinations for that particular branch are successful, the board is
         reinitialized for the next possible combination.
         """
         if is_safe(board, row, i):
@@ -77,14 +84,14 @@ def printboard(board: list[list[int]]) -> None:
     for i in range(len(board)):
         for j in range(len(board)):
             if board[i][j] == 1:
-                print("Q", end=" ")
+                print("Q", end=" ")  # Queen is present
             else:
-                print(".", end=" ")
+                print(".", end=" ")  # Empty cell
         print()
 
 
-# n=int(input("The no. of queens"))
+# Number of queens (e.g., n=8 for an 8x8 board)
 n = 8
 board = [[0 for i in range(n)] for j in range(n)]
 solve(board, 0)
-print("The total no. of solutions are :", len(solution))
+print("The total number of solutions are:", len(solution))