Merge branch 'master' into gaussian_elimination_julia

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
@@ -44,3 +48,10 @@ Max Weinstein
 <br>
 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

@@ -36,7 +36,7 @@ In code, it looks something like this:
 {% sample lang="rs" %}
 [import:16-20, lang:"rust"](code/rust/bogosort.rs)
 {% sample lang="swift" %}
-[import:32-39, lang:"swift"](code/swift/bogosort.swift)
+[import:25-31, lang:"swift"](code/swift/bogosort.swift)
 {% endmethod %}
 
 That's it.

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

@@ -25,7 +25,7 @@ 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:33-56, lang:"c_cpp"](code/c++/bubblesort.cpp)
+[import:13-23, lang:"c_cpp"](code/c++/bubblesort.cpp)
 {% sample lang="rs" %}
 [import:6-16, lang:"rust"](code/rust/bubble_sort.rs)
 {% sample lang="d" %}
@@ -35,9 +35,15 @@ This means that we need to go through the vector $$\mathcal{O}(n^2)$$ times with
 {% sample lang="racket" %}
 [import:6-19, lang:"racket"](code/racket/bubbleSort.rkt)
 {% sample lang="swift" %}
-[import:1-12, 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.
@@ -81,6 +87,12 @@ Program.cs
 [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>

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));
 }

contents/bubble_sort/code/crystal/bubble.cr

@@ -0,0 +1,20 @@
+def bubble_sort(arr)
+  arr = arr.dup 
+  (0 ... arr.size).each do 
+    (0 ... arr.size-1).each do |k| 
+      if arr[k] > arr[k+1]
+        arr[k+1],arr[k] = arr[k],arr[k+1]
+      end
+    end
+  end 
+  arr
+end
+
+def main 
+  number = 10.times.map{rand(0..1_000)}.to_a 
+  pp "The array before sorting is #{number}"
+  number = bubble_sort number 
+  pp "The array after  sorting is #{number}"
+end 
+
+main

contents/bubble_sort/code/php/bubble_sort.php

@@ -0,0 +1,21 @@
+<?php
+
+function bubble_sort(array $arr): array
+{
+  for ($i = 0, $length = count($arr); $i < $length; $i++) {
+    for ($j = 1; $j < $length; $j++) {
+      if ($arr[$j - 1] > $arr[$j]) {
+        $tmp = $arr[$j - 1];
+        $arr[$j - 1] = $arr[$j];
+        $arr[$j] = $tmp;
+      }
+    }
+  }
+  return $arr;
+}
+
+$unsorted = [1, 2, 6, 47, 4, 9, 3, 7, 8, 23, 15];
+$bubble_sorted = bubble_sort($unsorted);
+
+echo sprintf('Unsorted: %s%s', implode(',', $unsorted), PHP_EOL);
+echo sprintf('Sorted: %s%s', implode(',', $bubble_sorted), PHP_EOL);

contents/bubble_sort/code/ruby/bubble.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+def bubble_sort(arr)
+	(0..arr.length - 1).each do
+		(0..arr.length - 2).each do |k|
+			if arr[k] > arr[k + 1]
+				arr[k + 1], arr[k] = arr[k], arr[k + 1]
+			end
+		end
+	end
+
+	return arr
+end
+
+def main
+	range = [200, 79, 69, 45, 32, 5, 15, 88, 620, 125]	
+	puts "The range before sorting is #{range}"
+	range = bubble_sort(range)
+	puts "The range after sorting is #{range}"
+end
+
+main()

contents/bubble_sort/code/swift/bubblesort.swift

@@ -1,5 +1,4 @@
 func bubbleSort(sortArray: inout [Int]) -> [Int] {
-    
     for i in (1..<sortArray.count).reversed() {
         for j in 0..<i {
             if sortArray[j] > sortArray[j+1] {

contents/euclidean_algorithm/code/lua/euclidean.lua

@@ -0,0 +1,32 @@
+function euclidSub (a, b)
+  local a = math.abs(a)
+  local b = math.abs(b)
+
+  while a ~= b do
+    if a > b then
+      a = a-b
+    else
+      b = b-a
+    end
+  end
+
+  return a
+end
+
+function euclidMod (a, b)
+  local a = math.abs(a)
+  local b = math.abs(b)
+
+  while b ~= 0 do
+    a, b = b, a%b
+  end
+
+  return a
+end
+
+function main ()
+  print(euclidSub(128 * 12, 128 * 77))
+  print(euclidMod(64 * 67, 64 * 81))
+end
+
+main()