Project Euler: First Twenty solutions

project_euler/problem_1/problem1.go

@@ -0,0 +1,24 @@
+/**
+ * Problem 1 - Multiples of 3 and 5
+ *
+ * @see {@link https://projecteuler.net/problem=1}
+ *
+ * If we list all the natural numbers below 10 that are multiples of 3 or 5,
+ * we get 3, 5, 6 and 9. The sum of these multiples is 23.
+ * Find the sum of all the multiples of 3 or 5 below 1000.
+ *
+ * @author ddaniel27
+ */
+package problem1
+
+func Problem1(n uint) uint {
+	sum := uint(0)
+
+	for i := uint(1); i < n; i++ {
+		if i%3 == 0 || i%5 == 0 {
+			sum += i
+		}
+	}
+
+	return sum
+}

project_euler/problem_1/problem1_test.go

@@ -0,0 +1,45 @@
+package problem1
+
+import "testing"
+
+// Tests
+func TestProblem1_Func(t *testing.T) {
+	tests := []struct {
+		name      string
+		threshold uint
+		want      uint
+	}{
+		{
+			name:      "Testcase 1 - threshold 10",
+			threshold: 10,
+			want:      23,
+		},
+		{
+			name:      "Testcase 2 - threshold 100",
+			threshold: 100,
+			want:      2318,
+		},
+		{
+			name:      "Testcase 3 - threshold 1000",
+			threshold: 1000,
+			want:      233168,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			n := Problem1(tt.threshold)
+
+			if n != tt.want {
+				t.Errorf("Problem1() = %v, want %v", n, tt.want)
+			}
+		})
+	}
+}
+
+// Benchmarks
+func BenchmarkProblem1(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = Problem1(1000)
+	}
+}

project_euler/problem_10/problem10.go

@@ -0,0 +1,23 @@
+/**
+* Problem 10 - Summation of primes
+* @see {@link https://projecteuler.net/problem=10}
+*
+* The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+* Find the sum of all the primes below two million.
+*
+* @author ddaniel27
+ */
+package problem10
+
+import "github.com/TheAlgorithms/Go/math/prime"
+
+func Problem10(n int) uint {
+	sum := uint(0)
+	sieve := prime.SieveEratosthenes(n)
+
+	for _, v := range sieve {
+		sum += uint(v)
+	}
+
+	return sum
+}

project_euler/problem_10/problem10_test.go

@@ -0,0 +1,40 @@
+package problem10
+
+import "testing"
+
+// Tests
+func TestProblem10_Func(t *testing.T) {
+	tests := []struct {
+		name  string
+		input int
+		want  uint
+	}{
+		{
+			name:  "Testcase 1 - input 10",
+			input: 10,
+			want:  17,
+		},
+		{
+			name:  "Testcase 2 - input 2000000",
+			input: 2000000,
+			want:  142913828922,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			n := Problem10(tt.input)
+
+			if n != tt.want {
+				t.Errorf("Problem10() = %v, want %v", n, tt.want)
+			}
+		})
+	}
+}
+
+// Benchmarks
+func BenchmarkProblem10(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		_ = Problem10(2000000)
+	}
+}

project_euler/problem_11/problem11.go

