Merge branch 'master' of github.com:jiegillet/algorithm-archive

Author: jiegillet

CONTRIBUTORS.md

@@ -8,3 +8,7 @@ Hitesh C
 Maxime Dherbécourt
 Jess 3Jane
 Pen Pal
+Chinmaya Mahesh
+Unlambder
+Kjetil Johannessen
+CDsigma

book.json

@@ -36,12 +36,8 @@
 					"name": "C"
 				},
 				{
-					"lang": "py2",
-					"name": "Python 2"
-				},
-				{
-					"lang": "py3",
-					"name": "Python 3"
+					"lang": "py",
+					"name": "Python"
 				},
 				{
 					"lang": "js",
@@ -82,6 +78,22 @@
 				{
 					"lang": "d",
 					"name": "D"
+				},
+				{
+					"lang": "go",
+					"name": "Go"
+				},
+				{
+					"lang": "swift",
+					"name": "Swift"
+				},
+				{
+					"lang": "racket",
+					"name": "Racket"
+				},
+				{
+					"lang": "m",
+					"name": "Matlab"
 				}
 
 			],

chapters/FFT/code/python2/fft.py renamed to chapters/FFT/code/python/fft.py

@@ -77,7 +77,7 @@ For some reason, though, putting code to this transformation really helped me fi
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="hs" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
 {% sample lang="scratch" %}
 [import:2-11, lang:"julia"](code/julia/fft.jl)
