Merge branch 'master' into master

Author: Mukundan314

CONTRIBUTORS.md

@@ -9,3 +9,4 @@ Maxime Dherbécourt
 Jess 3Jane
 Pen Pal
 Mukundan
+Chinmaya Mahesh

book.json

@@ -82,6 +82,10 @@
 				{
 					"lang": "d",
 					"name": "D"
+				},
+				{
+					"lang": "go",
+					"name": "Go"
 				}
 
 			],

chapters/euclidean_algorithm/code/go/euclidean.go

@@ -0,0 +1,46 @@
+// Submitted by Chinmaya Mahesh (chin123)
+
+package main
+
+import "fmt"
+
+func abs(a int) int {
+	if a < 0 {
+		a = -a
+	}
+	return a
+}
+
+func euclidMod(a, b int) int {
+	a = abs(a)
+	b = abs(b)
+
+	for b != 0 {
+		a, b = b, a%b
+	}
+
+	return a
+}
+
+func euclidSub(a, b int) int {
+	a = abs(a)
+	b = abs(b)
+
+	for a != b {
+		if a > b {
+			a -= b
+		} else {
+			b -= a
+		}
+	}
+
+	return a
+}
+
+func main() {
+	check1 := euclidMod(64*67, 64*81)
+	check2 := euclidSub(128*12, 128*77)
+
+	fmt.Println(check1)
+	fmt.Println(check2)
+}

chapters/euclidean_algorithm/euclidean.md

@@ -25,6 +25,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:9-17, lang="ocaml"](code/ocaml/euclidean_example.ml)
 {% sample lang="java" %}
 [import:9-22, lang="java"](code/java/euclidean_example.java)
+{% sample lang="go" %}
+[import:25-38, lang="go"](code/go/euclidean.go)
 {% endmethod %}
 
 Here, we simply line the two numbers up every step and subtract the lower value from the higher one every timestep. Once the two values are equal, we call that value the greatest common divisor. A graph of `a` and `b` as they change every step would look something like this:
@@ -56,6 +58,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:3-7, lang="ocaml"](code/ocaml/euclidean_example.ml)
 {% sample lang="java" %}
 [import:24-35, lang="java"](code/java/euclidean_example.java)
+{% sample lang="go" %}
+[import:14-23, lang="go"](code/go/euclidean.go)
 {% endmethod %}
 
 Here, we set `b` to be the remainder of `a%b` and `a` to be whatever `b` was last timestep. Because of how the modulus operator works, this will provide the same information as the subtraction-based implementation, but when we show `a` and `b` as they change with time, we can see that it might take many fewer steps:
@@ -102,6 +106,9 @@ Program.cs
 {% sample lang="java" %}
 ### Java
 [import, lang="java"](code/java/euclidean_example.java)
+{% sample lang="go" %}
+### Go
+[import, lang="go"](code/go/euclidean.go)
 {% endmethod %}
 
 

chapters/monte_carlo/code/d/monte_carlo.d

@@ -0,0 +1,29 @@
+///Returns true if a point (x, y) is in the circle with radius r
+bool inCircle(real x, real y)
+{
+    return x ^^ 2 + y ^^ 2 < 1.0;
+}
+
+///Calculate pi using monte carlo
+real monteCarloPI(ulong n)
+{
+    import std.algorithm : count;
+    import std.random : uniform01;
+    import std.range : generate, take;
+    import std.typecons : tuple;
+
+    auto piCount =  generate(() => tuple!("x", "y")(uniform01, uniform01))
+        .take(n)
+        .count!(a => inCircle(a.x, a.y));
+    return piCount * 4.0 / n;
+}
+
+void main()
+{
+    import std.math : abs, PI;
+    import std.stdio : writeln;
+
+    auto p = monteCarloPI(100_000);
+    writeln("Estimated pi: ", p);
+    writeln("Percent error: ", abs(p - PI) * 100 / PI);
+}

chapters/monte_carlo/monte_carlo.md

@@ -45,6 +45,8 @@ each point is tested to see whether it's in the circle or not:
 [import:7-7, lang:"haskell"](code/haskell/monteCarlo.hs)
 {% sample lang="rs" %}
 [import:7-9, lang:"rust"](code/rust/monte_carlo.rs)
+{% sample lang="d" %}
+[import:2-5, lang:"d"](code/rust/monte_carlo.d)
 {% endmethod %}
 
 If it's in the circle, we increase an internal count by one, and in the end,
@@ -88,6 +90,9 @@ Feel free to submit your version via pull request, and thanks for reading!
 {%sample lang="rs" %}
 ### Rust
 [import, lang:"rust"](code/rust/monte_carlo.rs)
+### D
+{%sample lang="d" %}
+[import, lang:"d"](code/d/monte_carlo.d)
 {% endmethod %}
 
 

chapters/sorting_searching/bubble/bubble_sort.md

@@ -26,6 +26,8 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 [import:6-19, lang:"rust"](code/rust/bubble_sort.rs)
 {% sample lang="d" %}
 [import:3-18, lang:"d"](code/d/bubble_sort.d)
+{% sample lang="go" %}
+[import:7-21, lang:"go"](code/go/bubbleSort.go)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.

chapters/sorting_searching/bubble/code/go/bubbleSort.go

@@ -0,0 +1,30 @@
+// Submitted by Chinmaya Mahesh (chin123)
+
+package main
+
+import "fmt"
+
+func bubbleSort(array []int) {
+	n := len(array)
+	for i := 0; i < n-1; i++ {
+		swapped := false
+		for j := 0; j < n-i-1; j++ {
+			if array[j] > array[j+1] {
+				array[j], array[j+1] = array[j+1], array[j]
+				swapped = true
+			}
+		}
+		if !swapped {
+			break
+		}
+	}
+}
+
+func main() {
+	array := [10]int{1, 45, 756, 4569, 56, 3, 8, 5, -10, -4}
+	fmt.Println("Unsorted array:", array)
+
+	bubbleSort(array[:])
+
+	fmt.Println("Sorted array:", array)
+}