Sieve of Eratosthenes Find All Primes in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Sieve for n=10

What is the output of the following Rust code that uses the Sieve of Eratosthenes to find all primes up to 10?

DSA Rust

fn sieve(n: usize) -> Vec<usize> {
    let mut primes = vec![true; n + 1];
    primes[0] = false;
    primes[1] = false;
    let mut p = 2;
    while p * p <= n {
        if primes[p] {
            let mut i = p * p;
            while i <= n {
                primes[i] = false;
                i += p;
            }
        }
        p += 1;
    }
    primes.iter().enumerate().filter_map(|(i, &is_prime)| if is_prime { Some(i) } else { None }).collect()
}

fn main() {
    let result = sieve(10);
    println!("{:?}", result);
}

A [2, 3, 5, 7]

B [2, 3, 5, 7, 9]

C [1, 2, 3, 5, 7]

D [2, 3, 4, 5, 7]

💡 Hint

Remember that primes are numbers greater than 1 that have no divisors other than 1 and themselves.

The sieve marks multiples of each prime starting from its square as not prime. For n=10, primes are 2, 3, 5, and 7. Numbers like 9 are not prime because 3 divides 9.

🧠 Conceptual

intermediate

Number of Primes up to 20

Using the Sieve of Eratosthenes, how many prime numbers are there up to 20 (inclusive)?

A 7

B 9

C 8

D 6

💡 Hint

List primes: 2, 3, 5, 7, 11, 13, 17, 19

The primes up to 20 are 2, 3, 5, 7, 11, 13, 17, and 19, totaling 8 primes.

🔧 Debug

advanced

Identify the Error in Sieve Implementation

What error does the following Rust code produce when trying to find primes up to 15?

DSA Rust

fn sieve(n: usize) -> Vec<usize> {
    let mut primes = vec![true; n];
    primes[0] = false;
    primes[1] = false;
    let mut p = 2;
    while p * p <= n {
        if primes[p] {
            let mut i = p * p;
            while i <= n {
                primes[i] = false;
                i += p;
            }
        }
        p += 1;
    }
    primes.iter().enumerate().filter_map(|(i, &is_prime)| if is_prime { Some(i) } else { None }).collect()
}

fn main() {
    let result = sieve(15);
    println!("{:?}", result);
}

A Logical error: includes 1 as prime

B No error, outputs correct primes

C Compilation error: mismatched types

D Index out of bounds panic

💡 Hint

Check the size of the vector and the indices accessed.

The vector primes has length n, but the code accesses primes[n], which is out of bounds causing a panic.

🚀 Application

advanced

Find Sum of Primes up to 30

What is the sum of all prime numbers up to 30 using the Sieve of Eratosthenes?

A 113

B 129

C 141

D 97

💡 Hint

List primes up to 30 and add them: 2,3,5,7,11,13,17,19,23,29

Sum is 2+3+5+7+11+13+17+19+23+29 = 129. Wait, check carefully: 2+3=5, +5=10, +7=17, +11=28, +13=41, +17=58, +19=77, +23=100, +29=129. So correct sum is 129.

❓ Predict Output

expert

Output of Modified Sieve with Off-by-One

What is the output of this Rust code that attempts to find primes up to 12 but has an off-by-one error in the loop?

DSA Rust

fn sieve(n: usize) -> Vec<usize> {
    let mut primes = vec![true; n + 1];
    primes[0] = false;
    primes[1] = false;
    let mut p = 2;
    while p * p < n {
        if primes[p] {
            let mut i = p * p;
            while i <= n {
                primes[i] = false;
                i += p;
            }
        }
        p += 1;
    }
    primes.iter().enumerate().filter_map(|(i, &is_prime)| if is_prime { Some(i) } else { None }).collect()
}

fn main() {
    let result = sieve(12);
    println!("{:?}", result);
}

A [2, 3, 5, 7, 11]

B [2, 3, 5, 7]

C [2, 3, 5, 7, 11, 12]

D [2, 3, 5, 7, 11, 13]

💡 Hint

Check the condition in the while loop: p * p < n instead of p * p <= n.

Because the loop stops when p*p is not less than n, it misses marking multiples of 3 (since 3*3=9 < 12, but 4*4=16 > 12). This causes 11 to remain marked prime correctly, but the loop ends early, so 11 is included. Wait, check carefully: The loop condition is p*p < n, so for p=3, 9 < 12 true, loop runs. For p=4, 16 < 12 false, loop ends. So multiples of 3 are marked. So primes are correct. So output is [2,3,5,7,11]. So option A is correct. But option A misses 11. So correct answer is A.

Practice

1. What is the main purpose of the Sieve of Eratosthenes algorithm?

easy

A. To sort a list of numbers in ascending order

B. To find the greatest common divisor of two numbers

C. To find all prime numbers up to a given limit

D. To calculate the factorial of a number

Solution

1. Step 1: Understand the algorithm's goal

   The Sieve of Eratosthenes is designed to identify prime numbers efficiently.

2. Step 2: Recognize the output of the algorithm

   It marks multiples of primes as non-prime, leaving primes unmarked up to a limit.

3. Final Answer:

   To find all prime numbers up to a given limit -> Option C

4. Quick Check:

   Sieve of Eratosthenes = Find primes [OK]

Hint: Sieve marks multiples to find primes fast [OK]

Common Mistakes:

• Confusing it with sorting algorithms
• Thinking it calculates factorials
• Assuming it finds divisors instead of primes

