Removing All Language Headlines

chapters/algorithms/euclidean_algorithm/euclidean_algorithm.md

@@ -78,46 +78,34 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout
 
 {% method %}
 {% sample lang="c" %}
-### C
 [import, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-### C# #
 EuclideanAlgorithm.cs
 [import, lang="csharp"](code/csharp/EuclideanAlgorithm.cs)
 Program.cs
 [import, lang="csharp"](code/csharp/Program.cs)
 {% sample lang="clj" %}
-### Clojure
 [import 2-20, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
-### Cpp
 [import, lang="c_cpp"](code/c++/euclidean.cpp)
 {% sample lang="java" %}
-### Java
 EuclideanAlgo.java
 [import, lang="java"](code/java/EuclideanAlgo.java)
 MainClass.java
 [import, lang="java"](code/java/MainClass.java)
 {% sample lang="js" %}
-### JavaScript
 [import, lang="javascript"](code/javascript/euclidean_example.js)
 {% sample lang="py" %}
-### Python
 [import, lang="python"](code/python/euclidean_example.py)
 {% sample lang="haskell" %}
-### Haskell
 [import, lang="haskell"](code/haskell/euclidean_example.hs)
 {% sample lang="rs" %}
-### Rust
 [import, lang="rust"](code/rust/euclidean_example.rs)
 {% sample lang="ml" %}
-### Ocaml
 [import, lang="ocaml"](code/ocaml/euclidean_example.ml)
 {% sample lang="go" %}
-### Go
 [import, lang="golang"](code/go/euclidean.go)
 {% sample lang="swift" %}
-### Swift
 [import, lang="swift"](code/swift/euclidean_algorithm.swift)
 {% endmethod %}
 

chapters/algorithms/forward_euler_method/forward_euler_method.md

@@ -99,30 +99,23 @@ So, this time, let's remove ourselves from any physics and instead solve the fol
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/euler.jl)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/euler.c)
 {% sample lang="cpp" %}
-### C++
 [import, lang:"c_cpp"](code/c++/euler.cpp)
 {% sample lang="rs" %}
-### Rust
 [import, lang:"rust"](code/rust/euler.rs)
 {% sample lang="elm" %}
-### Elm
 [import:44-54, lang:"elm"](code/elm/euler.elm)
 [import:193-210, lang:"elm"](code/elm/euler.elm)
 
 Full code for the visualization follows:
 [import, lang:"elm"](code/elm/euler.elm)
 
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/euler.py)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/euler.hs)
 {% endmethod %}
 

chapters/algorithms/gaussian_elimination/gaussian_elimination.md

@@ -286,13 +286,10 @@ Now, as for what's next... Well, we are in for a treat! The above algorithm clea
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/gaussian_elimination.jl)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/gaussian_elimination.c)
 {% sample lang="rs" %}
-### Rust
 [import, lang:"rust"](code/rust/gaussian_elimination.rs)
 {% endmethod %}
 

chapters/algorithms/graham_scan/graham_scan.md

@@ -52,16 +52,12 @@ In the end, the code should look something like this:
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/graham.jl)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/grahamScan.hs)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/graham.c)
 {% sample lang="js" %}
-### Javascript
 [import, lang:"javascript"](code/javascript/graham-scan.js)
 {% endmethod %}
 

chapters/algorithms/huffman_encoding/huffman_encoding.md

@@ -55,37 +55,27 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/huffman.jl)
 {% sample lang="rs" %}
-### Rust
 [import, lang:"rust"](code/rust/huffman.rs)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/huffman.c)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/huffman.hs)
 {% sample lang="cs" %}
-### C# #
 HuffmanCoding.cs
 [import, lang:"csharp"](code/csharp/HuffmanCoding.cs)
 Program.cs
 [import, lang:"csharp"](code/csharp/Program.cs)
 {% sample lang="cpp" %}
-### C++
 [import, lang:"c_cpp"](code/c++/huffman.cpp)
 {% sample lang="clj" %}
-### Clojure
 [import 2-117, lang:"clojure"](code/clojure/huffman.clj)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/huffman.py)
 {% sample lang="js" %}
-### JavaScript
 [import, lang:"javascript"](code/javascript/huffman.js)
 {% sample lang="java" %}
-### Java
 [import, lang:"java"](code/java/huffman.java)
 {% endmethod %}
 

chapters/algorithms/jarvis_march/jarvis_march.md

@@ -24,25 +24,19 @@ Since this algorithm, there have been many other algorithms that have advanced t
 
 {% method %}
 {% sample lang="cs" %}
