Merge branch 'develop'

Author: codejsha

README.md

@@ -920,9 +920,9 @@ Math.pow(2.71, 3.15), Math.round(3.14), Math.sqrt(225)
 
 - Combination: [cpp](/cpp-algorithm/src/math/combination.h)(`GenerateCombination`) | Find the number of ways to choose $k$ items from $n$ items.
 - Fast Fourier transform: Fast Fourier transform is a mathematical algorithm that finds the discrete Fourier transform of a set of real numbers.
-- Greatest common divisor (GCD), CLRS#31.2: [python](/python-algorithm/algorithm/math/greatest_common_divisor.py), [java](/java-algorithm/src/main/java/com/example/algorithm/math/GreatestCommonDivisor.java), [golang](/go-algorithm/pkg/math/greatest_common_divisor.go) | Find the greatest common divisor of two numbers.
+- Greatest common divisor (GCD), CLRS#31.2: [python](/python-algorithm/algorithm/math/greatest_common_divisor.py), [golang](/go-algorithm/pkg/math/greatest_common_divisor.go), [java](/java-algorithm/src/main/java/com/example/algorithm/math/GreatestCommonDivisor.java) | Find the greatest common divisor of two numbers.
 - Integer factorization: [java](/java-algorithm/src/main/java/com/example/algorithm/math/IntegerFactorization.java) | Integer factorization is the process of determining which prime numbers divide a given positive integer.
-- Least common multiple (LCM): [python](/python-algorithm/algorithm/math/least_common_multiple.py), [java](/java-algorithm/src/main/java/com/example/algorithm/math/LeastCommonMultiple.java), [golang](/go-algorithm/pkg/math/least_common_multiple.go) | Find the least common multiple of two numbers.
+- Least common multiple (LCM): [python](/python-algorithm/algorithm/math/least_common_multiple.py), [golang](/go-algorithm/pkg/math/least_common_multiple.go), [java](/java-algorithm/src/main/java/com/example/algorithm/math/LeastCommonMultiple.java) | Find the least common multiple of two numbers.
 - Miller-Rabin primality test, CLRS#31.8: [cpp](/cpp-algorithm/src/math/miller_rabin.h) | Miller-Rabin primality test is a mathematical algorithm that finds whether a given number is prime.
 - Permutation
   - given string: [cpp](/cpp-algorithm/src/math/permutation.h)(`Permutation`) | Find the permutation of a set of items from given string.
@@ -1164,39 +1164,39 @@ list.sort(Comparator.comparingInt(String::length));
 
 **Sorting algorithms**
 
-- Bubble sort, CLRS#2-problems2.2: [java](/java-algorithm/src/main/java/com/example/algorithm/sort/BubbleSort.java) | Bubble sort is a sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items, and swaps them if needed.<br>($\textit{n}$ is the number of elements)
+- Bubble sort, CLRS#2-problems2.2: [golang](go-algorithm/pkg/sort/bubble_sort.go), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/BubbleSort.java) | Bubble sort is a sorting algorithm that repeatedly steps through the list to be sorted, compares each pair of adjacent items, and swaps them if needed.<br>($\textit{n}$ is the number of elements)
 
 | **Case**    | **Time complexity** | **Remarks**                                                                             |
 | :---------- | :-----------------: | :-------------------------------------------------------------------------------------- |
 | **Best**    |       $O(n)$        | when the input list is already sorted in the desired order (ascending or descending)    |
 | **Worst**   |      $O(n^2)$       | when the input list is already sorted in the reverse order of the desired sorting order |
 | **Average** |      $O(n^2)$       | when the input list is in jumbled order                                                 |
 
-- Bucket sort, CLRS#8.4: [java](/java-algorithm/src/main/java/com/example/algorithm/sort/BucketSort.java) | Bucket sort is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket contains a range of values and the elements are sorted within these buckets using any of the suitable sorting algorithms (such as insertion sort, merge sort, selection sort).<br>($\textit{n}$ is the number of elements and $\textit{k}$ is the number of buckets)
+- Bucket sort, CLRS#8.4: [golang](go-algorithm/pkg/sort/bucket_sort.go), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/BucketSort.java) | Bucket sort is a sorting algorithm that works by distributing the elements of an array into a number of buckets. Each bucket contains a range of values and the elements are sorted within these buckets using any of the suitable sorting algorithms (such as insertion sort, merge sort, selection sort).<br>($\textit{n}$ is the number of elements and $\textit{k}$ is the number of buckets)
 
 | **Case**    | **Time complexity** | **Remarks**                                                                                                    |
 | ----------- | :-----------------: | -------------------------------------------------------------------------------------------------------------- |
 | **Best**    |     $O(n + k)$      | when input elements are uniformly distributed<br> and each bucket contains roughly the same number of elements |
 | **Worst**   |      $O(n^2)$       | when all elements are placed into a single bucket                                                              |
 | **Average** |       $O(n)$        |                                                                                                                |
 
