fix: remove trailing spaces

Author: Navadeep0007

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

@@ -6,30 +6,30 @@
 /**
  * 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
     }
-    
+
     /**
      * 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
@@ -38,17 +38,17 @@ public static List<Integer> findPrimes(int n) {
         if (n < 0) {
             throw new IllegalArgumentException("Input must be non-negative");
         }
-        
+
         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;
         }
-        
+
         // Sieve process
         for (int i = 2; i * i <= n; i++) {
             if (isPrime[i]) {
@@ -58,21 +58,21 @@ public static List<Integer> findPrimes(int n) {
                 }
             }
         }
-        
+
         // Collect all prime numbers
         List<Integer> primes = new ArrayList<>();
         for (int i = 2; i <= n; i++) {
             if (isPrime[i]) {
                 primes.add(i);
             }
         }
-        
+
         return primes;
     }
-    
+
     /**
      * Counts the number of prime numbers up to n
-     * 
+     *
      * @param n the upper limit (inclusive)
      * @return count of prime numbers from 2 to n
      */

src/test/java/com/thealgorithms/maths/SieveOfEratosthenesTest.java

@@ -10,52 +10,52 @@
 
 /**
  * Test cases for Sieve of Eratosthenes algorithm
- * 
+ *
  * @author Navadeep0007
  */
 class SieveOfEratosthenesTest {
-    
+
     @Test
     void testPrimesUpTo10() {
         List<Integer> expected = Arrays.asList(2, 3, 5, 7);
         assertEquals(expected, SieveOfEratosthenes.findPrimes(10));
     }
-    
+
     @Test
     void testPrimesUpTo30() {
         List<Integer> expected = Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19, 23, 29);
         assertEquals(expected, SieveOfEratosthenes.findPrimes(30));
     }
-    
+
     @Test
     void testPrimesUpTo2() {
         List<Integer> expected = Arrays.asList(2);
         assertEquals(expected, SieveOfEratosthenes.findPrimes(2));
     }
-    
+
     @Test
     void testPrimesUpTo1() {
         assertTrue(SieveOfEratosthenes.findPrimes(1).isEmpty());
     }
-    
+
     @Test
     void testPrimesUpTo0() {
         assertTrue(SieveOfEratosthenes.findPrimes(0).isEmpty());
     }
-    
+
     @Test
     void testNegativeInput() {
         assertThrows(IllegalArgumentException.class, () -> {
             SieveOfEratosthenes.findPrimes(-1);
         });
     }
-    
+
     @Test
     void testCountPrimes() {
         assertEquals(4, SieveOfEratosthenes.countPrimes(10));
         assertEquals(25, SieveOfEratosthenes.countPrimes(100));
     }
-    
+
     @Test
     void testLargeNumber() {
         List<Integer> primes = SieveOfEratosthenes.findPrimes(1000);