-### C# #
 JarvisMarch.cs
 [import, lang="csharp"](code/csharp/JarvisMarch.cs)
 Program.cs
 [import, lang="csharp"](code/csharp/Program.cs)
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/jarvis.jl)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/jarvisMarch.hs)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/jarvis_march.c)
 {% sample lang="js" %}
-### JavaScript
 [import, lang:"javascript"](code/javascript/jarvis-march.js)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/py/jarvisMarch.py)
 {% endmethod %}
 

chapters/algorithms/monte_carlo_integration/monte_carlo_integration.md

@@ -91,37 +91,26 @@ Feel free to submit your version via pull request, and thanks for reading!
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/monte_carlo.jl)
 {% sample lang="clj" %}
-### Clojure
 [import, lang:"clojure"](code/clojure/monte_carlo.clj)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/monte_carlo.c)
 {% sample lang="js" %}
-### Javascript
 [import, lang:"javascript"](code/javascript/monte_carlo.js)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/monteCarlo.hs)
 {%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)
 {%sample lang="r" %}
-### R
 [import, lang:"r"](code/r/monte_carlo.R)
 {% sample lang="java" %}
-### Java
 [import, lang:"java"](code/java/MonteCarlo.java)
 {% sample lang="swift" %}
-### Swift
 [import, lang:"swift"](code/swift/monte_carlo.swift)
 {% endmethod %}
 

chapters/algorithms/split-operator_method/split-operator_method.md

@@ -84,7 +84,6 @@ The Split-Operator method is one of the most commonly used quantum simulation al
 ## Example Code
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/split_op.jl)
 {% endmethod %}
 

chapters/algorithms/stable_marriage_problem/stable_marriage_problem.md

@@ -22,25 +22,18 @@ I am incredibly interested to see what you guys do and how you implement the alg
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/stable_marriage.jl)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/stable_marriage.py)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/stableMarriage.hs)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/stable_marriage.c)
 {% sample lang="cpp" %}
-### C++
 [import, lang:"c_cpp"](code/c++/stable_marriage.cpp)
 {% sample lang="js" %}
-### JavaScript
 [import, lang:"javascript"](code/javascript/stable-marriage.js)
 {% sample lang="cs" %}
-### C# #
 GaleShapleyAlgorithm.cs
 [import, lang:"csharp"](code/csharp/GaleShapleyAlgorithm.cs)
 Person.cs

chapters/algorithms/thomas_algorithm/thomas_algorithm.md

@@ -39,13 +39,10 @@ $$
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/thomas.jl)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/thomas.c)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/thomas.py)
 {% endmethod %}
 

chapters/algorithms/tree_traversal/tree_traversal.md

@@ -198,37 +198,30 @@ This has not been implemented in your chosen language, so here is the Julia code
 ## Example Code
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/Tree.jl)
 {% sample lang="cpp" %}
-### C++
 [import, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-### C# #
 Tree.cs
 [import, lang:"csharp"](code/csharp/Tree.cs)
 Program.cs
 [import, lang:"csharp"](code/csharp/Program.cs)
 {% sample lang="c" %}
-### C
 utility.h
 [import, lang:"c_cpp"](code/c/utility.h)
 tree_traversal.c
 [import, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
-### Java
 Tree.java
 [import, lang:"java"](code/java/Tree.java)
 MainClass.java
 [import, lang:"java"](code/java/MainClass.java)
 {% sample lang="js" %}
-### JavaScript
 [import, lang:"javascript"](code/javascript/tree.js)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/Tree_example.py)
 {% sample lang="scratch" %}
-### Scratch
+
 <p>
     <img  class="center" src="code/scratch/scratch_tree.png" />
 </p>

chapters/algorithms/verlet_integration/verlet_integration.md

@@ -170,25 +170,18 @@ Both of these methods work simply by iterating timestep-by-timestep and can be w
 
 {% method %}
 {% sample lang="jl" %}
-### Julia
 [import, lang:"julia"](code/julia/verlet.jl)
 {% sample lang="cpp" %}
-### C++
 [import, lang:"c_cpp"](code/c++/verlet.cpp)
 {% sample lang="c" %}
-### C
 [import, lang:"c_cpp"](code/c/verlet.c)
 {% sample lang="java" %}
-### Java
 [import, lang:"java"](code/java/verlet.java)
 {% sample lang="py" %}
-### Python
 [import, lang:"python"](code/python/verlet.py)
 {% sample lang="hs" %}
-### Haskell
 [import, lang:"haskell"](code/haskell/verlet.hs)
 {% sample lang="scratch" %}
-### Scratch
 Submitted by Jie
 <p>
     <img  class="center" src="code/scratch/verlet_scratch.png" />