Fixing tests

Author: Prateek Khandelwal

machine_learning/minimax.py

@@ -3,14 +3,19 @@
 
 def minimax(depth, node_index, is_maximizing_player, scores, height):
     """
-    Minimax algorithm to determine the optimal move for a player in a two-player zero-sum game.
+    Minimax algorithm to determine the optimal move for a player in a two-player 
+    zero-sum game.
 
     Parameters:
     - depth (int): Current depth in the game tree. Used to track recursion level.
-    - node_index (int): Index of the current node in the scores array, representing leaf nodes.
-    - is_maximizing_player (bool): True if the current player is the maximizing player, False otherwise.
-    - scores (list): A list of integers representing the scores at the leaf nodes of the game tree.
-    - height (int): The maximum depth of the game tree, based on the number of leaf nodes in a binary structure.
+    - node_index (int): Index of the current node in the scores array, representing 
+    leaf nodes.
+    - is_maximizing_player (bool): True if the current player is the maximizing player
+    , False otherwise.
+    - scores (list): A list of integers representing the scores at the leaf nodes 
+    of the game tree.
+    - height (int): The maximum depth of the game tree, based on the number of leaf 
+    nodes in a binary structure.
 
     Returns:
     - int: The best score that the current player can achieve from this node.
@@ -51,7 +56,8 @@ def main():
 
     # Print the optimal outcome for the maximizing player
     print(
-        "Optimal value for the maximizing player:", minimax(0, 0, True, scores, height)
+        "Optimal value for the maximizing player:", 
+        minimax(0, 0, True, scores, height)
     )
 
 

machine_learning/minimax_alpha_beta_pruning.py

@@ -1,20 +1,25 @@
 import math
 
-
-def minimax_with_pruning(
-    depth, node_index, is_maximizing_player, scores, height, alpha, beta
-):
+def minimax_with_pruning(depth, node_index, is_maximizing_player, scores,
+                          height, alpha, beta):
     """
-    Minimax algorithm with alpha-beta pruning to determine the optimal move with improved efficiency.
-
+    Minimax algorithm with alpha-beta pruning to determine the optimal 
+    move with improved efficiency.
+    
     Parameters:
     - depth (int): Current depth in the game tree, used to track recursion level.
-    - node_index (int): Index of the current node in the scores array, representing leaf nodes.
-    - is_maximizing_player (bool): True if the current player is the maximizing player, False otherwise.
-    - scores (list): A list of integers representing the scores at the leaf nodes of the game tree.
-    - height (int): The maximum depth of the game tree, based on the number of leaf nodes in a binary structure.
-    - alpha (int): The best value that the maximizer can guarantee at the current level or above.
-    - beta (int): The best value that the minimizer can guarantee at the current level or above.
+    - node_index (int): Index of the current node in the scores array, representing 
+    leaf nodes.
+    - is_maximizing_player (bool): True if the current player is the maximizing player
+    , False otherwise.
+    - scores (list): A list of integers representing the scores at the 
+    leaf nodes of the game tree.
+    - height (int): The maximum depth of the game tree, based on the number of 
+    leaf nodes in a binary structure.
+    - alpha (int): The best value that the maximizer can guarantee at the 
+    current level or above.
+    - beta (int): The best value that the minimizer can guarantee at the 
+    current level or above.
 
     Returns:
     - int: The best score that the current player can achieve from this node.
@@ -27,9 +32,8 @@ def minimax_with_pruning(
     if is_maximizing_player:
         best_score = -math.inf  # Start with the worst possible score for maximizer
         for i in range(2):  # Two branches at each level in binary tree
-            val = minimax_with_pruning(
-                depth + 1, node_index * 2 + i, False, scores, height, alpha, beta
-            )
+            val = minimax_with_pruning(depth + 1, node_index * 2 + i, 
+                                       False, scores, height, alpha, beta)
             best_score = max(best_score, val)  # Maximizer selects the maximum value
             alpha = max(alpha, best_score)  # Update alpha (best option for maximizer)
             if beta <= alpha:
@@ -40,9 +44,8 @@ def minimax_with_pruning(
     else:
         best_score = math.inf  # Start with the worst possible score for minimizer
         for i in range(2):
-            val = minimax_with_pruning(
-                depth + 1, node_index * 2 + i, True, scores, height, alpha, beta
-            )
+            val = minimax_with_pruning(depth + 1, node_index * 2 + i, True, 
+                                       scores, height, alpha, beta)
             best_score = min(best_score, val)  # Minimizer selects the minimum value
             beta = min(beta, best_score)  # Update beta (best option for minimizer)
             if beta <= alpha:
@@ -57,11 +60,8 @@ def main():
     height = math.ceil(math.log2(len(scores)))
 
     # Print the optimal outcome for the maximizing player with alpha-beta pruning
-    print(
-        "Optimal value for the maximizing player with pruning:",
-        minimax_with_pruning(0, 0, True, scores, height, -math.inf, math.inf),
-    )
-
+    print("Optimal value for the maximizing player with pruning:", 
+          minimax_with_pruning(0, 0, True, scores, height, -math.inf, math.inf))
 
 if __name__ == "__main__":
     main()