Merge branch 'master' into tree-traversal-csharp-error

Author: henrikac

.devcontainer/Dockerfile

@@ -31,11 +31,10 @@ RUN sudo sh -c 'sudo dpkg -i packages-microsoft-prod.deb'
 RUN sudo sh -c 'rm packages-microsoft-prod.deb'
 
 # Setup D Lang
-RUN sudo sh -c 'mkdir -p ~/dlang && wget https://dlang.org/install.sh -O ~/dlang/install.sh'
-RUN sudo sh -c 'bash ~/dlang/install.sh'
-## From Docs not needed though
-# RUN sudo sh -c 'source ~/dlang/dmd-2.097.2/activate'
-ENV PATH=$PATH:/root/dlang/dmd-2.097.2/linux/bin64
+ENV DLANG_VERSION=2.097.2
+RUN mkdir -p ~/dlang && wget https://dlang.org/install.sh -O ~/dlang/install.sh
+RUN bash ~/dlang/install.sh dmd-$DLANG_VERSION
+ENV PATH=$PATH:~/dlang/dmd-$DLANG_VERSION/linux/bin64/
 
 # Setup Go
 RUN sudo sh -c 'wget -c https://dl.google.com/go/go1.14.2.linux-amd64.tar.gz -O - | sudo tar -xz -C /usr/local'
@@ -56,17 +55,14 @@ ENV PATH=$PATH:/usr/local/kotlinc/bin
 # Setup Matlab
 # ?????? This is a licensed language???
 
-# Setup Emojicode (in progress)
-RUN sudo sh -c 'wget -c https://github.com/emojicode/emojicode/releases/download/v1.0-beta.2/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz -O /usr/local/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz'
-RUN sudo tar -xvzf /usr/local/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz
-# && cd ~/emojicode/ && echo && ./install.sh'
-ENV PATH=$PATH:/usr/local/Emojicode-1.0-beta.2-Linux-x86_64
-
-# Setup Factor (in progress)
-RUN mkdir -p ~/factor && wget https://downloads.factorcode.org/releases/0.98/factor-linux-x86-64-0.98.tar.gz -O ~/factor/factor.tar.gz
-RUN tar -xzf /root/factor/factor.tar.gz
-# && rm ~/factor/factor.tar.gz
-ENV PATH=$PATH:/root/factor/factor
+# Setup Emojicode
+RUN mkdir -p ~/emojicode && wget -c https://github.com/emojicode/emojicode/releases/download/v1.0-beta.2/Emojicode-1.0-beta.2-Linux-x86_64.tar.gz -O ~/emojicode/emojicode.tar.gz && \
+    tar -xzf ~/emojicode/emojicode.tar.gz -C ~/emojicode --strip-components=1
+ENV PATH=$PATH:~/emojicode
+
+# Setup Factor
+RUN mkdir -p ~/factor && wget https://downloads.factorcode.org/releases/0.98/factor-linux-x86-64-0.98.tar.gz -O ~/factor/factor.tar.gz && tar -xzf ~/factor/factor.tar.gz -C ~/factor --strip-components=1
+ENV PATH=$PATH:~/factor/factor
 
 # Setup R
 RUN sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E298A3A825C0D65DFD57CBB651716619E084DAB9

CONTRIBUTORS.md

@@ -60,3 +60,4 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - Ridham177
 - Hugo Salou
 - Dimitri Belopopsky
++ Henrik Abel Christensen

contents/approximate_counting/code/c++/approximate_counting.cpp

