Add calculating factorial (#352)

Author: i-redbyte

math/factorial/factorial.go

@@ -0,0 +1,52 @@
+// factorial.go
+// description: Calculating factorial
+// details:
+// The factorial of a non-negative integer n, denoted by n!, is the product of all positive integers less than or equal to n - [Factorial](https://en.wikipedia.org/wiki/Factorial)
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see factorial_test.go
+
+// Package factorial describes algorithms Factorials calculations.
+package factorial
+
+func BruteForceFactorial(n int) int {
+	result := 1
+	for i := 2; i <= n; i++ {
+		result *= i
+	}
+	return result
+}
+
+func RecursiveFactorial(n int) int {
+	if n == 1 {
+		return 1
+	} else {
+		return n * RecursiveFactorial(n-1)
+	}
+}
+
+func CalculateFactorialUseTree(n int) int {
+	if n < 0 {
+		return 0
+	}
+	if n == 0 {
+		return 1
+	}
+	if n == 1 || n == 2 {
+		return n
+	}
+	return prodTree(2, n)
+}
+
+func prodTree(l int, r int) int {
+	if l > r {
+		return 1
+	}
+	if l == r {
+		return l
+	}
+	if r-l == 1 {
+		return l * r
+	}
+	m := (l + r) / 2
+	return prodTree(l, m) * prodTree(m+1, r)
+}

math/factorial/factorial_test.go

@@ -0,0 +1,81 @@
+// factorial_test.go
+// description: Test for calculating factorial
+// author(s) [red_byte](https://github.com/i-redbyte)
+// see factorial.go
+
+package factorial
+
+import "testing"
+
+func getTests() []struct {
+	name   string
+	n      int
+	result int
+} {
+	var tests = []struct {
+		name   string
+		n      int
+		result int
+	}{
+		{"5!", 5, 120},
+		{"3!", 3, 6},
+		{"6!", 6, 720},
+		{"12!", 12, 479001600},
+		{"1!", 1, 1},
+	}
+	return tests
+}
+
+func TestBruteForceFactorial(t *testing.T) {
+	tests := getTests()
+	for _, tv := range tests {
+		t.Run(tv.name, func(t *testing.T) {
+			result := BruteForceFactorial(tv.n)
+			if result != tv.result {
+				t.Errorf("Wrong result! Expected:%d, returned:%d ", tv.result, result)
+			}
+		})
+	}
+}
+
+func TestRecursiveFactorial(t *testing.T) {
+	tests := getTests()
+	for _, tv := range tests {
+		t.Run(tv.name, func(t *testing.T) {
+			result := RecursiveFactorial(tv.n)
+			if result != tv.result {
+				t.Errorf("Wrong result! Expected:%d, returned:%d ", tv.result, result)
+			}
+		})
+	}
+}
+
+func TestCalculateFactorialUseTree(t *testing.T) {
+	tests := getTests()
+	for _, tv := range tests {
+		t.Run(tv.name, func(t *testing.T) {
+			result := CalculateFactorialUseTree(tv.n)
+			if result != tv.result {
+				t.Errorf("Wrong result! Expected:%d, returned:%d ", tv.result, result)
+			}
+		})
+	}
+}
+
+func BenchmarkBruteForceFactorial(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		BruteForceFactorial(10)
+	}
+}
+
+func BenchmarkRecursiveFactorial(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		RecursiveFactorial(10)
+	}
+}
+
+func BenchmarkCalculateFactorialUseTree(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		RecursiveFactorial(10)
+	}
+}