fix(MiniMaxAlgorithm): correct power-of-2 validation and log2 handling, add tests

Author: Harsh Dubey

src/main/java/com/thealgorithms/others/MiniMaxAlgorithm.java

@@ -4,7 +4,7 @@
 import java.util.Random;
 
 /**
- * MiniMax is an algorithm used int artificial intelligence and game theory for
+ * MiniMax is an algorithm used in artificial intelligence and game theory for
  * minimizing the possible loss for the worst case scenario.
  *
  * See more (https://en.wikipedia.org/wiki/Minimax,
@@ -74,22 +74,18 @@ public int miniMax(int depth, boolean isMaximizer, int index, boolean verbose) {
             bestScore = Math.min(score1, score2);
         }
 
-        // Leaf nodes can be sequentially inspected by
-        // recurssively multiplying (0 * 2) and ((0 * 2) + 1):
-        // (0 x 2) = 0; ((0 x 2) + 1) = 1
-        // (1 x 2) = 2; ((1 x 2) + 1) = 3
-        // (2 x 2) = 4; ((2 x 2) + 1) = 5 ...
         if (verbose) {
-            System.out.printf("From %02d and %02d, %s chooses %02d%n", score1, score2, (isMaximizer ? "Maximizer" : "Minimizer"), bestScore);
+            System.out.printf("From %02d and %02d, %s chooses %02d%n",
+                    score1, score2, (isMaximizer ? "Maximizer" : "Minimizer"), bestScore);
         }
 
         return bestScore;
     }
 
     /**
-     * Returns an array of random numbers which lenght is a power of 2.
+     * Returns an array of random numbers whose length is a power of 2.
      *
-     * @param size The power of 2 that will determine the lenght of the array.
+     * @param size The power of 2 that will determine the length of the array.
      * @param maxScore The maximum possible score.
      * @return An array of random numbers.
      */
@@ -104,17 +100,29 @@ public static int[] getRandomScores(int size, int maxScore) {
         return randomScores;
     }
 
-    // A utility function to find Log n in base 2
+    // A utility function to find log2(n)
     private int log2(int n) {
-        return (n == 1) ? 0 : log2(n / 2) + 1;
+        if (n <= 0) {
+            throw new IllegalArgumentException("Input must be a positive integer.");
+        }
+        return (n == 1) ? 0 : 1 + log2(n / 2);
     }
 
+    /**
+     * Sets the scores array if its length is a power of 2, otherwise throws exception.
+     *
+     * @param scores input array of scores
+     */
     public void setScores(int[] scores) {
-        if (scores.length % 1 == 0) {
+        if (scores == null || scores.length == 0) {
+            throw new IllegalArgumentException("Scores array cannot be null or empty.");
+        }
+        // Check if length is power of 2 using bitwise trick
+        if ((scores.length & (scores.length - 1)) == 0) {
             this.scores = scores;
             height = log2(this.scores.length);
         } else {
-            System.out.println("The number of scores must be a power of 2.");
+            throw new IllegalArgumentException("The number of scores must be a power of 2.");
         }
     }
 

src/test/java/com/thealgorithms/others/MiniMaxAlgorithmTest.java

@@ -0,0 +1,81 @@
+package com.thealgorithms.others;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class MiniMaxAlgorithmTest {
+
+    private MiniMaxAlgorithm miniMax;
+
+    @BeforeEach
+    void setUp() {
+        miniMax = new MiniMaxAlgorithm();
+    }
+
+    @Test
+    void testRandomScoresLengthIsPowerOfTwo() {
+        int[] scores = MiniMaxAlgorithm.getRandomScores(3, 100); // 2^3 = 8
+        assertEquals(8, scores.length);
+    }
+
+    @Test
+    void testSetScoresValidPowerOfTwo() {
+        int[] validScores = {1, 2, 3, 4};
+        miniMax.setScores(validScores);
+        assertArrayEquals(validScores, miniMax.getScores());
+        assertEquals(2, miniMax.getHeight()); // log2(4) = 2
+    }
+
+    @Test
+    void testSetScoresInvalidLengthThrowsException() {
+        int[] invalidScores = {1, 2, 3}; // length 3, not a power of 2
+        assertThrows(IllegalArgumentException.class, () -> miniMax.setScores(invalidScores));
+    }
+
+    @Test
+    void testSetScoresNullThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> miniMax.setScores(null));
+    }
+
+    @Test
+    void testSetScoresEmptyThrowsException() {
+        assertThrows(IllegalArgumentException.class, () -> miniMax.setScores(new int[]{}));
+    }
+
+    @Test
+    void testLog2ValidInputs() {
+        // indirectly tested through setScores, but also test directly
+        assertEquals(0, invokeLog2(1));
+        assertEquals(1, invokeLog2(2));
+        assertEquals(2, invokeLog2(4));
+        assertEquals(3, invokeLog2(8));
+    }
+
+    @Test
+    void testLog2InvalidInputs() {
+        assertThrows(IllegalArgumentException.class, () -> invokeLog2(0));
+        assertThrows(IllegalArgumentException.class, () -> invokeLog2(-4));
+    }
+
+    @Test
+    void testMiniMaxComputation() {
+        int[] customScores = {3, 5, 2, 9}; // Tree height = 2
+        miniMax.setScores(customScores);
+        int bestScore = miniMax.miniMax(0, true, 0, false);
+        assertEquals(5, bestScore); // Correct result from minimax
+    }
+
+    // Utility to call private log2 method using reflection
+    private int invokeLog2(int n) {
+        try {
+            var method = MiniMaxAlgorithm.class.getDeclaredMethod("log2", int.class);
+            method.setAccessible(true);
+            return (int) method.invoke(miniMax, n);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}