Fix Checkstyle violations and improve setScores validation

- Replace star imports with explicit imports in test file
- Remove trailing whitespaces from all lines
- Add proper file ending newline
- Improve setScores method to handle edge cases properly
- Use direct bit manipulation for power-of-2 check as suggested
- Ensure error message is printed and scores remain unchanged for invalid input

All Checkstyle violations resolved and tests pass successfully.

Author: yashsaha555

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

@@ -115,12 +115,12 @@ private boolean isPowerOfTwo(int n) {
     }
 
     public void setScores(int[] scores) {
-        if (isPowerOfTwo(scores.length)) {
-            this.scores = scores;
-            height = log2(this.scores.length);
-        } else {
+        if (scores.length <= 0 || (scores.length & (scores.length - 1)) != 0) {
             System.out.println("The number of scores must be a power of 2.");
+            return;
         }
+        this.scores = scores;
+        height = log2(this.scores.length);
     }
 
     public int[] getScores() {

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

@@ -2,7 +2,10 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -28,7 +31,7 @@ void testConstructorCreatesValidScores() {
         // The default constructor should create scores array of length 8 (2^3)
         assertEquals(8, miniMax.getScores().length);
         assertEquals(3, miniMax.getHeight());
-        
+
         // All scores should be positive (between 1 and 99)
         for (int score : miniMax.getScores()) {
             assertTrue(score >= 1 && score <= 99);
@@ -39,7 +42,7 @@ void testConstructorCreatesValidScores() {
     void testSetScoresWithValidPowerOfTwo() {
         int[] validScores = {10, 20, 30, 40};
         miniMax.setScores(validScores);
-        
+
         assertArrayEquals(validScores, miniMax.getScores());
         assertEquals(2, miniMax.getHeight()); // log2(4) = 2
     }
@@ -48,11 +51,11 @@ void testSetScoresWithValidPowerOfTwo() {
     void testSetScoresWithInvalidLength() {
         int[] invalidScores = {10, 20, 30}; // Length 3 is not a power of 2
         miniMax.setScores(invalidScores);
-        
+
         // Should print error message and not change the scores
         String output = outputStream.toString();
         assertTrue(output.contains("The number of scores must be a power of 2."));
-        
+
         // Scores should remain unchanged (original length 8)
         assertEquals(8, miniMax.getScores().length);
     }
@@ -61,7 +64,7 @@ void testSetScoresWithInvalidLength() {
     void testSetScoresWithSingleElement() {
         int[] singleScore = {42};
         miniMax.setScores(singleScore);
-        
+
         assertArrayEquals(singleScore, miniMax.getScores());
         assertEquals(0, miniMax.getHeight()); // log2(1) = 0
     }
@@ -71,7 +74,7 @@ void testMiniMaxWithKnownScores() {
         // Test with a known game tree: [3, 12, 8, 2]
         int[] testScores = {3, 12, 8, 2};
         miniMax.setScores(testScores);
-        
+
         // Maximizer starts: should choose max(min(3,12), min(8,2)) = max(3, 2) = 3
         int result = miniMax.miniMax(0, true, 0, false);
         assertEquals(3, result);
@@ -82,7 +85,7 @@ void testMiniMaxWithMinimizerFirst() {
         // Test with minimizer starting first
         int[] testScores = {3, 12, 8, 2};
         miniMax.setScores(testScores);
-        
+
         // Minimizer starts: should choose min(max(3,12), max(8,2)) = min(12, 8) = 8
         int result = miniMax.miniMax(0, false, 0, false);
         assertEquals(8, result);
@@ -93,10 +96,10 @@ void testMiniMaxWithLargerTree() {
         // Test with 8 elements: [5, 6, 7, 4, 5, 3, 6, 2]
         int[] testScores = {5, 6, 7, 4, 5, 3, 6, 2};
         miniMax.setScores(testScores);
-        
+
         // Maximizer starts
         int result = miniMax.miniMax(0, true, 0, false);
-        // Expected: max(min(max(5,6), max(7,4)), min(max(5,3), max(6,2))) 
+        // Expected: max(min(max(5,6), max(7,4)), min(max(5,3), max(6,2)))
         //         = max(min(6, 7), min(5, 6)) = max(6, 5) = 6
         assertEquals(6, result);
     }
@@ -105,9 +108,9 @@ void testMiniMaxWithLargerTree() {
     void testMiniMaxVerboseOutput() {
         int[] testScores = {3, 12, 8, 2};
         miniMax.setScores(testScores);
-        
+
         miniMax.miniMax(0, true, 0, true);
-        
+
         String output = outputStream.toString();
         assertTrue(output.contains("Maximizer"));
         assertTrue(output.contains("Minimizer"));
@@ -118,7 +121,7 @@ void testMiniMaxVerboseOutput() {
     void testGetRandomScoresLength() {
         int[] randomScores = MiniMaxAlgorithm.getRandomScores(4, 50);
         assertEquals(16, randomScores.length); // 2^4 = 16
-        
+
         // All scores should be between 1 and 50
         for (int score : randomScores) {
             assertTrue(score >= 1 && score <= 50);
@@ -129,7 +132,7 @@ void testGetRandomScoresLength() {
     void testGetRandomScoresWithDifferentParameters() {
         int[] randomScores = MiniMaxAlgorithm.getRandomScores(2, 10);
         assertEquals(4, randomScores.length); // 2^2 = 4
-        
+
         // All scores should be between 1 and 10
         for (int score : randomScores) {
             assertTrue(score >= 1 && score <= 10);
@@ -140,7 +143,7 @@ void testGetRandomScoresWithDifferentParameters() {
     void testMainMethod() {
         // Test that main method runs without errors
         assertDoesNotThrow(() -> MiniMaxAlgorithm.main(new String[]{}));
-        
+
         String output = outputStream.toString();
         assertTrue(output.contains("The best score for"));
         assertTrue(output.contains("Maximizer"));
@@ -152,7 +155,7 @@ void testHeightCalculation() {
         int[] scores2 = {1, 2};
         miniMax.setScores(scores2);
         assertEquals(1, miniMax.getHeight()); // log2(2) = 1
-        
+
         int[] scores16 = new int[16];
         miniMax.setScores(scores16);
         assertEquals(4, miniMax.getHeight()); // log2(16) = 4
@@ -162,7 +165,7 @@ void testHeightCalculation() {
     void testEdgeCaseWithZeroScores() {
         int[] zeroScores = {0, 0, 0, 0};
         miniMax.setScores(zeroScores);
-        
+
         int result = miniMax.miniMax(0, true, 0, false);
         assertEquals(0, result);
     }
@@ -171,7 +174,7 @@ void testEdgeCaseWithZeroScores() {
     void testEdgeCaseWithNegativeScores() {
         int[] negativeScores = {-5, -2, -8, -1};
         miniMax.setScores(negativeScores);
-        
+
         // Tree evaluation with maximizer first:
         // Level 1 (minimizer): min(-5,-2) = -5, min(-8,-1) = -8
         // Level 0 (maximizer): max(-5, -8) = -5