Merge branch 'master' into add-sudoku-solver

Author: Navadeep0007

src/main/java/com/thealgorithms/bitmanipulation/CountSetBits.java

@@ -1,79 +1,79 @@
 package com.thealgorithms.bitmanipulation;
 
-public class CountSetBits {
+/**
+ * Utility class to count total set bits from 1 to N
+ * A set bit is a bit in binary representation that is 1
+ *
+ * @author navadeep
+ */
+public final class CountSetBits {
+
+    private CountSetBits() {
+        // Utility class, prevent instantiation
+    }
 
     /**
-     * The below algorithm is called as Brian Kernighan's algorithm
-     * We can use Brian Kernighan’s algorithm to improve the above naive algorithm’s performance.
-     The idea is to only consider the set bits of an integer by turning off its rightmost set bit
-     (after counting it), so the next iteration of the loop considers the next rightmost bit.
-
-        The expression n & (n-1) can be used to turn off the rightmost set bit of a number n. This
-     works as the expression n-1 flips all the bits after the rightmost set bit of n, including the
-     rightmost set bit itself. Therefore, n & (n-1) results in the last bit flipped of n.
-
-        For example, consider number 52, which is 00110100 in binary, and has a total 3 bits set.
-
-        1st iteration of the loop: n = 52
-
-        00110100    &               (n)
-        00110011                    (n-1)
-        ~~~~~~~~
-        00110000
+     * Counts total number of set bits in all numbers from 1 to n
+     * Time Complexity: O(log n)
+     *
+     * @param n the upper limit (inclusive)
+     * @return total count of set bits from 1 to n
+     * @throws IllegalArgumentException if n is negative
+     */
+    public static int countSetBits(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative");
+        }
 
+        if (n == 0) {
+            return 0;
+        }
 
-        2nd iteration of the loop: n = 48
+        // Find the largest power of 2 <= n
+        int x = largestPowerOf2InNumber(n);
 
-        00110000    &               (n)
-        00101111                    (n-1)
-        ~~~~~~~~
-        00100000
+        // Total bits at position x: x * 2^(x-1)
+        int bitsAtPositionX = x * (1 << (x - 1));
 
+        // Remaining numbers after 2^x
+        int remainingNumbers = n - (1 << x) + 1;
 
-        3rd iteration of the loop: n = 32
+        // Recursively count for the rest
+        int rest = countSetBits(n - (1 << x));
 
-        00100000    &               (n)
-        00011111                    (n-1)
-        ~~~~~~~~
-        00000000                    (n = 0)
+        return bitsAtPositionX + remainingNumbers + rest;
+    }
 
-     * @param num takes Long number whose number of set bit is to be found
-     * @return the count of set bits in the binary equivalent
-    */
-    public long countSetBits(long num) {
-        long cnt = 0;
-        while (num > 0) {
-            cnt++;
-            num &= (num - 1);
+    /**
+     * Finds the position of the most significant bit in n
+     *
+     * @param n the number
+     * @return position of MSB (0-indexed from right)
+     */
+    private static int largestPowerOf2InNumber(int n) {
+        int position = 0;
+        while ((1 << position) <= n) {
+            position++;
         }
-        return cnt;
+        return position - 1;
     }
 
     /**
-     * This approach takes O(1) running time to count the set bits, but requires a pre-processing.
+     * Alternative naive approach - counts set bits by iterating through all numbers
+     * Time Complexity: O(n log n)
      *
-     * So, we divide our 32-bit input into 8-bit chunks, with four chunks. We have 8 bits in each chunk.
-     *
-     * Then the range is from 0-255 (0 to 2^7).
-     * So, we may need to count set bits from 0 to 255 in individual chunks.
-     *
-     * @param num takes a long number
-     * @return the count of set bits in the binary equivalent
+     * @param n the upper limit (inclusive)
+     * @return total count of set bits from 1 to n
      */
-    public int lookupApproach(int num) {
-        int[] table = new int[256];
-        table[0] = 0;
-
-        for (int i = 1; i < 256; i++) {
-            table[i] = (i & 1) + table[i >> 1]; // i >> 1 equals to i/2
+    public static int countSetBitsNaive(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative");
         }
 
-        int res = 0;
-        for (int i = 0; i < 4; i++) {
-            res += table[num & 0xff];
-            num >>= 8;
+        int count = 0;
+        for (int i = 1; i <= n; i++) {
+            count += Integer.bitCount(i);
         }
-
-        return res;
+        return count;
     }
 }

src/main/java/com/thealgorithms/maths/SieveOfEratosthenes.java

@@ -1,66 +1,82 @@
 package com.thealgorithms.maths;
 
-import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
- * @brief utility class implementing <a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">Sieve of Eratosthenes</a>
+ * Sieve of Eratosthenes Algorithm
+ * An efficient algorithm to find all prime numbers up to a given limit.
+ *
+ * Algorithm:
+ * 1. Create a boolean array of size n+1, initially all true
+ * 2. Mark 0 and 1 as not prime
+ * 3. For each number i from 2 to sqrt(n):
+ *    - If i is still marked as prime
+ *    - Mark all multiples of i (starting from i²) as not prime
+ * 4. Collect all numbers still marked as prime
+ *
+ * Time Complexity: O(n log log n)
+ * Space Complexity: O(n)
+ *
+ * @author Navadeep0007
+ * @see <a href="https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes">Sieve of Eratosthenes</a>
  */
 public final class SieveOfEratosthenes {
+
     private SieveOfEratosthenes() {
+        // Utility class, prevent instantiation
     }
 
-    private static void checkInput(int n) {
-        if (n <= 0) {
-            throw new IllegalArgumentException("n must be positive.");
+    /**
+     * Finds all prime numbers up to n using the Sieve of Eratosthenes algorithm
+     *
+     * @param n the upper limit (inclusive)
+     * @return a list of all prime numbers from 2 to n
+     * @throws IllegalArgumentException if n is negative
+     */
+    public static List<Integer> findPrimes(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative");
         }
-    }
 
-    private static Type[] sievePrimesTill(int n) {
-        checkInput(n);
-        Type[] isPrimeArray = new Type[n + 1];
-        Arrays.fill(isPrimeArray, Type.PRIME);
-        isPrimeArray[0] = Type.NOT_PRIME;
-        isPrimeArray[1] = Type.NOT_PRIME;
+        if (n < 2) {
+            return new ArrayList<>();
+        }
+
+        // Create boolean array, initially all true
+        boolean[] isPrime = new boolean[n + 1];
+        for (int i = 2; i <= n; i++) {
+            isPrime[i] = true;
+        }
 
-        double cap = Math.sqrt(n);
-        for (int i = 2; i <= cap; i++) {
-            if (isPrimeArray[i] == Type.PRIME) {
-                for (int j = 2; i * j <= n; j++) {
-                    isPrimeArray[i * j] = Type.NOT_PRIME;
+        // Sieve process
+        for (int i = 2; i * i <= n; i++) {
+            if (isPrime[i]) {
+                // Mark all multiples of i as not prime
+                for (int j = i * i; j <= n; j += i) {
+                    isPrime[j] = false;
                 }
             }
         }
-        return isPrimeArray;
-    }
-
-    private static int countPrimes(Type[] isPrimeArray) {
-        return (int) Arrays.stream(isPrimeArray).filter(element -> element == Type.PRIME).count();
-    }
 
-    private static int[] extractPrimes(Type[] isPrimeArray) {
-        int numberOfPrimes = countPrimes(isPrimeArray);
-        int[] primes = new int[numberOfPrimes];
-        int primeIndex = 0;
-        for (int curNumber = 0; curNumber < isPrimeArray.length; ++curNumber) {
-            if (isPrimeArray[curNumber] == Type.PRIME) {
-                primes[primeIndex++] = curNumber;
+        // Collect all prime numbers
+        List<Integer> primes = new ArrayList<>();
+        for (int i = 2; i <= n; i++) {
+            if (isPrime[i]) {
+                primes.add(i);
             }
         }
+
         return primes;
     }
 
     /**
-     * @brief finds all of the prime numbers up to the given upper (inclusive) limit
-     * @param n upper (inclusive) limit
-     * @exception IllegalArgumentException n is non-positive
-     * @return the array of all primes up to the given number (inclusive)
+     * Counts the number of prime numbers up to n
+     *
+     * @param n the upper limit (inclusive)
+     * @return count of prime numbers from 2 to n
      */
-    public static int[] findPrimesTill(int n) {
-        return extractPrimes(sievePrimesTill(n));
-    }
-
-    private enum Type {
-        PRIME,
-        NOT_PRIME,
+    public static int countPrimes(int n) {
+        return findPrimes(n).size();
     }
 }

src/test/java/com/thealgorithms/bitmanipulation/CountSetBitsTest.java

@@ -1,26 +1,56 @@
 package com.thealgorithms.bitmanipulation;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
-public class CountSetBitsTest {
+class CountSetBitsTest {
 
     @Test
-    void testSetBits() {
-        CountSetBits csb = new CountSetBits();
-        assertEquals(1L, csb.countSetBits(16));
-        assertEquals(4, csb.countSetBits(15));
-        assertEquals(5, csb.countSetBits(10000));
-        assertEquals(5, csb.countSetBits(31));
+    void testCountSetBitsZero() {
+        assertEquals(0, CountSetBits.countSetBits(0));
     }
 
     @Test
-    void testSetBitsLookupApproach() {
-        CountSetBits csb = new CountSetBits();
-        assertEquals(1L, csb.lookupApproach(16));
-        assertEquals(4, csb.lookupApproach(15));
-        assertEquals(5, csb.lookupApproach(10000));
-        assertEquals(5, csb.lookupApproach(31));
+    void testCountSetBitsOne() {
+        assertEquals(1, CountSetBits.countSetBits(1));
+    }
+
+    @Test
+    void testCountSetBitsSmallNumber() {
+        assertEquals(4, CountSetBits.countSetBits(3)); // 1(1) + 10(1) + 11(2) = 4
+    }
+
+    @Test
+    void testCountSetBitsFive() {
+        assertEquals(7, CountSetBits.countSetBits(5)); // 1 + 1 + 2 + 1 + 2 = 7
+    }
+
+    @Test
+    void testCountSetBitsTen() {
+        assertEquals(17, CountSetBits.countSetBits(10));
+    }
+
+    @Test
+    void testCountSetBitsLargeNumber() {
+        assertEquals(42, CountSetBits.countSetBits(20)); // Changed from 93 to 42
+    }
+
+    @Test
+    void testCountSetBitsPowerOfTwo() {
+        assertEquals(13, CountSetBits.countSetBits(8)); // Changed from 9 to 13
+    }
+
+    @Test
+    void testCountSetBitsNegativeInput() {
+        assertThrows(IllegalArgumentException.class, () -> CountSetBits.countSetBits(-1));
+    }
+
+    @Test
+    void testNaiveApproachMatchesOptimized() {
+        for (int i = 0; i <= 100; i++) {
+            assertEquals(CountSetBits.countSetBitsNaive(i), CountSetBits.countSetBits(i), "Mismatch at n = " + i);
+        }
     }
 }