Merge branch 'gaussianElimination' of https://github.com/jiegillet/algorithm-archive

Author: jiegillet

CONTRIBUTORS.md

@@ -5,10 +5,11 @@ Gathros
 Jeremie Gillet (- Jie -)
 Salim Khatib
 Hitesh C
+Shaurya
 Maxime Dherbécourt
 Jess 3Jane
 Pen Pal
 Chinmaya Mahesh
 Unlambder
 Kjetil Johannessen
-CDsigma
+CDsigma

README.md

@@ -2,9 +2,9 @@
 The Arcane Algorithm Archive is a collaborative effort to create a guide for all important algorithms in all languages.
 This goal is obviously too ambitious for a book of any size, but it is a great project to learn from and work on and will hopefully become an incredible resource for programmers in the future.
 The book can be found here: https://www.algorithm-archive.org/.
-The github repository can be found here: https://github.com/algorithm-archivists/algorithm-archive.
-Most algorithms have been covered on the youtube channel LeiosOS: https://www.youtube.com/user/LeiosOS
-and livecoded on Twitch: https://www.twitch.tv/simuleios.
+The GitHub repository can be found here: https://github.com/algorithm-archivists/algorithm-archive.
+Most algorithms have been covered on the YouTube channel LeiosOS: https://www.youtube.com/user/LeiosOS
+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.
 
 

chapters/QI/QI.md

@@ -18,11 +18,11 @@ There are many places to start an introduction to quantum information theory, so
 3. **Quantum computers in the wild:** Current experimental techniques to create a quantum computer and what makes them ill-suited as real quantum computers
 4. **A survey of current quantum algorithms:** There are a number of algorithms that promise fantastic advantages when performed on quantum computers and should really shake up the industry when they are finally experimentally realized.
 
-As a note, item 3 might seem out of place for a book on algorithms, and I would tend to agree; however, at this point there is a phenominal amount of research being done to realize the first truly quantum computer and there are a number of potential systems that could work for this purpose.
+As a note, item 3 might seem out of place for a book on algorithms, and I would tend to agree; however, at this point there is a phenomenal amount of research being done to realize the first truly quantum computer and there are a number of potential systems that could work for this purpose.
 These systems will change how we think about and interface with quantum computation in the future and it is important to discuss where the field might be heading and when we can expect quantum computers at home.
 
 Now, there are not too many languages that can compile quantum code.
-A while ago, we tried to make a quantum circuit compiler, which was modelled after the SPICE circuit simulator, but this was far from a computer language.
+A while ago, we tried to make a quantum circuit compiler, which was modeled after the SPICE circuit simulator, but this was far from a computer language.
 At this point in time, it is impossible to tell what quantum computing languages will look like when we finally have a truly quantum machine, so for the time being, we will not ask for community code for the chapters related to quantum information.
 
 basically, it's hard to imagine how to would adequately implement Shor's algorithm in C.

chapters/convolutions/convolutions.md

@@ -61,9 +61,9 @@ Now, let me tell you about a bit of black computational magic:
 
 That is crazy!
 It's also incredibly hard to explain, so let me do my best.
-As described in the chapter on [Fourier Transforms](chapters/FFT/cooley_tukey.md), Fourier Tranforms allow programmers to move from real space to frequency space.
+As described in the chapter on [Fourier Transforms](chapters/FFT/cooley_tukey.md), Fourier Transforms allow programmers to move from real space to frequency space.
 When we transform a wave into frequency space, we see a single peak in frequency space related to the frequency of that wave.
-No matter what function we send into a Fourier Transform, the frequency-space image can be interpreted as a seires of different waves with a specified frequency.
+No matter what function we send into a Fourier Transform, the frequency-space image can be interpreted as a series of different waves with a specified frequency.
 
 So here's the idea: if we take two functions $$f(x)$$ and $$g(x)$$ and move them to frequency space to be $$\hat f(\xi)$$ and $$\hat g(\xi)$$, we can then multiply those two functions and transform them back into a third function to blend the signals together.
 In this way, we will have a third function that relates the frequency-space images of the two input functions.

chapters/data_compression/huffman/code/java/huffman.java

