Sieve of Eratosthenes Find All Primes in DSA Go - Time & Space Complexity

Time Complexity: Sieve of Eratosthenes Find All Primes

O(n log log n)

Understanding Time Complexity

We want to understand how the time needed to find all prime numbers up to a limit grows as the limit gets bigger.

How does the number of steps change when we increase the range of numbers checked?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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
}
    

This code marks all prime numbers up to n by crossing out multiples of each prime.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The inner loop that marks multiples of each prime as not prime.
• How many times: For each prime i, it marks multiples starting from i*i up to n, stepping by i.

How Execution Grows With Input

As n grows, the number of operations grows a bit faster than n but much less than n squared.

Input Size (n)	Approx. Operations
10	About 20 to 30 steps
100	About 300 to 400 steps
1000	About 4000 to 5000 steps

Pattern observation: The steps grow roughly proportional to n times the logarithm of the logarithm of n, which is slower than n log n but faster than n.

Final Time Complexity

Time Complexity: O(n log log n)

This means the time grows a little faster than n but much slower than n squared, making it efficient for large n.

Common Mistake

[X] Wrong: "The inner loop runs n times for each i, so total is O(n²)."

[OK] Correct: The inner loop starts at i*i and jumps by i, so it runs fewer times as i grows, making total steps much less than n².

Interview Connect

Understanding this time complexity shows you can analyze nested loops with decreasing work, a skill useful for many algorithms.

Self-Check

"What if we started marking multiples from 2*i instead of i*i? How would the time complexity change?"

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