@@ -0,0 +1,80 @@
+/**
+* Problem 11 - Largest product in a grid
+* @see {@link https://projecteuler.net/problem=11}
+*
+* In the 20×20 grid below, four numbers along a diagonal line have been marked in red.
+*
+* The product of these numbers is 26 × 63 × 78 × 14 = 1788696.
+*
+* What is the greatest product of four adjacent numbers in the same direction
+* (up, down, left, right, or diagonally) in the 20×20 grid?
+*
+* @author ddaniel27
+ */
+package problem11
+
+var grid = [20][20]uint{
+	{8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8},
+	{49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0},
+	{81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65},
+	{52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91},
+	{22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80},
+	{24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50},
+	{32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70},
+	{67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21},
+	{24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},
+	{21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95},
+	{78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92},
+	{16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57},
+	{86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},
+	{19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40},
+	{4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},
+	{88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},
+	{4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36},
+	{20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16},
+	{20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54},
+	{1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48},
+}
+
+func Problem11() uint {
+	max := uint(0)
+
+	for i := 0; i < 20; i++ {
+		for j := 0; j < 20; j++ {
+
+			// Vertical
+			if i+3 < 20 {
+				product := grid[i][j] * grid[i+1][j] * grid[i+2][j] * grid[i+3][j]
+				if product > max {
+					max = product
+				}
+			}
+
+			// Horizontal
+			if j+3 < 20 {
+				product := grid[i][j] * grid[i][j+1] * grid[i][j+2] * grid[i][j+3]
+				if product > max {
+					max = product
+				}
+			}
+
+			if i+3 < 20 && j+3 < 20 {
+				// Diagonal
+				product := grid[i][j] * grid[i+1][j+1] * grid[i+2][j+2] * grid[i+3][j+3]
+				if product > max {
+					max = product
+				}
+			}
+
+			if i+3 < 20 && j-3 >= 0 {
+				// Diagonal
+				product := grid[i][j] * grid[i+1][j-1] * grid[i+2][j-2] * grid[i+3][j-3]
+				if product > max {
+					max = product
+				}
+			}
+		}
+	}
+
+	return max
+}

project_euler/problem_11/problem11_test.go

@@ -0,0 +1,29 @@
+package problem11
+
+import "testing"
+
+// Tests
+func TestProblem11_Func(t *testing.T) {
+	testCases := []struct {
+		name     string
+		expected uint
+	}{
+		{"Test Case 1", 70600674},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := Problem11()
+			if actual != tc.expected {
+				t.Errorf("Expected: %v, but got %v", tc.expected, actual)
+			}
+		})
+	}
+}
+
+// Benchmark
+func BenchmarkProblem11_Func(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Problem11()
+	}
+}

project_euler/problem_12/problem12.go

@@ -0,0 +1,46 @@
+/**
+* Problem 12 - Highly divisible triangular number
+* @see {@link https://projecteuler.net/problem=12}
+*
+* The sequence of triangle numbers is generated by adding the natural numbers.
+* So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28.
+* The first ten terms would be:
+*
+* 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
+*
+* Let us list the factors of the first seven triangle numbers:
+*
+*  1: 1
+*  3: 1,3
+*  6: 1,2,3,6
+* 10: 1,2,5,10
+* 15: 1,3,5,15
+* 21: 1,3,7,21
+* 28: 1,2,4,7,14,28
+*
+* We can see that 28 is the first triangle number to have over five divisors.
+* What is the value of the first triangle number to have over five hundred divisors?
+*
+* @author ddaniel27
+ */
+package problem12
+
+func Problem12(limit uint) uint {
+	triangle := uint(0)
+	for i := uint(1); ; i++ {
+		triangle += i
+		if numDivisors(triangle) >= limit {
+			return triangle
+		}
+	}
+}
+
+func numDivisors(n uint) uint {
+	divisors := uint(0)
+	for i := uint(1); i*i <= n; i++ {
+		if n%i == 0 {
+			divisors += 2
+		}
+	}
+	return divisors
+}

project_euler/problem_12/problem12_test.go

@@ -0,0 +1,31 @@
+package problem12
+
+import "testing"
+
+func TestProblem12_Func(t *testing.T) {
+	tests := []struct {
+		name  string
+		input uint
+		want  uint
+	}{
+		{"Test Case 1", 6, 28},
+		{"Test Case 2", 7, 36},
+		{"Test Case 3", 11, 120},
+		{"Test Case 4", 500, 76576500},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual := Problem12(tt.input)
+			if actual != tt.want {
+				t.Errorf("Expected: %v, but got %v", tt.want, actual)
+			}
+		})
+	}
+}
+
+func BenchmarkProblem12_Func(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Problem12(500)
+	}
+}