@@ -0,0 +1,113 @@
+import java.util.*;
+
+class TreeNode {
+    String letter = "";
+    int frequency = 0;
+    TreeNode left = null, right = null;
+
+    public TreeNode(String letter, int frequency) {
+        this.letter = letter;
+        this.frequency = frequency;
+    }
+
+    public TreeNode(int frequency, TreeNode left, TreeNode right) {
+        this.frequency = frequency;
+        this.left = left;
+        this.right = right;
+    }
+}
+
+class HuffmanTree {
+    private Map<String, Integer> frequencyMap = new HashMap<>();
+    private Map<String, String> codeBook = new HashMap<>(), reverseCodeBook = new HashMap<>();
+    private TreeNode root;
+    private String stringToEncode;
+
+    public HuffmanTree(String stringToEncode) {
+        this.stringToEncode = stringToEncode;
+    }
+
+    public void createTree() {
+        for (int i = 0; i < stringToEncode.length(); i++) {
+            String key = Character.toString(stringToEncode.charAt(i));
+            if (!frequencyMap.containsKey(key)) {
+                frequencyMap.put(key, 1);
+            } else {
+                int frequency = frequencyMap.get(key) + 1;
+                frequencyMap.replace(key, frequency);
+            }
+        }
+        Queue<TreeNode> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(o -> o.frequency));
+        for (Map.Entry<String, Integer> m : frequencyMap.entrySet()) {
+            priorityQueue.add(new TreeNode(m.getKey(), m.getValue()));
+        }
+        while (priorityQueue.size() > 1) {
+            TreeNode left = priorityQueue.remove();
+            TreeNode right = priorityQueue.remove();
+            priorityQueue.add(new TreeNode(left.frequency + right.frequency, left, right));
+        }
+        root = priorityQueue.remove();
+    }
+
+    private void traverse(TreeNode node, StringBuilder code) {
+        if (node.left == null && node.right == null) {
+            codeBook.put(node.letter, code.toString());
+        }
+        if (node.left != null) {
+            traverse(node.left, code.append(0));
+            code.deleteCharAt(code.length() - 1);
+        }
+        if (node.right != null) {
+            traverse(node.right, code.append(1));
+            code.deleteCharAt(code.length() - 1);
+        }
+    }
+
+    public void printCodeBook() {
+        System.out.println("Code Book");
+        for (Map.Entry<String, String> m : codeBook.entrySet()) {
+            System.out.println(m.getKey() + "\t" + m.getValue());
+        }
+        System.out.println();
+    }
+
+    private void CodeBookReverse() {
+        for (Map.Entry<String, String> m : codeBook.entrySet()) {
+            reverseCodeBook.put(m.getValue(), m.getKey());
+        }
+    }
+
+    public String encode() {
+        traverse(root, new StringBuilder());
+        StringBuilder encode = new StringBuilder();
+        for (int i = 0; i < stringToEncode.length(); i++) {
+            String k = Character.toString(stringToEncode.charAt(i));
+            encode.append(codeBook.get(k));
+        }
+        printCodeBook();
+        return encode.toString();
+    }
+
+    public String decode(String encoded) {
+        StringBuilder decoded = new StringBuilder(), key = new StringBuilder();
+        CodeBookReverse();
+        for (int i = 0; i < encoded.length(); i++) {
+            key = key.append(encoded.charAt(i));
+            if (reverseCodeBook.containsKey(key.toString())) {
+                decoded.append(reverseCodeBook.get(key.toString()));
+                key = new StringBuilder();
+            }
+        }
+        return decoded.toString();
+    }
+}
+
+class Huffman {
+    public static void main(String[] args) {
+        HuffmanTree huffmanTree = new HuffmanTree("bibbity_bobbity");
+        huffmanTree.createTree();
+        String encoded = huffmanTree.encode();
+        System.out.println("Encoded String: " + encoded);
+        System.out.println("Decoded String: " + huffmanTree.decode(encoded));
+    }
+}

chapters/data_compression/huffman/huffman.md

@@ -118,9 +118,11 @@ Program.cs
 {% sample lang="js" %}
 ### JavaScript
 [import, lang:"javascript"](code/javascript/huffman.js)
+{% sample lang="java" %}
+### Java
+[import, lang:"java"](code/java/huffman.java)
 {% endmethod %}
 
-
 <script>
 MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
 </script>

chapters/differential_equations/euler/code/euler.m

