Merge branch 'develop'

Author: codejsha

README.md

@@ -6,7 +6,7 @@
 
 [English](README.md) | [Korean](README_ko-KR.md)
 
-This repository is an implementation of algorithms, data structures, and problem-solving. These are written in C++, Python, Java, and Go, and each language uses the following test framework/package: [Google Test](https://google.github.io/googletest/)(C++), [pytest](https://docs.pytest.org/)(Python), [JUnit](https://junit.org/)(Java), [go test](https://pkg.go.dev/cmd/go)(Go). Run tests to perform methods/functions on the algorithmic logic.
+This repository is an implementation of algorithms, data structures, and problem-solving. These are written in C++, Python, Java, and Go, and each language uses the following test framework: [Google Test](https://google.github.io/googletest/)(C++), [pytest](https://docs.pytest.org/)(Python), [JUnit](https://junit.org/)(Java), [go test](https://pkg.go.dev/cmd/go)(Go). Run tests to perform methods/functions on the algorithmic logic.
 
 ## Project Environments
 
@@ -873,7 +873,7 @@ Math.abs(-34.5), Math.ceil(2.17), Math.floor(3.14), Math.max(x, -3), Math.min(x,
 - 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), [java](java-algorithm/src/main/java/com/example/algorithm/math), [go](go-algorithm/pkg/math) | Find the greatest common divisor of two numbers.
 - Integer factorization: [c++](cpp-algorithm/src/math), [java](java-algorithm/src/main/java/com/example/algorithm/math) | Integer factorization is the process of determining which prime numbers divide a given positive integer.
-- Least common multiple (LCM): [python](python-algorithm/algorithm/math), [java](java-algorithm/src/main/java/com/example/algorithm/math) | Find the least common multiple of two numbers.
+- Least common multiple (LCM): [python](python-algorithm/algorithm/math), [java](java-algorithm/src/main/java/com/example/algorithm/math), [go](go-algorithm/pkg/math) | Find the least common multiple of two numbers.
 - Miller-Rabin primality test, CLRS#31.8: [c++](cpp-algorithm/src/math) | Miller-Rabin primality test is a mathematical algorithm that finds whether a given number is prime.
 - Permutation: [c++](cpp-algorithm/src/math)(`Permutation`) | Find the permutation of a set of items.
 - Permutation, EPI#5.10: [c++](cpp-algorithm/src/math)(`ApplyPermutationWithAdditionalSpace`, `ApplyPermutationBySwap`) | Permute the elements of an array

go-algorithm/pkg/math/greatest_common_divisor.go

@@ -1,28 +1,20 @@
 package math
 
-type GCD interface {
-	gcd(a int, b int) int
-	gcdExtended(a int, b int) (int, int, int)
-}
-
-type NumberTuple struct {
-	a int // dividend
-	b int // divisor
-}
-
-// GCD finds the greatest common divisor of two numbers.
-func (n NumberTuple) gcd() int {
-	for n.b != 0 {
-		n.a, n.b = n.b, n.a%n.b
+// GCDEuclidean finds the greatest common divisor of two numbers with Euclidean algorithm.
+// The `a` is the dividend and `b` is the divisor.
+func GCDEuclidean(a, b int) int {
+	for b != 0 {
+		a, b = b, a%b
 	}
-	return n.a
+	return a
 }
 
-// GCDExtended finds the greatest common divisor of two numbers with extended Euclidean algorithm.
-func (n NumberTuple) gcdExtended() (int, int, int) {
-	if n.b == 0 {
-		return n.a, 1, 0
+// GCDEuclideanExtended finds the greatest common divisor of two numbers with extended Euclidean algorithm.
+// The `a` is the dividend and `b` is the divisor.
+func GCDEuclideanExtended(a, b int) (int, int, int) {
+	if b == 0 {
+		return a, 1, 0
 	}
-	d, x, y := NumberTuple{n.b, n.a % n.b}.gcdExtended()
-	return d, y, x - (n.a/n.b)*y
+	d, x, y := GCDEuclideanExtended(b, a%b)
+	return d, y, x - (a/b)*y
 }

go-algorithm/pkg/math/greatest_common_divisor_test.go

@@ -5,17 +5,17 @@ import (
 	"testing"
 )
 
-func TestGCD(t *testing.T) {
-	assert.Equal(t, 12, NumberTuple{24, 36}.gcd())
-	assert.Equal(t, 1, NumberTuple{17, 22}.gcd())
-	assert.Equal(t, 20, NumberTuple{120, 500}.gcd())
+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 TestGCDExtended(t *testing.T) {
-	d1, _, _ := NumberTuple{24, 36}.gcdExtended()
+func TestGCDEuclideanExtended(t *testing.T) {
+	d1, _, _ := GCDEuclideanExtended(24, 36)
 	assert.Equal(t, 12, d1)
-	d2, _, _ := NumberTuple{17, 22}.gcdExtended()
+	d2, _, _ := GCDEuclideanExtended(17, 22)
 	assert.Equal(t, 1, d2)
-	d3, _, _ := NumberTuple{120, 500}.gcdExtended()
+	d3, _, _ := GCDEuclideanExtended(120, 500)
 	assert.Equal(t, 20, d3)
 }

go-algorithm/pkg/math/least_common_multiple.go

@@ -0,0 +1,7 @@
+package math
+
+// LCM finds the least common multiple of two numbers.
+// The `a` and `b` are the numbers.
+func LCM(a, b int) int {
+	return a * b / GCDEuclidean(a, b)
+}

go-algorithm/pkg/math/least_common_multiple_test.go

@@ -0,0 +1,12 @@
+package math
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+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))
+}