2. Which Rust code snippet correctly initializes a boolean vector is_prime of size n+1 with all values set to true except for indices 0 and 1?

easy

A. let is_prime = vec![false; n+1]; is_prime[0] = true; is_prime[1] = true;

B. let mut is_prime = vec![true; n+1]; is_prime[0] = false; is_prime[1] = false;

C. let mut is_prime = vec![true; n]; is_prime[0] = false; is_prime[1] = false;

D. let mut is_prime = vec![false; n]; is_prime[0] = true; is_prime[1] = true;

Solution

1. Step 1: Initialize vector with true values

   We want a mutable vector of size n+1 with all true values initially.

2. Step 2: Set indices 0 and 1 to false

   Since 0 and 1 are not prime, we set those positions to false.

3. Final Answer:

   let mut is_prime = vec![true; n+1]; is_prime[0] = false; is_prime[1] = false; -> Option B

4. Quick Check:

   Initialize true vector and mark 0,1 false [OK]

Hint: Use vec![true; n+1] and set 0,1 false [OK]

Common Mistakes:

• Using size n instead of n+1
• Not making vector mutable
• Setting wrong indices to true/false

3. What will be the output of the following Rust code snippet that uses the Sieve of Eratosthenes to find primes up to 10?

let n = 10;
let mut is_prime = vec![true; n+1];
is_prime[0] = false;
is_prime[1] = false;
for i in 2..=((n as f64).sqrt() as usize) {
    if is_prime[i] {
        let mut j = i * i;
        while j <= n {
            is_prime[j] = false;
            j += i;
        }
    }
}
let primes: Vec<usize> = is_prime.iter().enumerate()
    .filter(|&(_, &prime)| prime)
    .map(|(index, _)| index)
    .collect();
println!("{:?}", primes);

medium

A. [2, 3, 5, 7]

B. [1, 2, 3, 5, 7]

C. [2, 3, 4, 5, 7]

D. [0, 2, 3, 5, 7]

Solution

1. Step 1: Initialize and mark non-primes

   Indices 0 and 1 are false. Loop marks multiples of 2 and 3 as false.

2. Step 2: Collect indices marked true

   Only 2, 3, 5, and 7 remain true and are collected as primes.

3. Final Answer:

   [2, 3, 5, 7] -> Option A

4. Quick Check:

   Primes up to 10 = [2, 3, 5, 7] [OK]

Hint: Primes under 10 are 2,3,5,7 only [OK]

Common Mistakes:

• Including 1 or 0 as prime
• Including 4 which is not prime
• Not starting j from i*i

4. Identify the bug in this Rust code snippet implementing the Sieve of Eratosthenes for n = 15:

let n = 15;
let mut is_prime = vec![true; n+1];
is_prime[0] = false;
is_prime[1] = false;
for i in 2..n {
    if is_prime[i] {
        let mut j = i * 2;
        while j <= n {
            is_prime[j] = false;
            j += i;
        }
    }
}

medium

A. Indices 0 and 1 should be set to true

B. The vector size should be n, not n+1

C. The outer loop should run from 2 to sqrt(n), not 2 to n

D. The inner loop should start from i * i, not i * 2

Solution

1. Step 1: Check inner loop start index

   Starting from i*2 marks some numbers multiple times, less efficient.

2. Step 2: Correct start is i*i for marking multiples

   Because smaller multiples are already marked by smaller primes.

3. Final Answer:

   The inner loop should start from i * i, not i * 2 -> Option D

4. Quick Check:

   Start marking multiples from i*i for efficiency [OK]

Hint: Start marking multiples from i squared [OK]

Common Mistakes:

• Starting inner loop from i*2 wastes time
• Looping outer from 2 to n instead of sqrt(n)
• Wrong vector size causing index errors

5. You want to find all prime numbers up to 50 using the Sieve of Eratosthenes in Rust. After running the sieve, you want to return a vector of primes but exclude the prime number 2 from the result. Which modification to the code below achieves this?

let n = 50;
let mut is_prime = vec![true; n+1];
is_prime[0] = false;
is_prime[1] = false;
for i in 2..=((n as f64).sqrt() as usize) {
    if is_prime[i] {
        let mut j = i * i;
        while j <= n {
            is_prime[j] = false;
            j += i;
        }
    }
}
let primes: Vec<usize> = is_prime.iter().enumerate()
    .filter(|&(_, &prime)| prime)
    .map(|(index, _)| index)
    .collect();

hard

A. Add a filter after collecting primes: primes.into_iter().filter(|&x| x != 2).collect()

B. Set is_prime[2] = false before the outer loop

C. Start outer loop from 3 instead of 2

D. Remove is_prime[0] = false line

Solution

1. Step 1: Understand the sieve marks primes correctly

   All primes including 2 are marked true in is_prime.

2. Step 2: Exclude 2 after collecting primes

   Filtering out 2 after collecting primes avoids affecting sieve logic.

3. Final Answer:

   Add a filter after collecting primes: primes.into_iter().filter(|&x| x != 2).collect() -> Option A

4. Quick Check:

   Filter out 2 after sieve to exclude it [OK]

Hint: Filter out 2 after collecting primes [OK]

Common Mistakes:

• Setting is_prime[2] = false breaks sieve correctness
• Starting loop from 3 misses marking multiples of 2
• Removing is_prime[0] = false causes wrong prime marking