Sieve of Eratosthenes Find All Primes in DSA Go

Mental Model

We mark multiples of each prime number as not prime, so only primes remain unmarked.

Analogy: Imagine a list of numbers like a row of boxes. We paint over boxes that are multiples of smaller numbers, leaving only prime boxes unpainted.

Numbers: 2 3 4 5 6 7 8 9 10
Marks:  _ _ X _ X _ X X  X
_ means unmarked (potential prime), X means marked (not prime)

Dry Run Walkthrough

Input: Find all primes up to 10

Goal: Identify all prime numbers from 2 to 10 using the sieve

Step 1: Start with list 2 to 10 all unmarked

2 3 4 5 6 7 8 9 10
_ _ _ _ _ _ _ _  _

Why: We begin assuming all numbers could be prime

Step 2: Mark multiples of 2 (except 2) as not prime

2 3 4 5 6 7 8 9 10
_ _ X _ X _ X _  X

Why: Multiples of 2 cannot be prime

Step 3: Move to next unmarked number 3, mark multiples of 3

2 3 4 5 6 7 8 9 10
_ _ X _ X _ X X  X

Why: Multiples of 3 are not prime

Step 4: Next unmarked number is 5, mark multiples of 5 (none in range)

2 3 4 5 6 7 8 9 10
_ _ X _ X _ X X  X

Why: No multiples of 5 to mark up to 10

Step 5: Next unmarked number is 7, mark multiples of 7 (none in range)

2 3 4 5 6 7 8 9 10
_ _ X _ X _ X X  X

Why: No multiples of 7 to mark up to 10

Result:

2 3 5 7 are unmarked and prime
2 _ 3 _ 5 _ 7 _ _ _

Annotated Code

DSA Go

package main

import (
	"fmt"
)

func sieveOfEratosthenes(n int) []int {
	// Create a boolean slice to mark primes
	isPrime := make([]bool, n+1)
	for i := 2; i <= n; i++ {
		isPrime[i] = true // assume all are prime initially
	}

	for i := 2; i*i <= n; i++ {
		if isPrime[i] {
			// Mark multiples of i as not prime
			for j := i * i; j <= n; j += i {
				isPrime[j] = false
			}
		}
	}

	primes := []int{}
	for i := 2; i <= n; i++ {
		if isPrime[i] {
			primes = append(primes, i)
		}
	}
	return primes
}

func main() {
	primes := sieveOfEratosthenes(10)
	for i, p := range primes {
		if i > 0 {
			fmt.Print(", ")
		}
		fmt.Print(p)
	}
	fmt.Println()
}