@@ -61,11 +61,11 @@ auto test_approximate_count(
 int main() {
   std::cout << "Counting Tests, 100 trials\n";
 
-  std::cout << "testing 1,000, a = 30, 1% error "
+  std::cout << "testing 1,000, a = 30, 10% error "
             << test_approximate_count(100, 1000, 30, 0.1) << "\n";
-  std::cout << "testing 12,345, a = 10, 1% error "
+  std::cout << "testing 12,345, a = 10, 10% error "
             << test_approximate_count(100, 12345, 10, 0.1) << "\n";
   // Note : with a lower a, we need more trials, so a higher % error here.
-  std::cout << "testing 222,222, a = 0.5, 10% error "
+  std::cout << "testing 222,222, a = 0.5, 20% error "
             << test_approximate_count(100, 222222, 0.5, 0.2) << "\n";
 }

contents/approximate_counting/code/c/approximate_counting.c

@@ -71,11 +71,11 @@ int main()
     srand(time(NULL));
 
     printf("Counting Tests, 100 trials\n");
-    printf("testing 1000, a = 30, 1%% error\n");
+    printf("testing 1000, a = 30, 10%% error\n");
     test_approximation_count(100, 1000, 30, 0.1);
-    printf("testing 12345, a = 10, 1%% error\n");
+    printf("testing 12345, a = 10, 10%% error\n");
     test_approximation_count(100, 12345, 10, 0.1);
-    printf("testing 222222, a = 0.5, 10%% error\n");
+    printf("testing 222222, a = 0.5, 20%% error\n");
     test_approximation_count(100, 222222, 0.5, 0.2);
 
     return 0;

contents/approximate_counting/code/julia/approximate_counting.jl

@@ -51,11 +51,11 @@ function test_approximate_count(n_trials, n_items, a, threshold)
 end
 
 @testset "Counting Tests, 100 trials" begin
-    println("testing 1,000, a = 30, 1% error")
+    println("testing 1,000, a = 30, 10% error")
         test_approximate_count(100, 1000, 30, 0.1)
-    println("testing 12,345, a = 10, 1% error")
+    println("testing 12,345, a = 10, 10% error")
         test_approximate_count(100, 12345, 10, 0.1)
     # Note: with a lower a, we need more trials, so a higher % error here.
-    println("testing 222,222, a = 0.5, 10% error")
+    println("testing 222,222, a = 0.5, 20% error")
         test_approximate_count(100, 222222, 0.5, 0.2)
 end

contents/approximate_counting/code/python/approximate_counting.py

@@ -41,9 +41,9 @@ def test_approximate_count(n_trials, n_items, a, threshold):
     if abs((avg - n_items)/n_items) < threshold:
         print("passed")
 
-print("testing 1,000, a = 30, 1% error")
+print("testing 1,000, a = 30, 10% error")
 test_approximate_count(100, 1000, 30, 0.1)
-print("testing 12,345, a = 10, 1% error")
+print("testing 12,345, a = 10, 10% error")
 test_approximate_count(100, 12345, 10, 0.1)
-print("testing 222,222, a = 0.5, 10% error")
+print("testing 222,222, a = 0.5, 20% error")
 test_approximate_count(100, 222222, 0.5, 0.2)

contents/huffman_encoding/code/julia/huffman.jl

@@ -1,3 +1,5 @@
+using Test
+
 # This is for the PriorityQueue
 using DataStructures
 
@@ -13,8 +15,6 @@ struct Branch
 end
 
 const Node = Union{Leaf, Branch}
-isbranch(branch::Branch) = true
-isbranch(other::T) where {T} = false
 
 function codebook_recurse!(leaf::Leaf, code::String,
                           dict::Dict{Char,String})
@@ -33,7 +33,11 @@ end
 # This outputs encoding Dict to be used for encoding
 function create_codebook(n::Node)
     codebook = Dict{Char,String}()
-    codebook_recurse!(n, "", codebook)
+    if isa(n, Leaf)
+        codebook[n.key]="0"
+    else
+        codebook_recurse!(n, "", codebook)
+    end
     return codebook
 end
 
@@ -85,14 +89,19 @@ function decode(huffman_tree::Node, bitstring::String)
     current = huffman_tree
     final_string = ""
     for i in bitstring
-        if (i == '1')
-            current = current.left
+        if isa(huffman_tree, Branch)
+            if (i == '1')
+                current = current.left
+            else
+                current = current.right
+            end
+
+            if (!isa(current, Branch))
+                final_string *= string(current.key)
+                current = huffman_tree
+            end
         else
-            current = current.right
-        end
-        if (!isbranch(current))
-            final_string = final_string * string(current.key)
-            current = huffman_tree
+            final_string *= string(huffman_tree.key)
         end
     end
 
@@ -102,11 +111,13 @@ end
 function two_pass_huffman(phrase::String)
     huffman_tree = create_tree(phrase)
     codebook = create_codebook(huffman_tree)
-    println(codebook)
     bitstring = encode(codebook, phrase)
     final_string = decode(huffman_tree, bitstring)
-    println(bitstring)
-    println(final_string)
+    return final_string
 end
 
-two_pass_huffman("bibbity bobbity")
+@testset "b-string tests" begin
+    @test two_pass_huffman("b") == "b"
+    @test two_pass_huffman("bbbbbbbb") == "bbbbbbbb"
+    @test two_pass_huffman("bibbity bobbity") == "bibbity bobbity"
+end

contents/stacks_and_queues/code/java/Queue.java

@@ -0,0 +1,71 @@
+import java.util.List;
+import java.util.ArrayList;
+
+public class QueueTest {
+    
+    public static void main(String[] args) {
+	IQueue<Integer> intQueue = new Queue<>();
+
+	intQueue.enqueue(4);
+	intQueue.enqueue(5);
+	intQueue.enqueue(9);
+	
+	System.out.println(intQueue.dequeue());
+	System.out.println(intQueue.size());
+	System.out.println(intQueue.front());
+    }
+
+}
+
+
+interface IQueue<T> {
+
+   /*
+    * 'dequeue' removes the first element from the queue and returns it
+    */
+    T dequeue();
+
+   /*
+    * 'enqueue' adds an element at the end of the queue and returns the new size
+    */
+    int enqueue(T element);
+    
+
+   /*
+    * 'size' returns the size of the queue
+    */
+    int size();
+
+   /*
+    * 'front' returns the first element of the queue without removing it
+    */
+    T front();
+}
+
+
+public class Queue<T> implements  IQueue<T> {
+
+    private List<T> list;
+
+    public Queue() {
+        this.list = new ArrayList<>();
+    }
+
+    public T dequeue() {
+        return this.list.remove(0);
+    }
+
+    public int enqueue(T element) {
+        this.list.add(element);
+        return this.size();
+    }
+
+    public int size() {
+        return this.list.size();
+    }
+
+    public T front() {
+        return this.list.get(0);
+    }
+
+}

contents/stacks_and_queues/code/java/Stack.java

@@ -0,0 +1,72 @@
+import java.util.List;
+import java.util.ArrayList;
+
+
+public class StackTest {
+    
+    public static void main(String[] args) {
+	IStack<Integer> intStack = new Stack<>();
+
+	intStack.push(4);
+	intStack.push(5);
+	intStack.push(9);
+
+	System.out.println(intStack.pop());
+	System.out.println(intStack.size());
+	System.out.println(intStack.top());
+    }
+
+}
+
+
+interface IStack<T> {
+   /*
+    * 'pop' removed the last element from the stack and returns it
+    */
+    T pop();
+
+   /*
+    * 'push' adds an element to at the end of the stack and returns the new size
+    */
+    int push(T element);
+
+   /*
+    * 'size' returns the length of the stack
+    */
+    int size();
+
+   /*
+    * 'top' returns the first element of the stack
+    */
+    T top();
+}
+
+
+public class Stack<T> implements IStack<T> {
+    
+    private List<T> list;
+
+    public Stack() {
+        this.list = new ArrayList<>();
+    }
+
+    public T pop() {
+        return this.list.remove(this.size() - 1);
+    }
+
+    public int push(T element) {
+        this.list.add(element);
+        return this.size();
+    }
+
+    public int size() {
+        return this.list.size();
+    }
+
+    public T top() {
+        return this.list.get(this.size() - 1);
+    }
+
+}
+
+

contents/stacks_and_queues/stacks_and_queues.md

@@ -18,12 +18,16 @@ Here is a simple implementation of a stack:
 {% method %}
 {% sample lang="ts" %}
 [import, lang:"typescript"](code/typescript/stack.ts)
+{% sample lang="java" %}
+[import, lang:"java"](code/java/Stack.java)
 {% endmethod %}
 
 Here is a simple implementation of a queue:
 {% method %}
 {% sample lang="ts" %}
 [import, lang:"typescript"](code/typescript/queue.ts)
+{% sample lang="java" %}
+[import, lang:"java" ](code/java/Queue.java)
 {% endmethod %}