math: Added PrimeList(n) and GetDivisors(n) (#193)

* Added new math functions: PrimeList, GetDivisors

* coderabbitai suggetions, Fix some spelling mistakes and make the GetDivisors example more accurate

---------

Co-authored-by: Kashif Khan <[email protected]>

Author: mahmoudheshamsg

math/EXAMPLES.md

@@ -408,6 +408,55 @@ func main() {
 ```
 true
 false
+```
+---
+## `PrimeList`
+
+### Get a list of prime numbers.
+
+```go
+package main
+
+import (
+	"fmt"
+
+	utils "github.com/kashifkhan0771/utils/math"
+)
+
+func main() {
+	sl := utils.PrimeList(60)
+	fmt.Println(sl)
+}
+```
+
+#### Output:
 
+```
+[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]
+```
+---
+## `GetDivisors`
+
+### Get a list of divisors of a number.
+
+```go
+package main
+
+import (
+	"fmt"
+
+	utils "github.com/kashifkhan0771/utils/math"
+)
+
+func main() {
+	sl := utils.GetDivisors(24)
+	fmt.Println(sl)
+}
+```
+
+#### Output:
+
+```
+[1 24 2 12 3 8 4 6]
 ```
 ---

math/README.md

@@ -29,6 +29,12 @@
 
 - **IsPrime**: Checks if a number is prime or not. Only works for non-negative integers.
 
+- **PrimeList**: Returns a slice of prime numbers up to n.
+
+- **GetDivisors**: Returns the divisors of a positive integer as an unordered slice. Returns an empty slice for negative inputs.
+
+
+
 ## Examples:
 
 For examples of each function, please checkout [EXAMPLES.md](/math/EXAMPLES.md)

math/math.go

@@ -190,14 +190,14 @@ func IsPrime(x int) bool {
 	if x == 2 {
 		return true
 	}
-	//no need to handle sqrt error since we elimnated negative numbers
+	// No need to handle sqrt error since we elimnated negative numbers
 	fsqrx, _ := Sqrt(x)
 	sqrx := int(fsqrx)
-	// if it's an even number that is not 2 then it's not a prime number
+	// If it's an even number that is not 2 then it's not a prime number
 	if x%2 == 0 {
 		return false
 	}
-	//since we eliminated all even numbers we can just iterate over only odd numbers
+	// Since we eliminated all even numbers we can just iterate over only odd numbers
 	// I'm iterating up to sqrx+1 just to account for any rounding errors
 	for i := 3; i <= sqrx+1; i += 2 {
 		if x%i == 0 {
@@ -207,3 +207,51 @@ func IsPrime(x int) bool {
 
 	return true
 }
+
+// Sieve of Eratosthenes algorithm Complexity = O(n log log n).
+func PrimeList(n int) []int {
+	if n < 2 {
+		return []int{}
+	}
+	list := []int{}
+	// Slice of bool to flag each number, intially we assume every number is a prime number except 1 and 0
+	isPrime := make([]bool, n+1)
+	for i := 2; i <= n; i++ {
+		isPrime[i] = true
+	}
+	// Basic implementation of Sieve
+	for i := 2; i*i <= n; i++ {
+		if isPrime[i] {
+			for j := i + i; j <= n; j += i {
+				isPrime[j] = false
+			}
+		}
+	}
+	for i := 2; i <= n; i++ {
+		if isPrime[i] {
+			list = append(list, i)
+		}
+	}
+
+	return list
+}
+
+// Complexity = sqrt(n)
+func GetDivisors(n int) []int {
+	if n <= 0 {
+		return []int{}
+	}
+	// 2 is a good starting point for the slice capacity
+	list := make([]int, 0, 2)
+	for i := 1; i*i <= n; i++ {
+		if n%i == 0 {
+			list = append(list, i)
+			// Check for perfect squares
+			if i != n/i {
+				list = append(list, n/i)
+			}
+		}
+	}
+	// The list is not sorted.
+	return list
+}

math/math_test.go

@@ -2,6 +2,7 @@ package math
 
 import (
 	"math"
+	"slices"
 	"testing"
 )
 
@@ -715,7 +716,7 @@ func TestIsPrime(t *testing.T) {
 	}{
 		{
 			name: "success - negative 10",
-			args: args{x: 10},
+			args: args{x: -10},
 			want: false,
 		},
 		{
@@ -763,6 +764,126 @@ func TestIsPrime(t *testing.T) {
 	}
 }
 
+func TestPrimeList(t *testing.T) {
+	type args struct {
+		x int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			name: "success - 2",
+			args: args{x: 2},
+			want: []int{2},
+		},
+		{
+			name: "success - 0",
+			args: args{x: 0},
+			want: []int{},
+		},
+		{
+			name: "success - 1",
+			args: args{x: 1},
+			want: []int{},
+		},
+		{
+			name: "success - 3",
+			args: args{x: 3},
+			want: []int{2, 3},
+		},
+		{
+			name: "success - 4",
+			args: args{x: 4},
+			want: []int{2, 3},
+		},
+		{
+			name: "success - 10",
+			args: args{x: 10},
+			want: []int{2, 3, 5, 7},
+		},
+		{
+			name: "success - 100 ",
+			args: args{x: 100},
+			want: []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},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := PrimeList(tt.args.x); !slices.Equal(got, tt.want) {
+				t.Errorf("PrimeList() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+func TestGetDivisors(t *testing.T) {
+	type args struct {
+		x int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			name: "success - 0",
+			args: args{x: 0},
+			want: []int{},
+		},
+		{
+			name: "success - 1",
+			args: args{x: 1},
+			want: []int{1},
+		},
+		{
+			name: "success - 2",
+			args: args{x: 2},
+			want: []int{1, 2},
+		},
+		{
+			name: "success - 3",
+			args: args{x: 3},
+			want: []int{1, 3},
+		},
+		{
+			name: "success - 4",
+			args: args{x: 4},
+			want: []int{1, 2, 4},
+		},
+		{
+			name: "success - 10",
+			args: args{x: 10},
+			want: []int{1, 2, 5, 10},
+		},
+		{
+			name: "success - 49",
+			args: args{x: 49},
+			want: []int{1, 7, 49},
+		},
+		{
+			name: "success - 48",
+			args: args{x: 48},
+			want: []int{1, 2, 3, 4, 6, 8, 12, 16, 24, 48},
+		},
+		{
+			name: "success - 100 ",
+			args: args{x: 100},
+			want: []int{1, 2, 4, 5, 10, 20, 25, 50, 100},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GetDivisors(tt.args.x)
+			// The slice need to be sorted in order to be compared
+			slices.Sort(got)
+			if !slices.Equal(got, tt.want) {
+				t.Errorf("GetDivisors() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 // ================================================================================
 // ### BENCHMARKS
 // ================================================================================
@@ -819,3 +940,21 @@ func BenchmarkIsPrime(b *testing.B) {
 		_ = IsPrime(prime)
 	}
 }
+
+func BenchmarkPrimeList(b *testing.B) {
+	b.ReportAllocs()
+
+	const n = 1e8
+	for b.Loop() {
+		_ = PrimeList(n)
+	}
+}
+
+func BenchmarkGetDivisors(b *testing.B) {
+	b.ReportAllocs()
+
+	const n = 2e9
+	for b.Loop() {
+		_ = GetDivisors(n)
+	}
+}