get primes using segmented sieve

Author: danrusei

README.md

@@ -89,7 +89,7 @@ WIP, the descriptions of the below `unsolved yet` problems can be found in the [
 - [x] [Sieve of Eratosthenes](https://github.com/danrusei/algorithms_with_Go/tree/main/numbers/eratosthenes)
 - [] Convex Hull
 - [] Basic and Extended Euclidean algorithms
-- [] Segmented Sieve
+- [x] [Segmented Sieve](https://github.com/danrusei/algorithms_with_Go/tree/main/numbers/segmented)
 - [] Chinese remainder theorem
 - [] Lucas Theorem
 

numbers/segmented/README.md

@@ -0,0 +1,46 @@
+# Segmented Sieve 
+
+Source: [GeeksforGeeks](https://www.geeksforgeeks.org/segmented-sieve/amp/)  
+Source: [Wikipedia - Segmented Sieves](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes#Segmented_sieve)
+
+Given a number n, print all primes smaller than or equal to n.
+
+The implemented [Sieve of Eratosthenes](https://github.com/danrusei/algorithms_with_Go/tree/main/numbers/eratosthenes) looks good, but consider the situation when n is large, the Simple Sieve faces following issues:
+
+* an array of size Θ(n) may not fit in memory
+* the simple Sieve is not cache friendly even for slightly bigger n. The algorithm traverses the array without locality of reference
+
+## Example
+
+> Input : n =10  
+> Output : 2 3 5 7
+>
+> Input : n = 20  
+> Output: 2 3 5 7 11 13 17 19
+
+## Algorithm
+
+The idea of segmented sieve is to divide the range [0..n-1] in different segments and compute primes in all segments one by one. This algorithm first uses Simple Sieve to find primes smaller than or equal to √(n).
+
+* use Simple Sieve to find all primes upto square root of ‘n’ and store these primes in an array “prime[]”. Store the found primes in an array ‘prime[]’.
+* divide [0..n-1] range in different segments such that size of every segment is at-most √n
+* for every segment [low..high]
+  * create an array mark[high-low+1]. Here we need only O(x) space where x is number of elements in given range.
+  * iterate through all primes found in step 1. For every prime, mark its multiples in given range [low..high].
+
+In Simple Sieve, we needed O(n) space which may not be feasible for large n. Here we need O(√n) space and we process smaller ranges at a time (locality of reference)
+
+## Result
+
+```bash
+ go test -v
+=== RUN   TestPrimes
+=== RUN   TestPrimes/10_value
+=== RUN   TestPrimes/20_value
+=== RUN   TestPrimes/99_value
+--- PASS: TestPrimes (0.00s)
+    --- PASS: TestPrimes/10_value (0.00s)
+    --- PASS: TestPrimes/20_value (0.00s)
+    --- PASS: TestPrimes/99_value (0.00s)
+PASS
+```

numbers/segmented/primes.go

@@ -0,0 +1,83 @@
+package primes
+
+import "math"
+
+func segmentedSieve(num int) []int {
+	limit := int(math.Floor(math.Sqrt(float64(num))) + 1)
+	primes := getPrimes(limit)
+
+	result := []int{}
+
+	low := limit
+	high := limit * 2
+
+	for low < num {
+		if high >= num {
+			high = num
+		}
+
+		// mark primes in current range. A value in mark[i]
+		// will finally be false if 'i-low' is Not a prime, else true.
+		mark := make([]bool, limit+1)
+		for i := 0; i < limit+1; i++ {
+			mark[i] = true
+		}
+
+		for i := 0; i < len(primes); i++ {
+
+			//find the minimum number in [low..high] that is a multiple of prime[i]
+			loLim := int(math.Floor(float64(low/primes[i])) * float64(primes[i]))
+
+			if loLim < low {
+				loLim += primes[i]
+			}
+			// mark multiples of prime[i] in [low..high]: marking j - low for j
+			for j := loLim; j < high; j += primes[i] {
+				mark[j-low] = false
+			}
+		}
+
+		for i := low; i < high; i++ {
+			if mark[i-low] {
+				result = append(result, i)
+			}
+		}
+
+		// update low and high for next segment
+		low = low + limit
+		high = high + limit
+
+	}
+	primes = append(primes, result...)
+	return primes
+}
+
+func getPrimes(num int) []int {
+	numbers := make([]bool, num)
+
+	//create the slice of bools and mark initially all true
+	//a value in numbers[i] will finally be false if i is Not a prime, else true.
+	for i := 0; i < num; i++ {
+		numbers[i] = true
+	}
+
+	for p := 2; p*p < num; p++ {
+		//if numbers[p] is not changed, then it is a prime
+		// this selects only the alreade identified prime numbers
+		if numbers[p] {
+			// search for multiple of p, and mark them as false
+			for i := p * p; i < num; i += p {
+				numbers[i] = false
+			}
+		}
+	}
+
+	//create the list that containts only the prime numbers
+	primes := []int{}
+	for i := 2; i < num; i++ {
+		if numbers[i] {
+			primes = append(primes, i)
+		}
+	}
+	return primes
+}

numbers/segmented/primes_test.go

@@ -0,0 +1,17 @@
+package primes
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestPrimes(t *testing.T) {
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := segmentedSieve(tc.num)
+			if !reflect.DeepEqual(result, tc.expected) {
+				t.Errorf("Expected: %d, got: %d", tc.expected, result)
+			}
+		})
+	}
+}

numbers/segmented/test_cases.go

@@ -0,0 +1,23 @@
+package primes
+
+var testcases = []struct {
+	name     string
+	num      int
+	expected []int
+}{
+	{
+		name:     "10_value",
+		num:      10,
+		expected: []int{2, 3, 5, 7},
+	},
+	{
+		name:     "20_value",
+		num:      20,
+		expected: []int{2, 3, 5, 7, 11, 13, 17, 19},
+	},
+	{
+		name:     "99_value",
+		num:      99,
+		expected: []int{2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97},
+	},
+}