@@ -0,0 +1,46 @@
+clc;clear;close all
+
+%==========================================================================
+% Define Function
+f =@(x) -3*x;
+
+% Define Initial and Final time
+tInit=0;
+tLast=5;
+
+% Define number of points
+N=1e2;
+
+% Set Initial Conditions
+yInit=1;
+%==========================================================================
+
+dt=(tLast-tInit)/(N-1); % Calculate dt
+t=[tInit:dt:tLast];     % Preallocate time array
+y=zeros(1,length(t));   % Preallocate solution array
+y(1)=yInit;             % Impose Initial Conditions
+
+% Loop over time
+for i=1:length(t)-1
+    
+    t(i+1) = t(i) + dt;             % Calculate next time 
+    y(i+1) = y(i) + f( y(i) )*dt;   % Update solution
+    
+end
+
+% Plot numerical solution
+plot(t,y)
+
+% Create analytical solution
+g=@(x) exp(-3*x);
+z=g(t);
+
+% Plot analytical solution on the same graph
+hold on
+plot(t,z,'--')
+
+% Set axis, title and legend
+xlabel('t');ylabel('y(t)');
+title('Analytical VS Numerical Solution')
+grid
+legend('Numerical','Analytical')

chapters/euclidean_algorithm/code/java/EuclideanAlgo.java

@@ -0,0 +1,27 @@
+// submitted by lolatomroflsinnlos, modified by xam4lor
+public class EuclideanAlgo {
+    public static int euclidSub(int a, int b) {
+        a = Math.abs(a);
+        b = Math.abs(b);
+        
+        while (a != b) {
+            if (a > b) {
+                a -= b;
+            } else {
+                b -= a;
+            }
+        }
+        
+        return a;
+    }
+    
+    public static int euclidMod(int a, int b) {
+        while (b != 0) {
+            int tmp = b;
+            b = a % b;
+            a = tmp;
+        }
+
+        return a;
+    }
+}

chapters/euclidean_algorithm/code/java/MainClass.java

@@ -0,0 +1,8 @@
+//submitted by lolatomroflsinnlos, modified by xam4lor
+public class MainClass {
+    public static void main(String[] args) {
+        System.out.println("Euclidean Algorithm :");
+        System.out.println(EuclideanAlgo.euclidMod(64 * 67, 64 * 81));
+        System.out.println(EuclideanAlgo.euclidSub(128 * 12, 128 * 77) + "\n");
+    }
+}

chapters/euclidean_algorithm/code/java/euclidean_example.java

@@ -13,6 +13,8 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:2-8, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
 [import:20-33, lang="c_cpp"](code/c++/euclidean.cpp)
+{% sample lang="java" %}
+[import:3-16, lang="java"](code/java/EuclideanAlgo.java)
 {% sample lang="js" %}
 [import:15-29, lang="javascript"](code/javascript/euclidean_example.js)
 {% sample lang="py" %}
@@ -23,8 +25,6 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 [import:3-15, lang="rust"](code/rust/euclidean_example.rs)
 {% sample lang="ml" %}
 [import:9-17, lang="ocaml"](code/ocaml/euclidean_example.ml)
-{% sample lang="java" %}
-[import:9-22, lang="java"](code/java/euclidean_example.java)
 {% sample lang="go" %}
 [import:25-38, lang="golang"](code/go/euclidean.go)
 {% endmethod %}
@@ -46,6 +46,8 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:9-13, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
 [import:7-17, lang="c_cpp"](code/c++/euclidean.cpp)
+{% sample lang="java" %}
+[import:18-26, lang="java"](code/java/EuclideanAlgo.java)
 {% sample lang="js" %}
 [import:1-13, lang="javascript"](code/javascript/euclidean_example.js)
 {% sample lang="py" %}
@@ -56,8 +58,6 @@ Modern implementations, though, often use the modulus operator (%) like so
 [import:17-27, lang="rust"](code/rust/euclidean_example.rs)
 {% sample lang="ml" %}
 [import:3-7, lang="ocaml"](code/ocaml/euclidean_example.ml)
-{% sample lang="java" %}
-[import:24-35, lang="java"](code/java/euclidean_example.java)
 {% sample lang="go" %}
 [import:14-23, lang="golang"](code/go/euclidean.go)
 {% endmethod %}
@@ -88,6 +88,12 @@ Program.cs
 {% 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)
@@ -103,10 +109,6 @@ Program.cs
 {% sample lang="ml" %}
 ### Ocaml
 [import, lang="ocaml"](code/ocaml/euclidean_example.ml)
-{% sample lang="java" %}
-### Java
-[import, lang="java"](code/java/euclidean_example.java)
-{% sample lang="go" %}
 ### Go
 [import, lang="golang"](code/go/euclidean.go)
 {% endmethod %}

chapters/euclidean_algorithm/euclidean.md

@@ -1,6 +1,6 @@
 # My Introduction to Hobby Programming
 
