Sieve of Eratosthenes Find All Primes in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Sieve of Eratosthenes?

It is a method to find all prime numbers up to a certain limit by repeatedly marking the multiples of each prime number starting from 2.

intermediate

Why do we start marking multiples from the square of the prime number in the Sieve of Eratosthenes?

Because all smaller multiples of that prime have already been marked by smaller primes, so starting from the square avoids redundant work.

beginner

In the Sieve of Eratosthenes, what does a 'true' value in the boolean array represent?

It means the number at that index is currently considered prime (not marked as a multiple of any smaller prime).

intermediate

What is the time complexity of the Sieve of Eratosthenes algorithm?

The time complexity is O(n log log n), which is very efficient for finding primes up to n.

beginner

How does the Sieve of Eratosthenes help in real-life situations?

It helps quickly find prime numbers which are useful in cryptography, hashing, and random number generation.

What is the first prime number used to start the sieve?

A 3

B 1

C 0

D 2

The sieve starts with 2, the smallest prime number.

When marking multiples of a prime p, from which number do we start?

A p * p

B 2

C p

D 1

We start marking from p squared to avoid marking multiples already handled.

What does a false value in the sieve array mean after processing?

A The number is prime

B The number is zero

C The number is composite

D The number is negative

False means the number was marked as a multiple of a prime, so it is composite.

Which data structure is commonly used to implement the sieve?

A Linked list

B Boolean array

C Stack

D Queue

A boolean array tracks whether each number is prime (true) or not (false).

What is the main benefit of the Sieve of Eratosthenes compared to checking each number individually?

A It is faster for large ranges

B It works only for small numbers

C It finds only even primes

D It uses less memory

The sieve is much faster than checking primality one by one for large ranges.

Explain how the Sieve of Eratosthenes finds all prime numbers up to a given number n.

Think about crossing out multiples step by step.

Describe why starting to mark multiples from p squared is an optimization in the sieve.

Consider what happens to multiples less than p squared.

Practice

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

easy

A. To sort an array of numbers

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

C. To find the greatest common divisor of two numbers

D. To reverse a string

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

   It marks multiples of primes as non-prime to find all primes up to a limit.

3. Final Answer:

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

4. Quick Check:

   Prime finding = B [OK]

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

Common Mistakes:

• Confusing prime finding with sorting
• Thinking it finds divisors or reverses strings
• Assuming it works for negative numbers

2. Which of the following is the correct way to initialize the sieve array in C for finding primes up to n?

easy

A. int sieve[n+1]; for(int i=0; i<=n; i++) sieve[i] = 1;

B. int sieve[n]; for(int i=1; i

C. int sieve[n+1]; for(int i=0; i<=n; i++) sieve[i] = 0; sieve[0] = sieve[1] = 1;

D. int sieve[n+1]; for(int i=0; i<=n; i++) sieve[i] = i;

Solution

1. Step 1: Understand sieve initialization

   The sieve array uses 1 to mark potential primes initially.

2. Step 2: Check array size and initialization

   Array size should be n+1 to include number n, and all set to 1 (true) initially.

3. Final Answer:

   int sieve[n+1]; for(int i=0; i<=n; i++) sieve[i] = 1; -> Option A

4. Quick Check:

   Initialize all to 1 for primes [OK]

Hint: Initialize all to 1 (true) for prime candidates [OK]

Common Mistakes:

• Using size n instead of n+1
• Initializing with zeros instead of ones
• Marking 0 and 1 as prime initially

3. What will be the output of the following C code snippet using Sieve of Eratosthenes to find primes up to 10?

int n = 10;
int sieve[11];
for(int i=0; i<=n; i++) sieve[i] = 1;
sieve[0] = sieve[1] = 0;
for(int i=2; i*i<=n; i++) {
  if(sieve[i]) {
    for(int j=i*i; j<=n; j+=i) sieve[j] = 0;
  }
}
for(int i=2; i<=n; i++) {
  if(sieve[i]) printf("%d ", i);
}

medium

A. 2 3 4 5 7

B. 1 2 3 5 7

C. 2 3 5 7 9

D. 2 3 5 7

Solution

1. Step 1: Initialize sieve and mark 0,1 as non-prime

   Array sieve marks 0 and 1 as 0 (not prime), others as 1 (prime candidate).

2. Step 2: Mark multiples of primes as non-prime

   For i=2, mark 4,6,8,10 as 0; for i=3, mark 9 as 0.

3. Step 3: Print all indices with sieve[i] = 1

   Primes are 2, 3, 5, 7 only.

4. Final Answer:

   2 3 5 7 -> Option D

5. Quick Check:

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

Hint: Mark multiples starting from i*i to avoid repeats [OK]

Common Mistakes:

• Printing 1 as prime
• Including non-primes like 4 or 9
• Starting marking multiples from i instead of i*i

4. Identify the error in this Sieve of Eratosthenes code snippet and choose the correct fix:

int n = 20;
int sieve[21];
for(int i=0; i<=n; i++) sieve[i] = 1;
sieve[0] = sieve[1] = 0;
for(int i=2; i<=n; i++) {
  if(sieve[i]) {
    for(int j=2*i; j<=n; j+=i) sieve[j] = 0;
  }
}

medium

A. Remove sieve[0] and sieve[1] assignments

B. Initialize sieve array with zeros instead of ones

C. Change outer loop condition to i*i <= n

D. Start inner loop from j = i instead of 2*i

Solution

1. Step 1: Analyze outer loop condition

   Outer loop runs from 2 to n, but it should run only up to sqrt(n) for efficiency.

2. Step 2: Understand inner loop start

   Inner loop correctly starts from 2*i, but starting from i*i is more optimal.

3. Step 3: Correct the outer loop condition

   Change outer loop to for(i=2; i*i<=n; i++) to avoid unnecessary iterations.

4. Final Answer:

   Change outer loop condition to i*i <= n -> Option C

5. Quick Check:

   Outer loop till sqrt(n) improves sieve [OK]

Hint: Outer loop runs only to sqrt(n) for marking multiples [OK]

Common Mistakes:

• Running outer loop till n wastes time
• Starting inner loop from 2*i instead of i*i (less efficient)
• Not marking 0 and 1 as non-prime

5. You want to find all prime numbers up to 50 using the Sieve of Eratosthenes. After running the sieve, how many numbers will remain marked as prime?

hard

A. 15

B. 16

C. 14

D. 13

Solution

1. Step 1: List primes up to 50

   Primes are: 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 (total 15).

2. Step 2: Count primes carefully

   Counting again: 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 = 15 primes.

3. Step 3: Check if 1 is counted

   1 is not prime, so total primes = 15.

4. Final Answer:

   15 -> Option A

5. Quick Check:

   Count primes up to 50 = 15 [OK]

Hint: Count known primes or use sieve output count [OK]

Common Mistakes:

• Including 1 as prime
• Miscounting primes between 40 and 50
• Forgetting to exclude non-primes