-- Counting sort, CLRS#8.2: [java](/java-algorithm/src/main/java/com/example/algorithm/sort/CountingSort.java) | Counting sort is a non-comparative sorting algorithm that sorts the elements of an array by counting the occurrences of each element in the array. The count is stored in an auxiliary array and the sorting is done by mapping the count as an index of the auxiliary array. It is used as a subroutine in radix sort (CLRS#8.3).<br>($\textit{n}$ is the number of elements and $\textit{k}$ is the range of input values)
+- Counting sort, CLRS#8.2: [golang](go-algorithm/pkg/sort/counting_sort.go), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/CountingSort.java) | Counting sort is a non-comparative sorting algorithm that sorts the elements of an array by counting the occurrences of each element in the array. The count is stored in an auxiliary array and the sorting is done by mapping the count as an index of the auxiliary array. It is used as a subroutine in radix sort (CLRS#8.3).<br>($\textit{n}$ is the number of elements and $\textit{k}$ is the range of input values)
 
 | **Case**    | **Time complexity** | **Remarks**                                             |
 | ----------- | :-----------------: | ------------------------------------------------------- |
 | **Best**    |     $O(n + k)$      | when the input elements have a small range of values    |
 | **Worst**   |     $O(n + k)$      | when the input elements have a large range of values    |
 | **Average** |     $O(n + k)$      | when the elements are distributed randomly in the array |
 
-- Heap sort, CLRS#6: [java](/java-algorithm/src/main/java/com/example/algorithm/sort/HeapSort.java) | Heap sort is a comparison-based sorting algorithm that uses a binary heap data structure to sort an array. It is used for the implementation of priority queue.<br>($\textit{n}$ is the number of elements)
+- Heap sort, CLRS#6: [golang](go-algorithm/pkg/sort/heap_sort.go), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/HeapSort.java) | Heap sort is a comparison-based sorting algorithm that uses a binary heap data structure to sort an array. It is used for the implementation of priority queue.<br>($\textit{n}$ is the number of elements)
 
 | **Case**    | **Time complexity** | **Remarks** |
 | ----------- | :-----------------: | ----------- |
 | **Best**    |    $O(n log n)$     |             |
 | **Worst**   |    $O(n log n)$     |             |
 | **Average** |    $O(n log n)$     |             |
 
-- Insertion sort, CLRS#2.1: [cpp](/cpp-algorithm/src/sort/sort.h), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/InsertionSort.java) | Insertion sort is a comparison-based sorting algorithm that builds the final sorted array one element at a time. One of the fastest algorithms for sorting very small arrays (around 10 elements).<br>($\textit{n}$ is the number of elements)
+- Insertion sort, CLRS#2.1: [cpp](/cpp-algorithm/src/sort/sort.h), [golang](go-algorithm/pkg/sort/insertion_sort.go), [java](/java-algorithm/src/main/java/com/example/algorithm/sort/InsertionSort.java) | Insertion sort is a comparison-based sorting algorithm that builds the final sorted array one element at a time. One of the fastest algorithms for sorting very small arrays (around 10 elements).<br>($\textit{n}$ is the number of elements)
 
 | **Case**    | **Time complexity** | **Remarks**                                                                     |
 | ----------- | :-----------------: | ------------------------------------------------------------------------------- |

go-algorithm/go.mod

@@ -7,5 +7,6 @@ require github.com/stretchr/testify v1.9.0
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go-algorithm/go.sum

@@ -4,6 +4,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f h1:XdNn9LlyWAhLVp6P/i8QYBW+hlyhrhei9uErw2B5GJo=
+golang.org/x/exp v0.0.0-20241108190413-2d47ceb2692f/go.mod h1:D5SMRVC3C2/4+F/DB1wZsLRnSNimn2Sp/NPsCrsv8ak=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

go-algorithm/pkg/math/greatest_common_divisor_test.go

@@ -1,21 +1,97 @@
 package math
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestGCDEuclidean(t *testing.T) {
-	assert.Equal(t, 12, GCDEuclidean(24, 36))
-	assert.Equal(t, 1, GCDEuclidean(17, 22))
-	assert.Equal(t, 20, GCDEuclidean(120, 500))
+func Test_GCDEuclidean(t *testing.T) {
+	type args struct {
+		a int
+		b int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "Case 1",
+			args: args{
+				a: 24,
+				b: 36,
+			},
+			want: 12,
+		},
+		{
+			name: "Case 2",
+			args: args{
+				a: 17,
+				b: 22,
+			},
+			want: 1,
+		},
+		{
+			name: "Case 3",
+			args: args{
+				a: 120,
+				b: 500,
+			},
+			want: 20,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := GCDEuclidean(tt.args.a, tt.args.b)
+
+			assert.Equalf(t, tt.want, got, "GCDEuclidean(%v, %v)", tt.args.a, tt.args.b)
+		})
+	}
 }
 