-Here's the thing. I love programming. I know it's fun, interactive, and addictive, but it's hard to see that when you are looking through a pair of spectacles that sees the world ever-so-slightly differently than mine. For that reason, I feel I should start with my own introduction to the world of computer science, with the hope of inspiring you to share your own story. Full disclosure: this story is a decade old and involved linux. In fact, the open source community was one of the main reasons I ever became interested in hobby programming to begin with. Regardless, let's start at the start.
+Here's the thing. I love programming. I know it's fun, interactive, and addictive, but it's hard to see that when you are looking through a pair of spectacles that sees the world ever-so-slightly differently than mine. For that reason, I feel I should start with my own introduction to the world of computer science, with the hope of inspiring you to share your own story. Full disclosure: this story is a decade old and involved Linux. In fact, the open source community was one of the main reasons I ever became interested in hobby programming to begin with. Regardless, let's start at the start.
 
 I don't know if you guys had a similar childhood to mine or not, but I found that no matter who I spoke to, there was one central theme in all of our lives -- something so fundamental to the way we communicated with each other that it was nearly impossible to have a discussion without bringing it up: **Video Games**.
 
@@ -12,11 +12,11 @@ Being the curious kid I was, I asked what I should do to avoid Vista and they sa
 
 My friends could have just said, "It's the thing that operates your hardware. It brings up the UI elements and stuff you work with." Sure, it's not quite the whole story, but as a computer novice, it would have been just fine for me. That said, they took it a step further and said, "Nowadays, there are many operating systems to choose from, including Windows, Mac, and Linux." I may have been a complete novice, but I at least knew about Windows and Mac. Linux, though? What the heck was that?
 
-Of course I asked about it, but this was early high school. My friends may have been smarter than I was, but there was a limit to their knowledge. Apparently, the only thing they knew about linux was that it was supposedly faster and couldn't catch viruses. That caught me.
+Of course I asked about it, but this was early high school. My friends may have been smarter than I was, but there was a limit to their knowledge. Apparently, the only thing they knew about Linux was that it was supposedly faster and couldn't catch viruses. That caught me.
 
 Remember how I said I couldn't get the virus software to work on my computer? Yeah. At this point, I was thinking, *What? A computer that couldn't catch viruses? No way! That's gotta be **leagues** easier to use than Windows!*
 
-*Oh ho* I was... well... I was downright naive. I had no idea what I was doing. That night, I ran home, super excited to learn about linux and operating systems, and spent the entire night browsing the internet, trying to find whatever information was out there. At the time, my google-fu was weak and my internet was slow. The first thing I learned was that there were apparently different types of linuxes called "distributions." At that point, I probably searched "What is the best linux?" or something to that effect. Somehow, I managed to find [distrowatch](https://distrowatch.com/), which had a list of all the most popular distros on the side.
+*Oh ho* I was... well... I was downright naive. I had no idea what I was doing. That night, I ran home, super excited to learn about Linux and operating systems, and spent the entire night browsing the internet, trying to find whatever information was out there. At the time, my google-fu was weak and my internet was slow. The first thing I learned was that there were apparently different types of linuxes called "distributions." At that point, I probably searched "What is the best Linux?" or something to that effect. Somehow, I managed to find [distrowatch](https://distrowatch.com/), which had a list of all the most popular distros on the side.
 
 I don't remember the exact order, but I knew the key players were there: Ubuntu, Mint, Fedora, Debian, and Arch. Now, here's where my years of gaming experience came in. I personified each distribution as a class in a game world. Ubuntu was the easy to use axe-wielding warrior that would get the job done. Fedora was the Archer in the back with a feather in his cap and a quick quip for everything. Debian was the grandmotherly spellcaster just trying to keep everyone alive. Then there was Arch, the one who rushed into combat without any armor and uses only the environment as a weapon.
 
@@ -36,7 +36,7 @@ In my head, I knew what this meant. I needed to create my username, right? So I
 
 **root**
 
-Now, at the time, I didn't realize what I was doing. I didn't know that root was the god of my computer -- the user who decides all other user disputes. At the time, I thought it was an odd, quircky word chosen by the Arch developers in the same way they were talking about cheese graters before. I suppose that knowledge would come in time. At that moment, I was celebrating what might have been the most difficult thing I had done to that point in my life: typing in a 4 letter word.
+Now, at the time, I didn't realize what I was doing. I didn't know that root was the god of my computer -- the user who decides all other user disputes. At the time, I thought it was an odd, quirky word chosen by the Arch developers in the same way they were talking about cheese graters before. I suppose that knowledge would come in time. At that moment, I was celebrating what might have been the most difficult thing I had done to that point in my life: typing in a 4 letter word.
 
 #### Step 3: The blue screen of death