Merge branch 'master' into jarvis_march_cpp

Author: leios

CONTRIBUTING.md

@@ -0,0 +1,8 @@
+# Contributing
+
+A contribution guide on how to contribute to the Arcane Algorithm Archive (AAA) can be found on this Wiki page:
+https://github.com/algorithm-archivists/algorithm-archive/wiki/How-to-Contribute
+
+The community member Buttercak3 also created a video series, explaining the contribution process of the AAA.
+You can find a playlist with all videos here:
+https://www.youtube.com/playlist?list=PL5NSPcN6fRq2vwgdb9noJacF945CeBk8x

CONTRIBUTORS.md

@@ -1,3 +1,7 @@
+This file lists everyone, who contributed to this repo and wanted to show up here. If you're looking for information on contribution, please check the `CONTRIBUTING.md` out.
+
+# Contributors
+
 James Schloss
 <br>
 Nicole Mazzuca
@@ -46,3 +50,8 @@ Gibus Wearing Brony
 <br>
 Gorzoid
 <br>
+Arun Sahadeo
+<br>
+NIFR91
+<br>
+Michal Hanajik

README.md

@@ -15,7 +15,7 @@ and live coded on Twitch: https://www.twitch.tv/simuleios.
 If you would like to communicate more directly, please feel free to go to our discord: https://discord.gg/Pr2E9S6.
 
 
-Note that the this project is is essentially a book about algorithms collaboratively written by an online community.
+Note that the this project is essentially a book about algorithms collaboratively written by an online community.
 Fortunately, there are a lot of algorithms out there, which means that there is a lot of content material available.
 Unfortunately, this means that we will probably never cover every algorithm ever created and instead need to focus on what the community sees as useful and necessary.
 That said, we'll still cover a few algorithms for fun that have very little, if any practical purpose.

book.json

@@ -33,10 +33,6 @@
           "name": "Julia",
           "default": true
         },
-        {
-          "lang": "pseudo",
-          "name": "Pseudocode"
-        },
         {
           "lang": "cs",
           "name": "C#"
@@ -116,6 +112,18 @@
         {
           "lang": "ti83b",
           "name": "TI-83 Basic"
+        },
+        {
+          "lang": "lua",
+          "name": "Lua"
+        },
+        {
+          "lang": "crystal",
+          "name": "Crystal"
+        },
+        {
+          "lang": "php",
+          "name": "PHP"
         }
       ]
     }

contents/bogo_sort/bogo_sort.md

@@ -14,19 +14,55 @@ In code, it looks something like this:
 
 {% method %}
 {% sample lang="jl" %}
-[import:1-14, lang:"julia"](code/julia/bogo.jl)
+[import:10-14, lang:"julia"](code/julia/bogo.jl)
 {% sample lang="cs" %}
 [import:9-15, lang:"csharp"](code/csharp/BogoSort.cs)
 {% sample lang="clj" %}
-[import:2-11, lang:"clojure"](code/clojure/bogo.clj)
+[import:7-11, lang:"clojure"](code/clojure/bogo.clj)
 {% sample lang="c" %}
-[import:4-29, lang:"c_cpp"](code/c/bogo_sort.c)
+[import:25-29, lang:"c_cpp"](code/c/bogo_sort.c)
 {% sample lang="java" %}
-[import:2-17, lang:"java"](code/java/bogo.java)
+[import:2-6, lang:"java"](code/java/bogo.java)
 {% sample lang="js" %}
-[import:1-16, lang:"javascript"](code/javascript/bogo.js)
+[import:11-15, lang:"javascript"](code/javascript/bogo.js)
 {% sample lang="py" %}
-[import:4-12, lang:"python"](code/python/bogo.py)
+[import:10-12, lang:"python"](code/python/bogo.py)
+{% sample lang="hs" %}
+[import:17-20, lang:"haskell"](code/haskell/bogoSort.hs)
+{% sample lang="m" %}
+[import:21-28, lang:"matlab"](code/matlab/bogosort.m)
+{% sample lang="cpp" %}
+[import:33-38, lang:"c_cpp"](code/c++/bogosort.cpp)
+{% sample lang="rs" %}
+[import:16-20, lang:"rust"](code/rust/bogosort.rs)
+{% sample lang="swift" %}
+[import:25-31, lang:"swift"](code/swift/bogosort.swift)
+{% endmethod %}
+
+That's it.
+Ship it!
+We are done here!
+
+## Example Code
+
+{% method %}
+{% sample lang="jl" %}
+[import, lang:"julia"](code/julia/bogo.jl)
+{% sample lang="cs" %}
+BogoSort.cs
+[import, lang:"csharp"](code/csharp/BogoSort.cs)
+Program.cs
+[import, lang:"csharp"](code/csharp/Program.cs)
+{% sample lang="clj" %}
+[import, lang:"clojure"](code/clojure/bogo.clj)
+{% sample lang="c" %}
+[import, lang:"c_cpp"](code/c/bogo_sort.c)
+{% sample lang="java" %}
+[import, lang:"java"](code/java/bogo.java)
+{% sample lang="js" %}
+[import, lang:"javascript"](code/javascript/bogo.js)
+{% sample lang="py" %}
+[import, lang:"python"](code/python/bogo.py)
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/bogoSort.hs)
 {% sample lang="m" %}