-func TestGCDEuclideanExtended(t *testing.T) {
-	d1, _, _ := GCDEuclideanExtended(24, 36)
-	assert.Equal(t, 12, d1)
-	d2, _, _ := GCDEuclideanExtended(17, 22)
-	assert.Equal(t, 1, d2)
-	d3, _, _ := GCDEuclideanExtended(120, 500)
-	assert.Equal(t, 20, d3)
+func Test_GCDEuclideanExtended(t *testing.T) {
+	type args struct {
+		a int
+		b int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "Case 1",
+			args: args{
+				a: 24,
+				b: 36,
+			},
+			want: 12,
+		},
+		{
+			name: "Case 2",
+			args: args{
+				a: 17,
+				b: 22,
+			},
+			want: 1,
+		},
+		{
+			name: "Case 3",
+			args: args{
+				a: 120,
+				b: 500,
+			},
+			want: 20,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, _, _ := GCDEuclideanExtended(tt.args.a, tt.args.b)
+
+			assert.Equalf(t, tt.want, got, "GCDEuclideanExtended(%v, %v)", tt.args.a, tt.args.b)
+		})
+	}
 }

go-algorithm/pkg/math/least_common_multiple_test.go

@@ -1,12 +1,52 @@
 package math
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-func TestLCM(t *testing.T) {
-	assert.Equal(t, 72, LCM(24, 36))
-	assert.Equal(t, 374, LCM(17, 22))
-	assert.Equal(t, 3000, LCM(120, 500))
+func Test_LCM(t *testing.T) {
+	type args struct {
+		a int
+		b int
+	}
+	tests := []struct {
+		name string
+		args args
+		want int
+	}{
+		{
+			name: "Case 1",
+			args: args{
+				a: 24,
+				b: 36,
+			},
+			want: 72,
+		},
+		{
+			name: "Case 2",
+			args: args{
+				a: 17,
+				b: 22,
+			},
+			want: 374,
+		},
+		{
+			name: "Case 3",
+			args: args{
+				a: 120,
+				b: 500,
+			},
+			want: 3000,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := LCM(tt.args.a, tt.args.b)
+
+			assert.Equalf(t, tt.want, got, "LCM() got = %v, want %v", got, tt.want)
+		})
+	}
 }

go-algorithm/pkg/sort/bubble_sort.go

@@ -0,0 +1,16 @@
+package sort
+
+import (
+	"golang.org/x/exp/constraints"
+)
+
+func bubbleSort[T constraints.Integer](arr []T) {
+	n := len(arr)
+	for i := 0; i < n; i++ {
+		for j := n - 1; j > i; j-- {
+			if arr[j] < arr[j-1] {
+				arr[j], arr[j-1] = arr[j-1], arr[j]
+			}
+		}
+	}
+}

go-algorithm/pkg/sort/bubble_sort_test.go

@@ -0,0 +1,41 @@
+package sort
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_bubbleSort(t *testing.T) {
+	type args struct {
+		arr []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			name: "Integer Case",
+			args: args{
+				arr: []int{31, 64, 49, 85, 71, 26, 6, 19},
+			},
+			want: []int{6, 19, 26, 31, 49, 64, 71, 85},
+		},
+		{
+			name: "Empty array input",
+			args: args{
+				arr: []int{},
+			},
+			want: []int{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			bubbleSort(tt.args.arr)
+
+			assert.Equalf(t, tt.want, tt.args.arr, "bubbleSort() got = %v, want %v", tt.args.arr, tt.want)
+		})
+	}
+}

go-algorithm/pkg/sort/bucket_sort.go

@@ -0,0 +1,46 @@
+package sort
+
+import (
+	"math"
+
+	"golang.org/x/exp/constraints"
+)
+
+func bucketSort[T constraints.Integer](arr []T) []T {
+	n := len(arr)
+
+	var maxVal, minVal T
+	for _, v := range arr {
+		if v > maxVal {
+			maxVal = v
+		}
+		if v < minVal {
+			minVal = v
+		}
+	}
+	rangeVal := maxVal - minVal
+
+	bucket := make([][]T, n)
+	for i := 0; i < n; i++ {
+		bucket[i] = make([]T, 0)
+	}
+
+	for _, v := range arr {
+		index := int(math.Floor(float64(n) * float64((v-minVal)/rangeVal)))
+		if index == n {
+			index--
+		}
+		bucket[index] = append(bucket[index], v)
+	}
+
+	for i := 0; i < n; i++ {
+		insertionSort(bucket[i])
+	}
+
+	sorted := make([]T, 0, n)
+	for i := 0; i < n; i++ {
+		sorted = append(sorted, bucket[i]...)
+	}
+
+	return sorted
+}

go-algorithm/pkg/sort/bucket_sort_test.go

@@ -0,0 +1,41 @@
+package sort
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_bucketSortInteger(t *testing.T) {
+	type args struct {
+		arr []int
+	}
+	tests := []struct {
+		name string
+		args args
+		want []int
+	}{
+		{
+			name: "Integer Case",
+			args: args{
+				arr: []int{31, 64, 49, 85, 71, 26, 6, 19},
+			},
+			want: []int{6, 19, 26, 31, 49, 64, 71, 85},
+		},
+		{
+			name: "Empty array input",
+			args: args{
+				arr: []int{},
+			},
+			want: []int{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := bucketSort(tt.args.arr)
+
+			assert.Equalf(t, tt.want, got, "bucketSort() got = %v, want %v", got, tt.want)
+		})
+	}
+}