@@ -122,8 +122,8 @@ In the end, the code looks like:
 [import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 [import:6-19, lang:"haskell"](code/hs/fft.hs)
-{% sample lang="py2" %}
-[import:5-16, lang:"python"](code/python2/fft.py)
+{% sample lang="py" %}
+[import:5-16, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
 [import:14-31, lang:"julia"](code/julia/fft.jl)
 {% endmethod %}
@@ -230,9 +230,9 @@ Note: I implemented this in Julia because the code seems more straightforward in
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/hs/fft.hs)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang:"python"](code/python2/fft.py)
+[import, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
 ### Scratch
 Some rather impressive scratch code was submitted by Jie and can be found here: https://scratch.mit.edu/projects/37759604/#editor

chapters/FFT/cooley_tukey.md

@@ -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/code/go/euclidean.go

@@ -2,12 +2,9 @@ def euclid_mod(a, b):
 
     a = abs(a)
     b = abs(b)
-    temp = 0
 
     while b > 0:
-        temp = b
-        b = a % b
-        a = temp
+        a, b = b, a % b
 
     return a
 
@@ -24,6 +21,8 @@ def euclid_sub(a, b):
 
     return a
 
-print euclid_mod(64 * 67, 64 * 81)
-print euclid_sub(128 * 12, 128 * 77)
+def main():
+    print(euclid_mod(64 * 67, 64 * 81))
+    print(euclid_sub(128 * 12, 128 * 77))
 
+main()

chapters/euclidean_algorithm/code/python2/euclidean_example.py renamed to chapters/euclidean_algorithm/code/python/euclidean_example.py

@@ -15,8 +15,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:20-33, lang="c_cpp"](code/c++/euclidean.cpp)
 {% sample lang="js" %}
 [import:15-29, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
-[import:14-25, lang="python"](code/python2/euclidean_example.py)
+{% sample lang="py" %}
+[import:11-22, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 [import:3-11, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
@@ -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="golang"](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:
@@ -46,8 +48,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:7-17, lang="c_cpp"](code/c++/euclidean.cpp)
 {% sample lang="js" %}
 [import:1-13, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
-[import:1-12, lang="python"](code/python2/euclidean_example.py)
+{% sample lang="py" %}
+[import:1-9, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 [import:13-24, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
@@ -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="golang"](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:
@@ -87,9 +91,9 @@ Program.cs
 {% sample lang="js" %}
 ### JavaScript
 [import, lang="javascript"](code/javascript/euclidean_example.js)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang="python"](code/python2/euclidean_example.py)
+[import, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
 ### Haskell
 [import, lang="haskell"](code/haskell/euclidean_example.hs)
@@ -102,6 +106,9 @@ Program.cs
 {% sample lang="java" %}
 ### Java
 [import, lang="java"](code/java/euclidean_example.java)
+{% sample lang="go" %}
+### Go
+[import, lang="golang"](code/go/euclidean.go)
 {% endmethod %}
 
 

chapters/euclidean_algorithm/euclidean.md

@@ -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/code/d/monte_carlo.d

@@ -0,0 +1,37 @@
+// Submitted by Chinmaya Mahesh (chin123)
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+)
+
+func inCircle(x, y float64) bool {
+	return x*x+y*y < 1.0 // the radius of an unit circle is 1.0
+}
+
+func monteCarlo(samples int) {
+	count := 0
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+
+	for i := 0; i < samples; i++ {
+		x, y := r.Float64(), r.Float64()
+
+		if inCircle(x, y) {
+			count += 1
+		}
+	}
+	
+	estimate := 4.0 * float64(count) / float64(samples)
+
+	fmt.Println("The estimate of pi is", estimate)
+	fmt.Printf("Which has an error of %f%%\n", 100*math.Abs(math.Pi-estimate)/math.Pi)
+}
+
+func main() {
+	monteCarlo(10000000)
+}

chapters/monte_carlo/code/go/monteCarlo.go

@@ -45,6 +45,10 @@ 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/d/monte_carlo.d)
+{% sample lang="go" %}
+[import:12-14, lang:"golang"](code/go/monteCarlo.go)
 {% endmethod %}
 
 If it's in the circle, we increase an internal count by one, and in the end,
@@ -88,6 +92,12 @@ 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)
+{%sample lang="d" %}
+### D
+[import, lang:"d"](code/d/monte_carlo.d)
+{%sample lang="go" %}
+### Go
+[import, lang:"golang"](code/go/monteCarlo.go)
 {% endmethod %}
 
 

chapters/monte_carlo/monte_carlo.md

@@ -52,17 +52,17 @@ def main():
     sim = Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Verlet:", sim.time
+    print("Verlet:", sim.time)
 
     sim = Stormer_Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Stormer Verlet:", sim.time
+    print("Stormer Verlet:", sim.time)
 
     sim = Velocity_Verlet(Ball(pos = 5.0, acc = -10))
     sim.run()
 
-    print "Velocity Verlet:", sim.time
+    print("Velocity Verlet:", sim.time)
 
 
 if __name__ == "__main__":

chapters/physics_solvers/verlet/code/python2/verlet.py renamed to chapters/physics_solvers/verlet/code/python/verlet.py

@@ -38,8 +38,8 @@ Here is what it looks like in code:
 [import:3-16, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:2-18, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:28-33, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:28-33, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in haskell, so here's Julia code:
 [import:1-13, lang:"julia"](code/julia/verlet.jl)
@@ -84,8 +84,8 @@ Here's what it looks like in code:
 [import:18-33, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:21-40, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:35-42, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:35-42, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in scratch, so here's Julia code:
 [import:15-31, lang:"julia"](code/julia/verlet.jl)
@@ -141,8 +141,8 @@ Here is the velocity Verlet method in code:
 [import:35-46, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
 [import:43-57, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
-[import:44-48, lang:"python"](code/python2/verlet.py)
+{% sample lang="py" %}
+[import:44-48, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 Unfortunately, this has not yet been implemented in haskell, so here's Julia code:
 [import:33-45, lang:"julia"](code/julia/verlet.jl)
@@ -181,9 +181,9 @@ Both of these methods work simply by iterating timestep-by-timestep and can be w
 {% sample lang="java" %}
 ### Java
 [import, lang:"java"](code/java/verlet.java)
-{% sample lang="py2" %}
+{% sample lang="py" %}
 ### Python
-[import, lang:"python"](code/python2/verlet.py)
+[import, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/haskell/verlet.hs)

chapters/physics_solvers/verlet/verlet.md

@@ -25,12 +25,18 @@ In code, it looks something like this:
 [import:2-17, lang:"java"](code/java/bogo.java)
 {% sample lang="js" %}
 [import:1-16, lang:"javascript"](code/js/bogo.js)
+{% sample lang="py" %}
+[import:4-12, lang:"python"](code/python/bogo.py)
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/bogoSort.hs)
+{% sample lang="m" %}
+[import, lang:"matlab"](code/matlab/bogosort.m)
 {% sample lang="cpp" %}
 [import, lang:"c_cpp"](code/c++/bogosort.cpp)
 {% sample lang="rs" %}
 [import, lang:"rust"](code/rust/bogosort.rs)
+{% sample lang="swift" %}
+[import, lang:"swift"](code/swift/bogosort.swift)
 {% endmethod %}
 
 That's it.