for i := 2; i <= n; i++ { isPrime[i] = true // assume all are prime initially }

Initialize all numbers from 2 to n as potential primes

for i := 2; i*i <= n; i++ { if isPrime[i] { for j := i * i; j <= n; j += i { isPrime[j] = false } } }

For each prime candidate i, mark all multiples starting from i*i as not prime

for i := 2; i <= n; i++ { if isPrime[i] { primes = append(primes, i) } }

Collect all numbers still marked prime into the result list

Output

2, 3, 5, 7

Complexity Analysis

Time: O(n log log n) because we mark multiples efficiently up to sqrt(n)

Space: O(n) because we store a boolean array for all numbers up to n

vs Alternative: Much faster than checking each number's divisibility individually which is O(n sqrt n)

Edge Cases

n less than 2

Returns empty list since no primes exist below 2

DSA Go

for i := 2; i <= n; i++ { isPrime[i] = true }

n equals 2

Returns list with only 2 as prime

DSA Go

for i := 2; i <= n; i++ { isPrime[i] = true }

When to Use This Pattern

When asked to find all primes up to a number efficiently, use the Sieve of Eratosthenes because it marks multiples systematically to avoid repeated checks.

Common Mistakes

Mistake: Starting to mark multiples from i*2 instead of i*i
Fix: Start marking from i*i because smaller multiples were already marked by smaller primes

Summary

Finds all prime numbers up to a given limit by marking multiples as not prime.

Use when you need a fast way to list primes up to a number.

The key insight is to start marking multiples from the square of each prime candidate.

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 all prime numbers up to a given limit

C. To find the greatest common divisor of two numbers

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

   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 B

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 of the following Go code snippets correctly initializes a boolean slice for the sieve up to n?

easy

A. primes := make([]bool, n-1)

B. primes := make([]int, n)

C. primes := []bool{n}

D. primes := make([]bool, n+1)

Solution

1. Step 1: Identify correct slice type and size

   We need a boolean slice of size n+1 to include index n.

2. Step 2: Check Go syntax for slice creation

   make([]bool, n+1) correctly creates a boolean slice of length n+1.

3. Final Answer:

   primes := make([]bool, n+1) -> Option D

4. Quick Check:

   Boolean slice with length n+1 = primes := make([]bool, n+1) [OK]

Hint: Use make([]bool, n+1) for sieve array [OK]

Common Mistakes:

• Using int slice instead of bool
• Incorrect slice length causing index errors
• Wrong slice initialization syntax

3. What will be the output slice after running the sieve for n = 10 if true means prime and false means not prime?

func sieve(n int) []bool {
    primes := make([]bool, n+1)
    for i := 2; i <= n; i++ {
        primes[i] = true
    }
    for i := 2; i*i <= n; i++ {
        if primes[i] {
            for j := i * i; j <= n; j += i {
                primes[j] = false
            }
        }
    }
    return primes
}

fmt.Println(sieve(10))

medium

A. [false false true true false true false true false false false]

B. [false false true true false true false true false true false]

C. [false false true true false true false true false false true]

D. [false false true true true true false true false false false]

Solution

1. Step 1: Initialize primes slice for n=10

   Indices 0 and 1 are false; 2 to 10 are initially true.

2. Step 2: Mark multiples of primes as false

   Multiples of 2: 4,6,8,10 set false; multiples of 3: 9 set false.

3. Final Answer:

   [false false true true false true false true false false false] -> Option A

4. Quick Check:

   Primes at 2,3,5,7 true; multiples false [OK]

Hint: Mark multiples starting from i*i as false [OK]

Common Mistakes:

• Marking primes as false by mistake
• Starting inner loop from i instead of i*i
• Incorrect slice indexing

4. Identify the error in this Go code implementing the sieve:

func sieve(n int) []bool {
    primes := make([]bool, n)
    for i := 2; i <= n; i++ {
        primes[i] = true
    }
    for i := 2; i*i <= n; i++ {
        if primes[i] {
            for j := i * i; j <= n; j += i {
                primes[j] = false
            }
        }
    }
    return primes
}

medium

A. Inner loop increments by 1 instead of i

B. Loop starts from 2 instead of 0

C. Slice length is n, but indices go up to n causing out-of-range error

D. Boolean slice should be initialized with false values

Solution

1. Step 1: Check slice size vs index usage

   Slice is length n, but code accesses primes[n], which is out of range.

2. Step 2: Understand Go slice indexing

   Valid indices are 0 to n-1, so primes[n] causes runtime panic.

3. Final Answer:

   Slice length is n, but indices go up to n causing out-of-range error -> Option C

4. Quick Check:

   Slice size mismatch causes index error [OK]

Hint: Slice length must be n+1 for index n [OK]

Common Mistakes:

• Ignoring slice length vs index range
• Starting loops incorrectly
• Misunderstanding slice initialization defaults

5. Using the Sieve of Eratosthenes, how many prime numbers are there up to n = 30?

Consider the standard sieve implementation where indices 0 and 1 are not prime.

medium

A. 10

B. 11

C. 12

D. 13

Solution

1. Step 1: List primes up to 30

   Primes are 2,3,5,7,11,13,17,19,23,29.

2. Step 2: Count the primes

   Counting gives 10 primes.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Count primes ≤ 30 = 10 [OK]

Hint: Count primes manually or use sieve output [OK]

Common Mistakes:

• Including non-primes like 9 or 15
• Forgetting to exclude 1 and 0
• Miscounting primes near 30