Renamed some language code dirs for consistency (#224)

* Renamed code/js/ directories to code/javascript/

* Renamed code/hs/ directories to code/haskell/

* Renamed code/R/ directories to code/r/

* Updated a reference to a JS file in a code file

* Renamed code/cs/ directories to code/csharp/

Author: Butt4cak3

chapters/FFT/code/hs/fft.hs renamed to chapters/FFT/code/haskell/fft.hs

@@ -121,7 +121,7 @@ In the end, the code looks like:
 {% sample lang="cpp" %}
 [import:27-57, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
-[import:6-19, lang:"haskell"](code/hs/fft.hs)
+[import:6-19, lang:"haskell"](code/haskell/fft.hs)
 {% sample lang="py" %}
 [import:5-16, lang:"python"](code/python/fft.py)
 {% sample lang="scratch" %}
@@ -229,7 +229,7 @@ Note: I implemented this in Julia because the code seems more straightforward in
 [import, lang:"c_cpp"](code/c++/fft.cpp)
 {% sample lang="hs" %}
 ### Haskell
-[import, lang:"haskell"](code/hs/fft.hs)
+[import, lang:"haskell"](code/haskell/fft.hs)
 {% sample lang="py" %}
 ### Python
 [import, lang:"python"](code/python/fft.py)

chapters/FFT/cooley_tukey.md

@@ -26,9 +26,9 @@ Since this algorithm, there have been many other algorithms that have advanced t
 {% sample lang="cs" %}
 ### C# #
 JarvisMarch.cs
-[import, lang="csharp"](code/cs/JarvisMarch.cs)
+[import, lang="csharp"](code/csharp/JarvisMarch.cs)
 Program.cs
-[import, lang="csharp"](code/cs/Program.cs)
+[import, lang="csharp"](code/csharp/Program.cs)
 {% sample lang="jl" %}
 ### Julia
 [import, lang:"julia"](code/julia/jarvis.jl)

chapters/computational_geometry/gift_wrapping/jarvis_march/code/cs/JarvisMarch.cs renamed to chapters/computational_geometry/gift_wrapping/jarvis_march/code/csharp/JarvisMarch.cs

@@ -69,9 +69,9 @@ Whether you use a stack or straight-up recursion also depends on the language, b
 {% sample lang="cs" %}
 ### C# #
 HuffmanCoding.cs
-[import, lang:"csharp"](code/cs/HuffmanCoding.cs)
+[import, lang:"csharp"](code/csharp/HuffmanCoding.cs)
 Program.cs
-[import, lang:"csharp"](code/cs/Program.cs)
+[import, lang:"csharp"](code/csharp/Program.cs)
 {% sample lang="cpp" %}
 ### C++
 [import, lang:"c_cpp"](code/c++/huffman.cpp)

chapters/computational_geometry/gift_wrapping/jarvis_march/code/cs/Program.cs renamed to chapters/computational_geometry/gift_wrapping/jarvis_march/code/csharp/Program.cs

@@ -40,13 +40,13 @@ I am incredibly interested to see what you guys do and how you implement the alg
 {% sample lang="cs" %}
 ### C# #
 GaleShapleyAlgorithm.cs
-[import, lang:"csharp"](code/cs/GaleShapleyAlgorithm.cs)
+[import, lang:"csharp"](code/csharp/GaleShapleyAlgorithm.cs)
 Person.cs
-[import, lang:"csharp"](code/cs/Person.cs)
+[import, lang:"csharp"](code/csharp/Person.cs)
 Program.cs
-[import, lang:"csharp"](code/cs/Program.cs)
+[import, lang:"csharp"](code/csharp/Program.cs)
 ListExtensions.cs
-[import, lang:"csharp"](code/cs/ListExtensions.cs)
+[import, lang:"csharp"](code/csharp/ListExtensions.cs)
 {% endmethod %}
 
 <script>

chapters/computational_geometry/gift_wrapping/jarvis_march/jarvis_march.md

@@ -8,7 +8,7 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 {% sample lang="c" %}
 [import:17-30, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:8-23, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
+[import:8-23, lang="csharp"](code/csharp/EuclideanAlgorithm.cs)
 {% sample lang="clj" %}
 [import:2-8, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
@@ -41,7 +41,7 @@ Modern implementations, though, often use the modulus operator (%) like so
 {% sample lang="c" %}
 [import:4-16, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:25-39, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
+[import:25-39, lang="csharp"](code/csharp/EuclideanAlgorithm.cs)
 {% sample lang="clj" %}
 [import:9-13, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
@@ -79,9 +79,9 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout
 {% sample lang="cs" %}
 ### C# #
 EuclideanAlgorithm.cs
-[import, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
+[import, lang="csharp"](code/csharp/EuclideanAlgorithm.cs)
 Program.cs
-[import, lang="csharp"](code/cs/Program.cs)
+[import, lang="csharp"](code/csharp/Program.cs)
 {% sample lang="clj" %}
 ### Clojure
 [import 2-20, lang="clojure"](code/clojure/euclidean_example.clj)

chapters/data_compression/huffman/code/cs/HuffmanCoding.cs renamed to chapters/data_compression/huffman/code/csharp/HuffmanCoding.cs

@@ -44,7 +44,7 @@ each point is tested to see whether it's in the circle or not:
 {% sample lang="c" %}
 [import:7-9, lang:"c_cpp"](code/c/monte_carlo.c)
 {% sample lang="js" %}
-[import:2-6, lang:"javascript"](code/js/monte_carlo.js)
+[import:2-6, lang:"javascript"](code/javascript/monte_carlo.js)
 {% sample lang="hs" %}
 [import:7-7, lang:"haskell"](code/haskell/monteCarlo.hs)
 {% sample lang="rs" %}
@@ -54,7 +54,7 @@ each point is tested to see whether it's in the circle or not:
 {% sample lang="go" %}
 [import:12-14, lang:"golang"](code/go/monteCarlo.go)
 {% sample lang="r" %}
-[import:2-6, lang:"r"](code/R/monte_carlo.R)
+[import:2-6, lang:"r"](code/r/monte_carlo.R)
 {% sample lang="java" %}
 [import:13-15, lang:"java"](code/java/MonteCarlo.java)
 {% sample lang="swift" %}
@@ -101,7 +101,7 @@ Feel free to submit your version via pull request, and thanks for reading!
 [import, lang:"c_cpp"](code/c/monte_carlo.c)
 {% sample lang="js" %}
 ### Javascript
-[import, lang:"javascript"](code/js/monte_carlo.js)
+[import, lang:"javascript"](code/javascript/monte_carlo.js)
 {% sample lang="hs" %}
 ### Haskell
 [import, lang:"haskell"](code/haskell/monteCarlo.hs)
@@ -116,7 +116,7 @@ Feel free to submit your version via pull request, and thanks for reading!
 [import, lang:"golang"](code/go/monteCarlo.go)
 {%sample lang="r" %}
 ### R
-[import, lang:"r"](code/R/monte_carlo.R)
+[import, lang:"r"](code/r/monte_carlo.R)
 {% sample lang="java" %}
 ### Java
 [import, lang:"java"](code/java/MonteCarlo.java)

chapters/data_compression/huffman/code/cs/Program.cs renamed to chapters/data_compression/huffman/code/csharp/Program.cs

@@ -16,15 +16,15 @@ In code, it looks something like this:
 {% sample lang="jl" %}
 [import:1-14, lang:"julia"](code/julia/bogo.jl)
 {% sample lang="cs" %}
-[import:9-15, lang:"csharp"](code/cs/BogoSort.cs)
+[import:9-15, lang:"csharp"](code/csharp/BogoSort.cs)
 {% sample lang="clj" %}
 [import:2-11, lang:"clojure"](code/clojure/bogo.clj)
 {% sample lang="c" %}
 [import:4-29, lang:"c_cpp"](code/c/bogo_sort.c)
 {% sample lang="java" %}
 [import:2-17, lang:"java"](code/java/bogo.java)
 {% sample lang="js" %}
-[import:1-16, lang:"javascript"](code/js/bogo.js)
+[import:1-16, lang:"javascript"](code/javascript/bogo.js)
 {% sample lang="py" %}
 [import:4-12, lang:"python"](code/python/bogo.py)
 {% sample lang="hs" %}

chapters/data_compression/huffman/huffman.md

@@ -8,7 +8,7 @@ function isSorted(arr) {
   return true;
 }
 
-// The shuffle() function can be found in code/js/bogo.js
+// The shuffle() function can be found in code/javascript/bogo.js
 function bogoSort(arr) {
   while (!isSorted(arr)) {
     shuffle(arr);

chapters/decision_problems/stable_marriage/code/cs/GaleShapleyAlgorithm.cs renamed to chapters/decision_problems/stable_marriage/code/csharp/GaleShapleyAlgorithm.cs

@@ -11,13 +11,13 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="jl" %}
 [import:1-10, lang:"julia"](code/julia/bubble.jl)
 {% sample lang="cs" %}
-[import:9-27, lang:"csharp"](code/cs/BubbleSort.cs)
+[import:9-27, lang:"csharp"](code/csharp/BubbleSort.cs)
 {% sample lang="c" %}
 [import:4-22, lang:"c_cpp"](code/c/bubble_sort.c)
 {% sample lang="java" %}
 [import:2-12, lang:"java"](code/java/bubble.java)
 {% sample lang="js" %}
-[import:1-11, lang:"javascript"](code/js/bubble.js)
+[import:1-11, lang:"javascript"](code/javascript/bubble.js)
 {% sample lang="py" %}
 [import:4-9, lang:"python"](code/python/bubblesort.py)
 {% sample lang="m" %}

chapters/decision_problems/stable_marriage/code/cs/ListExtensions.cs renamed to chapters/decision_problems/stable_marriage/code/csharp/ListExtensions.cs

@@ -8,7 +8,7 @@ Trees are naturally recursive data structures, and because of this, we cannot ac
 {% sample lang="cpp" %}
 [import:15-18, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:7-11, lang:"csharp"](code/cs/Tree.cs)
+[import:7-11, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:7-11, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -35,7 +35,7 @@ Because of this, the most straightforward way to traverse the tree might be recu
 {% sample lang="cpp" %}
 [import:20-27, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:34-45, lang:"csharp"](code/cs/Tree.cs)
+[import:34-45, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:37-45, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -71,7 +71,7 @@ Now, in this case the first element searched through is still the root of the tr
 This has not been implemented in your chosen language, so here is the Julia code
 [import:18-26, lang:"julia"](code/julia/Tree.jl)
 {% sample lang="cs" %}
-[import:47-58, lang:"csharp"](code/cs/Tree.cs)
+[import:47-58, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:47-53, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -103,7 +103,7 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 This has not been implemented in your chosen language, so here is the Julia code
 [import:28-43, lang:"julia"](code/julia/Tree.jl)
 {% sample lang="cs" %}
-[import:60-79, lang:"csharp"](code/cs/Tree.cs)
+[import:60-79, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:55-73, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -144,7 +144,7 @@ In code, it looks like this:
 {% sample lang="cpp" %}
 [import:29-45, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:81-94, lang:"csharp"](code/cs/Tree.cs)
+[import:81-94, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:75-93, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -177,7 +177,7 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 {% sample lang="cpp" %}
 [import:47-61, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:96-109, lang:"csharp"](code/cs/Tree.cs)
+[import:96-109, lang:"csharp"](code/csharp/Tree.cs)
 {% sample lang="c" %}
 [import:95-113, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -206,9 +206,9 @@ This has not been implemented in your chosen language, so here is the Julia code
 {% sample lang="cs" %}
 ### C# #
 Tree.cs
-[import, lang:"csharp"](code/cs/Tree.cs)
+[import, lang:"csharp"](code/csharp/Tree.cs)
 Program.cs
-[import, lang:"csharp"](code/cs/Program.cs)
+[import, lang:"csharp"](code/csharp/Program.cs)
 {% sample lang="c" %}
 ### C
 utility.h