ref: optimize implementation a bit more

Author: sozelfist

src/math/sieve_of_eratosthenes.rs

@@ -18,46 +18,49 @@ pub fn sieve_of_eratosthenes(num: usize) -> Vec<usize> {
 
         let end: usize = (num as f64).sqrt() as usize;
 
-        // mark non-prime numbers in the sieve
-        update_sieve(&mut sieve, end, num);
+        // Mark non-prime numbers in the sieve and collect primes up to `end`
+        update_sieve(&mut sieve, end, num, &mut result);
 
-        // collect all prime numbers
-        result = extract_primes(&sieve);
+        // Collect remaining primes beyond `end`
+        result.extend(extract_remaining_primes(&sieve, end + 1));
     }
     result
 }
 
-/// Marks non-prime numbers in the sieve.
+/// Marks non-prime numbers in the sieve and collects prime numbers up to `end`.
 ///
 /// # Arguments
 ///
-/// * `sieve` - A mut slice of booleans representing the sieve.
+/// * `sieve` - A mutable slice of booleans representing the sieve.
 /// * `end` - The square root of the upper limit, used to optimize the algorithm.
 /// * `num` - The upper limit up to which to mark non-prime numbers.
-fn update_sieve(sieve: &mut [bool], end: usize, num: usize) {
+/// * `result` - A mutable vector to store the prime numbers.
+fn update_sieve(sieve: &mut [bool], end: usize, num: usize, result: &mut Vec<usize>) {
     for start in 2..=end {
         if sieve[start] {
+            result.push(start); // Collect prime numbers up to `end`
             for i in (start * start..=num).step_by(start) {
                 sieve[i] = false;
             }
         }
     }
 }
 
-/// Extracts prime numbers from the sieve.
+/// Extracts remaining prime numbers from the sieve beyond the given start index.
 ///
 /// # Arguments
 ///
 /// * `sieve` - A slice of booleans representing the sieve with non-prime numbers marked as false.
+/// * `start` - The index to start checking for primes (inclusive).
 ///
 /// # Returns
 ///
-/// A vector containing all prime numbers extracted from the sieve.
-fn extract_primes(sieve: &[bool]) -> Vec<usize> {
-    sieve
+/// A vector containing all remaining prime numbers extracted from the sieve.
+fn extract_remaining_primes(sieve: &[bool], start: usize) -> Vec<usize> {
+    sieve[start..]
         .iter()
         .enumerate()
-        .filter_map(|(num, is_prime)| if *is_prime { Some(num) } else { None })
+        .filter_map(|(i, &is_prime)| if is_prime { Some(start + i) } else { None })
         .collect()
 }