@@ -39,10 +75,6 @@ In code, it looks something like this:
 [import, lang:"swift"](code/swift/bogosort.swift)
 {% endmethod %}
 
-That's it.
-Ship it!
-We are done here!
-
 
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);

contents/bogo_sort/code/java/bogo.java

@@ -1,5 +1,4 @@
 public class Bogo {
-    // The shuffle() function can be found in code/java/bogo.java
     static void bogoSort(int[] arr) {
         while(!isSorted(arr)) {
             shuffle(arr);
@@ -26,7 +25,6 @@ static void shuffle(int[] arr) {
     }
 
 
-    // main function (for testing)
     public static void main(String[] args) {
         int[] test = new int[]{20, -3, 50, 1, -6, 59};
 

contents/bogo_sort/code/javascript/bogo.js

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

contents/bogo_sort/code/swift/bogosort.swift

@@ -1,40 +1,32 @@
 import Foundation
 
-
 func isSorted(inputArray: [Int]) -> Bool {
-
     for i in 0..<inputArray.count-1 {
         if inputArray[i] > inputArray[i+1] {
             return false
         }
     }
-
+    
     return true
 }
 
-
-
 func shuffle(inputArray: inout [Int]) -> [Int] {
-    
     var shuffledArray = [Int]()
 
     for _ in 0..<inputArray.count {
         let rand = Int(arc4random_uniform(UInt32(inputArray.count)))
         shuffledArray.append(inputArray[rand])
         inputArray.remove(at: rand)
     }
-
+    
     return shuffledArray
 }
 
-
-
 func bogoSort(sortArray: inout [Int]) -> [Int] {
-
     while(!isSorted(inputArray: sortArray)) {
         sortArray = shuffle(inputArray: &sortArray)
     }
-
+    
     return sortArray
 }
 

contents/bubble_sort/bubble_sort.md

@@ -13,7 +13,7 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="cs" %}
 [import:9-27, lang:"csharp"](code/csharp/BubbleSort.cs)
 {% sample lang="c" %}
-[import:11-21, lang:"c_cpp"](code/c/bubble_sort.c)
+[import:10-20, lang:"c_cpp"](code/c/bubble_sort.c)
 {% sample lang="java" %}
 [import:2-12, lang:"java"](code/java/bubble.java)
 {% sample lang="js" %}
@@ -25,26 +25,75 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="hs" %}
 [import, lang:"haskell"](code/haskell/bubbleSort.hs)
 {% sample lang="cpp" %}
-[import, lang:"c_cpp"](code/c++/bubblesort.cpp)
+[import:13-23, lang:"c_cpp"](code/c++/bubblesort.cpp)
 {% sample lang="rs" %}
-[import:6-19, lang:"rust"](code/rust/bubble_sort.rs)
+[import:6-16, 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:"golang"](code/go/bubbleSort.go)
 {% sample lang="racket" %}
-[import:5-19, lang:"racket"](code/racket/bubbleSort.rkt)
+[import:6-19, lang:"racket"](code/racket/bubbleSort.rkt)
 {% sample lang="swift" %}
-[import, lang:"swift"](code/swift/bubblesort.swift)
+[import:1-13, lang:"swift"](code/swift/bubblesort.swift)
 {% sample lang="ti83b" %}
 [import:2-13, lang:"ti-83_basic"](code/ti83basic/BUBLSORT.txt)
+{% sample lang="ruby" %}
+[import:3-13, lang:"ruby"](code/ruby/bubble.rb)
+{% sample lang="crystal" %}
+[import:1-11, lang:"crystal"](code/crystal/bubble.cr)
+{% sample lang="php" %}
+[import:3-15, lang:"php"](code/php/bubble_sort.php)
 {% endmethod %}
 
 ... And that's it for the simplest bubble sort method.
 Now, as you might imagine, computer scientists have optimized this to the fiery lakes of Michigan and back, so we'll come back to this in the future and talk about how to optimize it.
 For now, it's fine to just bask in the simplicity that is bubble sort.
 Trust me, there are plenty of more complicated algorithms that do precisely the same thing, only much, much better (for most cases).
 
+## Example Code
+
+{% method %}
+{% sample lang="jl" %}
+[import, lang:"julia"](code/julia/bubble.jl)
+{% sample lang="cs" %}
+BubbleSort.cs
+[import, lang:"csharp"](code/csharp/BubbleSort.cs)
+Program.cs
+[import, lang:"csharp"](code/csharp/Program.cs)
+{% sample lang="c" %}
+[import, lang:"c_cpp"](code/c/bubble_sort.c)
+{% sample lang="java" %}
+[import, lang:"java"](code/java/bubble.java)
+{% sample lang="js" %}
+[import, lang:"javascript"](code/javascript/bubble.js)
+{% sample lang="py" %}
+[import, lang:"python"](code/python/bubblesort.py)
+{% sample lang="m" %}
+[import, lang:"matlab"](code/matlab/bubblesort.m)
+{% sample lang="hs" %}
+[import, lang:"haskell"](code/haskell/bubbleSort.hs)
+{% sample lang="cpp" %}
+[import, lang:"c_cpp"](code/c++/bubblesort.cpp)
+{% sample lang="rs" %}
+[import, lang:"rust"](code/rust/bubble_sort.rs)
+{% sample lang="d" %}
+[import, lang:"d"](code/d/bubble_sort.d)
+{% sample lang="go" %}
+[import, lang:"golang"](code/go/bubbleSort.go)
+{% sample lang="racket" %}
+[import, lang:"racket"](code/racket/bubbleSort.rkt)
+{% sample lang="swift" %}
+[import, lang:"swift"](code/swift/bubblesort.swift)
+{% sample lang="ti83b" %}
+[import, lang:"ti-83_basic"](code/ti83basic/BUBLSORT.txt)
+{% sample lang="ruby" %}
+[import, lang:ruby"](code/ruby/bubble.rb)
+{% sample lang="crystal" %}
+[import, lang:"crystal"](code/crystal/bubble.cr)
+{% sample lang="php" %}
+[import, lang:"php"](code/php/bubble_sort.php)
+{% endmethod %}
 
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);

contents/bubble_sort/code/c++/bubblesort.cpp

@@ -2,70 +2,34 @@
 #include <cstddef>
 #include <iostream>
 #include <iterator>
-#include <random>
-
-using std::begin;
-using std::end;
-
-template <class Rng>
-std::vector<float> generate_input(std::size_t size, Rng& rng) {
-  auto dist = std::uniform_real_distribution<>(0.0, 1.0);
-
-  auto ret = std::vector<float>();
-  std::generate_n(std::back_inserter(ret), size,
-    [&rng, &dist] { return dist(rng); });
-
-  return ret;
-}
 
 template <class Iter>
-void print_range(std::ostream& os, Iter const first, Iter const last) {
-  os << '{';
-
-  if (first != last) {
-    os << *first;
-    std::for_each(first + 1, last, [&os] (double d) { os << ", " << d; });
-  }
-
-  os << "}\n";
+void print_range(Iter first, Iter last) {
+  for (auto it = first; it != last; ++it)
+    std::cout << *it << " ";
+  std::cout << std::endl;
 }
 
 template <class Iter>
-void bubble_sort(Iter const first, Iter const last) {
-  if (first == last) {
-    // the empty range is vacuously sorted
-    return;
-  }
-
-  for (;;) {
-    bool is_sorted = true;
-
-    for (auto it = first; it + 1 != last; ++it) {
+void bubble_sort(Iter first, Iter last) {
+  for (auto it1 = first; it1 != last; ++it1) {
+    for (auto it2 = first; it2 + 1 != last; ++it2) {
       // these are unsorted! gotta swap 'em
-      if (*(it + 1) < *it) {
-        using std::swap;
-        swap(*it, *(it + 1));
-        is_sorted = false;
+      if (*(it2 + 1) < *it2) {
+        std::iter_swap(it2, it2 + 1);
       }
     }
-
-    if (is_sorted) {
-      break;
-    }
   }
 }
 
 int main() {
-  std::random_device random_device;
-  auto rng = std::mt19937(random_device());
-
-  auto input = generate_input(10, rng);
+  int input[] = {1, 45, 756, 4569, 56, 3, 8, 5, -10, -4};
 
-  std::cout << "before sorting:\n";
-  print_range(std::cout, begin(input), end(input));
+  std::cout << "Unsorted array:\n";
+  print_range(std::begin(input), std::end(input));
 
-  bubble_sort(begin(input), end(input));
+  bubble_sort(std::begin(input), std::end(input));
 
-  std::cout << "\nafter sorting:\n";
-  print_range(std::cout, begin(input), end(input));
+  std::cout << "\nSorted array:\n";
+  print_range(std::begin(input), std::end(input));
 }