first

Author: matthewlilley

.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js,ts,json}]
+charset = utf-8
+indent_style = space
+indent_size = 2
+
+
+[*.{md,txt}]
+indent_size = 2
+indent_style = space
+trim_trailing_whitespace = false

.gitignore

@@ -0,0 +1 @@
+data/dictionary

README.md

@@ -0,0 +1,109 @@
+# Algorithms and Data Structures
+
+WIP
+
+Beautifully crafted and well documented examples of Algorithms and Data Structures.
+
+## Algorithms
+
+[Circular Array](./algorithms/circular-array/index.ts)
+
+[Damerau Levenshtein Distance](./algorithms/damerau-levenshtein-distance/index.ts)
+
+[Euler's Totient](./algorithms/eulers-totient/index.ts)
+
+[Fibonacci Numbers](./algorithms/fibonacci-numbers/index.ts)
+
+[Fisher–Yates Shuffle](./algorithms/fisher-yates-shuffle/index.ts)
+
+[Levenshtein Distance](./algorithms/levenshtein-distance/index.ts)
+
+[Linear Congruential Generator](./algorithms/linear-congruential-generator/index.ts)
+
+[Lucas Numbers](./algorithms/lucas-numbers/index.ts)
+
+[Mersenne Twister](./algorithms/mersenne-twister/index.ts)
+
+[Phi](./algorithms/phi/index.ts)
+
+[Sieve of Eratosthenes](./algorithms/sieve-of-eratosthenes/index.ts)
+
+### Search Algorithms
+
+[Binary Search](./algorithms/binary-search/index.ts)
+
+[Exponential Search](./algorithms/exponential-search/index.ts)
+
+[Interpolation Search](./algorithms/interpolation-search/index.ts)
+
+[Linear Search](./algorithms/linear-search/index.ts)
+
+[Ternary Search](./algorithms/ternary-search/index.ts)
+
+### Hash Algorithms
+
+[djb2](./algorithms/hash/djb2/index.ts)
+
+[sdbm](./algorithms/hash/sdbm/index.ts)
+
+[loselose](./algorithms/hash/loselose/index.ts)
+
+### Sort Algorithms
+
+[Bubble Sort](./algorithms/sorting/bubble-sort/index.ts)
+
+[Comb Sort](./algorithms/sorting/comb-sort/index.ts)
+
+[Heapsort](./algorithms/sorting/heapsort/index.ts)
+
+[Insertion Sort](./algorithms/sorting/insertion-sort/index.ts)
+
+[Merge Sort](./algorithms/sorting/merge-sort/index.ts)
+
+[Quicksort](./algorithms/sorting/quicksort/index.ts)
+
+[Selection Sort](./algorithms/sorting/selection-sort/index.ts)
+
+[Shellsort](./algorithms/sorting/shellsort/index.ts)
+
+## Data Structures
+
+[AVL Tree](./data-structures/avl-tree/index.ts)
+
+[Binary Search Tree](./data-structures/binary-search-tree/index.ts)
+
+[Binary Tree](./data-structures/binary-tree/index.ts)
+
+[Circular Doubly Linked List](./data-structures/circular-doubly-linked-list/index.ts)
+
+[Circular Linked List](./data-structures/circular-linked-list/index.ts)
+
+[Deque](./data-structures/deque/index.ts)
+
+[Dictionary](./data-structures/dictionary/index.ts)
+
+[Doubly Linked List](./data-structures/doubly-linked-list/index.ts)
+
+[Graph](./data-structures/graph/index.ts)
+
+[Hash Table](./data-structures/hash-table/index.ts)
+
+[Linked List](./data-structures/linked-list/index.ts)
+
+[Queue](./data-structures/queue/index.ts)
+
+[Red Black Tree](./data-structures/red-black-tree/index.ts)
+
+[Skip List](./data-structures/skip-list/index.ts)
+
+[Stack](./data-structures/stack/index.ts)
+
+[Tree](./data-structures/tree/index.ts)
+
+[Trie](./data-structures/trie/index.ts)
+
+[Unrolled Linked List](./data-structures/unrolled-linked-list/index.ts)
+
+## Licence
+
+MIT

algorithms/binary-search/README.md

@@ -0,0 +1,24 @@
+# Binary Search
+
+In computer science, binary search, also known as half-interval search, logarithmic search, or binary chop, is a search algorithm that finds the position of a target value within a sorted array. Binary search compares the target value to the middle element of the array. If they are not equal, the half in which the target cannot lie is eliminated and the search continues on the remaining half, again taking the middle element to compare to the target value, and repeating this until the target value is found. If the search ends with the remaining half being empty, the target is not in the array. [Wikipedia](https://en.wikipedia.org/wiki/Binary_search_algorithm)
+
+<table>
+  <tbody align="left">
+    <tr>
+      <th colspan="3">Time Complexity</th>
+      <th>Space Complexity</th>
+    </tr>
+    <tr>
+      <th>Average</th>
+      <th>Best</th>
+      <th>Worst</th>
+      <th>Worst</th>
+    </tr>
+    <tr>
+      <td><code class="yellow-green">Θ(log(n))</code></td>
+      <td><code class="green">O(1)</code></td>
+      <td><code class="yellow-green">Θ(log(n))</code></td>
+      <td><code class="green">O(1)</code></td>
+    </tr>
+  </tbody>
+</table>

algorithms/binary-search/index.ts

@@ -0,0 +1,55 @@
+export function binarySearch(
+  haystack: number[],
+  needle: number,
+  left: number = 0,
+  right: number = haystack.length - 1
+): number | undefined {
+  while (left <= right) {
+    const middle = Math.floor((left + right) / 2);
+    if (haystack[middle] < needle) {
+      left = middle + 1;
+    } else if (haystack[middle] > needle) {
+      right = middle - 1;
+    } else {
+      return middle;
+    }
+  }
+}
+
+export function binarySearchLeftmost(
+  haystack: number[],
+  needle: number,
+  left: number = 0,
+  right: number = haystack.length
+) {
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+    if (haystack[middle] < needle) {
+      left = middle + 1;
+    } else {
+      right = middle;
+    }
+  }
+  return left;
+}
+
+export function binarySearchRightmost(
+  haystack: number[],
+  needle: number,
+  left: number = 0,
+  right: number = haystack.length
+) {
+  while (left < right) {
+    const middle = Math.floor((left + right) / 2);
+    if (haystack[middle] > needle) {
+      right = middle;
+    } else {
+      left = middle + 1;
+    }
+  }
+  return right - 1;
+}
+
+// const array = [3, 3];
+// console.log(binarySearchLeftmost(array, 3));
+// console.log(binarySearchRightmost(array, 3));

algorithms/binary-search/test.ts

@@ -0,0 +1,29 @@
+import {
+  binarySearch,
+  binarySearchLeftmost,
+  binarySearchRightmost,
+} from "./index.ts";
+
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+
+Deno.test("Binary search odd sized array", () => {
+  const array = [0, 1, 2];
+  assertEquals(binarySearch(array, 1), 1);
+  assertEquals(binarySearch(array, 3), undefined);
+});
+
+Deno.test("Binary search even sized array", () => {
+  const array = [0, 1];
+  assertEquals(binarySearch(array, 1), 1);
+  assertEquals(binarySearch(array, 2), undefined);
+});
+
+Deno.test("Binary search empty array returns undefined", () => {
+  assertEquals(binarySearch([], 1), undefined);
+});
+
+Deno.test("Binary search duplicates", () => {
+  const array = [3, 3];
+  assertEquals(binarySearchLeftmost(array, 3), 0);
+  assertEquals(binarySearchRightmost(array, 3), 1);
+});

algorithms/damerau-levenshtein-distance/README.md

@@ -0,0 +1,7 @@
+# Damerau Levenshtein Distance
+
+In information theory and computer science, the Damerau–Levenshtein distance (named after Frederick J. Damerau and Vladimir I. Levenshtein) is a string metric for measuring the edit distance between two sequences. Informally, the Damerau–Levenshtein distance between two words is the minimum number of operations (consisting of insertions, deletions or substitutions of a single character, or transposition of two adjacent characters) required to change one word into the other.
+
+The Damerau–Levenshtein distance differs from the classical Levenshtein distance by including transpositions among its allowable operations in addition to the three classical single-character edit operations (insertions, deletions and substitutions).
+
+In his seminal paper, Damerau stated that more than 80% of all human misspellings can be expressed by a single error of one of the four types. Damerau's paper considered only misspellings that could be corrected with at most one edit operation. While the original motivation was to measure distance between human misspellings to improve applications such as spell checkers, Damerau–Levenshtein distance has also seen uses in biology to measure the variation between protein sequences. [Wikipedia](https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance)

algorithms/damerau-levenshtein-distance/index.ts

@@ -0,0 +1,116 @@
+// https://en.wikipedia.org/wiki/Damerau%E2%80%93Levenshtein_distance
+
+export function optimalStringAlignmentDistance(a: string, b: string) {
+  let i;
+  let j;
+
+  const d: number[][] = [];
+
+  for (i = 0; i <= a.length; i++) {
+    d[i] = [i];
+  }
+
+  for (j = 0; j <= b.length; j++) {
+    d[0][j] = j;
+  }
+
+  for (i = 1; i <= a.length; i++) {
+    for (j = 1; j <= b.length; j++) {
+      d[i][j] = Math.min(
+        d[i - 1][j] + 1, // deletion
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1) // substitution
+      );
+      if (i > 1 && j > 1 && a[i] === b[j - 1] && a[i - 1] === b[j]) {
+        d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+      } // transposition
+    }
+  }
+
+  return d[a.length][b.length];
+}
+
+export function damerauLevenshteinDistance(a: string, b: string) {
+  let i: number;
+  let j: number;
+
+  const da: { [key: string]: number } = {};
+
+  a = a.toUpperCase();
+  b = b.toUpperCase();
+
+  for (const letter of a + b) {
+    if (!da[letter]) {
+      da[letter] = 0;
+    }
+  }
+
+  const d: number[][] = new Array(a.length);
+
+  for (i = -1; i <= a.length; i++) {
+    d[i] = new Array(b.length);
+    for (j = -1; j <= b.length; j++) {
+      d[i][j] = 0;
+    }
+  }
+
+  const INFINITY = a.length + b.length;
+  d[-1][-1] = INFINITY;
+
+  for (i = 0; i < a.length; i++) {
+    d[i][-1] = INFINITY;
+    d[i][0] = i;
+  }
+
+  for (j = 0; j < b.length; j++) {
+    d[-1][j] = INFINITY;
+    d[0][j] = j;
+  }
+
+  for (i = 1; i <= a.length; i++) {
+    let db = 0;
+    for (j = 1; j <= b.length; j++) {
+      const k: number = da[b[j - 1]];
+      const l: number = db;
+
+      let cost;
+
+      if (a[i - 1] === b[j - 1]) {
+        db = j;
+        cost = 0;
+      } else {
+        cost = 1;
+      }
+
+      d[i][j] = Math.min(
+        d[i - 1][j - 1] + cost, // substitution
+        d[i][j - 1] + 1, // insertion
+        d[i - 1][j] + 1, // deletion
+        d[k - 1][l - 1] + (i - k - 1) + 1 + (j - l - 1) // transposition
+      );
+    }
+
+    da[a[i - 1]] = i;
+  }
+
+  // console.log(d);
+
+  // console.log(da);
+
+  return d[a.length][b.length];
+}
+
+// 3
+console.log(optimalStringAlignmentDistance('ca', 'abc'));
+
+// 2
+console.log(damerauLevenshteinDistance('ca', 'abc'));
+
+// 2
+console.log(damerauLevenshteinDistance('a cat', 'a abct'));
+
+// 1
+console.log(damerauLevenshteinDistance('smtih', 'smith'));
+
+// 1
+console.log(damerauLevenshteinDistance('cat', 'cta'));

algorithms/eulers-totient/README.md

@@ -0,0 +1,5 @@
+# Euler's Totient
+
+In number theory, Euler's totient function counts the positive integers up to a given integer n that are relatively prime to n. It is written using the Greek letter phi as φ(n) or ϕ(n), and may also be called Euler's phi function. In other words, it is the number of integers k in the range 1 ≤ k ≤ n for which the greatest common divisor gcd(n, k) is equal to 1. The integers k of this form are sometimes referred to as totatives of n.
+
+<img src="https://render.githubusercontent.com/render/math?math=\phi(n)">

algorithms/eulers-totient/index.ts

@@ -0,0 +1,23 @@
+function gcd(a: number, b: number): number {
+  if (a === 0) {
+    return b;
+  }
+
+  return gcd(b % a, a);
+}
+
+export function eulersTotient(n: number) {
+  let totient = 1;
+
+  for (let i = 2; i < n; i++) {
+    if (gcd(i, n) === 1) {
+      totient++;
+    }
+  }
+
+  return totient;
+}
+
+for (let i = 1; i <= 10; i++) {
+  console.log(eulersTotient(i));
+}