Implemented dynamic programming (Closes #12)

Author: CoffeelessProgrammer

Algorithms/DynamicProgramming/Basics.ts

@@ -0,0 +1,76 @@
+// ----------------------- Class Implementation -----------------------
+class MemoizationExample {
+  private static cache = Object.create({});
+
+  public static resetCache() {
+    this.cache = null;
+    this.cache = Object.create({});
+  }
+
+  public static memoizedAddTo42(n: number, visualize?: boolean): number {
+    if (n in this.cache) {
+      if (visualize) console.log('Found!', n, '+ 42 =', this.cache[n]);
+      return this.cache[n];
+    } else {
+      if (visualize) console.log('New encounter!', n);
+      this.cache[n] = n + 42;
+      return this.cache[n]
+    }
+  }
+
+  public static addTo42(n: number): number {
+    console.log('Long time!', n);
+    return n + 42;
+  }
+}
+
+// ----------------------- Closure Implementation -----------------------
+function memoizedAddTo64() {
+  let cache = Object.create({});
+
+  return function(n: number): number {
+    if (n in cache) {
+      console.log('Found!', n, '+ 64 =', cache[n]);
+      return cache[n];
+    } else {
+      console.log('New encounter!', n);
+      cache[n] = n + 64;
+      return cache[n]
+    }
+  }
+}
+
+//---------------------------------------------------------------------
+// ----------                 MAIN PROGRAM                   ----------
+//---------------------------------------------------------------------
+if (import.meta.main) {
+
+  console.log('------------ Memoization via Class ------------');
+  MemoizationExample.memoizedAddTo42(17, true);
+  MemoizationExample.memoizedAddTo42(15, true);
+  MemoizationExample.memoizedAddTo42(17, true);
+  MemoizationExample.memoizedAddTo42(28, true);
+  MemoizationExample.memoizedAddTo42(28, true);
+
+  console.log('\n----------- Memoization via Closure -----------');
+  const memoized = memoizedAddTo64();
+
+  memoized(7);
+  memoized(5);
+  memoized(5);
+
+  // RUN:   deno run Algorithms/DynamicProgramming/Basics.ts
+}
+
+// --------------------------- Terminal Output: ---------------------------
+// ------------ Memoization via Class ------------
+// New encounter! 17
+// New encounter! 15
+// Found! 17 + 42 = 59
+// New encounter! 28
+// Found! 28 + 42 = 70
+
+// ----------- Memoization via Closure -----------
+// New encounter! 7
+// New encounter! 5
+// Found! 5 + 64 = 69

Algorithms/DynamicProgramming/Fibonacci.ts

@@ -0,0 +1,88 @@
+// ---------------- Fibonacci Sequence ----------------
+// 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144...
+
+class FibonacciMemoized {
+  private static cache = Object.create({});
+
+  private static _initialize = (() => {
+    FibonacciMemoized.cache[1] = 0;
+    FibonacciMemoized.cache[2] = 1;
+  })();
+
+  public static nthTerm(nth: number): number {
+    if (nth in this.cache)
+      return this.cache[nth];
+    else
+      this.cache[nth] = this.nthTerm(nth-2) + this.nthTerm(nth-1);
+    
+    return this.cache[nth];
+  }
+}
+
+function fibonacciBottomUp() {
+  let fibonacciSequence: number[] = [0,1];
+
+  return function(nth: number): number | undefined {
+    if (nth < 1) return undefined;
+    else nth = Math.floor(nth);
+  
+    for (let i=fibonacciSequence.length; i <= nth; ++i)
+      fibonacciSequence.push(fibonacciSequence[i-2]+ fibonacciSequence[i-1]);
+    
+    return fibonacciSequence[nth-1];
+  }
+}
+
+function executionTime(n: number): string {
+  const t0 = performance.now();
+  console.log('Term', n+':', FibonacciMemoized.nthTerm(n));
+  const t1 = performance.now();
+  return (t1-t0) + 'ms';
+}
+
+//---------------------------------------------------------------------
+// ----------                 MAIN PROGRAM                   ----------
+//---------------------------------------------------------------------
+if (import.meta.main) {
+
+  console.log('\n------------ Memoization ------------');
+  const a1 = Object.create({});
+  a1.run_1 = executionTime(256);
+  a1.run_2 = executionTime(256);
+  a1.run_3 = executionTime(16);
+  a1.run_4 = executionTime(8);
+
+  console.table(a1);
+
+  console.log('\n------------ Bottom Up ------------');
+  const fibBot = fibonacciBottomUp();
+
+  console.log('Term 1:', fibBot(1));
+  console.log('Term 6:', fibBot(6));
+  console.log('Term 11:', fibBot(11));
+  console.log('Term 42:', fibBot(42));
+
+  // RUN:   deno run Algorithms/DynamicProgramming/Fibonacci.ts
+}
+
+// --------------------------- Terminal Output: ---------------------------
+//
+// ------------ Memoization ------------
+// Term 256: 8.757159534301882e+52
+// Term 256: 8.757159534301882e+52
+// Term 16: 610
+// Term 8: 13
+// ┌───────┬────────┐
+// │ (idx) │ Values │
+// ├───────┼────────┤
+// │ run_1 │ "2ms"  │
+// │ run_2 │ "8ms"  │
+// │ run_3 │ "2ms"  │
+// │ run_4 │ "12ms" │
+// └───────┴────────┘
+//
+// ------------ Bottom Up ------------
+// Term 1: 0
+// Term 6: 5
+// Term 11: 55
+// Term 42: 165580141

Algorithms/README.md

@@ -2,7 +2,7 @@
 
 ## Core
 - [X] Recursion
-- [ ] Dynamic Programming
+- [X] Dynamic Programming
 - [X] Comparison Sorting
   - [X] *Merge Sort*
   - [X] *Quicksort*
@@ -20,17 +20,24 @@
 - [Unicode Characters | RapidTables](https://www.rapidtables.com/code/text/unicode-characters.html)
 - [The Big-O Algorithm Complexity Cheat Sheet](https://www.bigocheatsheet.com/ "Big O Cheat Sheet")
 
+### Dynamic Programming
+- [Closures | JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures)
+
+### Recursion
+- [Recursion | Brilliant.org](https://brilliant.org/wiki/recursion-problem-solving/)
+- [Tail Call Optimization in ES6](https://2ality.com/2015/06/tail-call-optimization.html)
+
 ### Searching
-- [Graph Traversals: VisuAlgo](https://visualgo.net/en/dfsbfs)
+- [Graph Traversals | VisuAlgo](https://visualgo.net/en/dfsbfs)
 - [Tree Traversals: Preorder, Inorder, & Postorder](https://www.geeksforgeeks.org/tree-traversals-inorder-preorder-and-postorder/)
 - [Space Complexity: BFS vs DFS](https://stackoverflow.com/questions/9844193/what-is-the-time-and-space-complexity-of-a-breadth-first-and-depth-first-tree-tr)
 
 ### Sorting
 - [Array.prototype.sort()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
 - [Animated Sorting | Toptal](https://www.toptal.com/developers/sorting-algorithms)
-- [Dancing Algorithms | AlgoRythmics](https://www.youtube.com/user/AlgoRythmics/videos)what-is-stability-in-sorting-algorithms-and-why-is-it-important)
+- [Dancing Algorithms | AlgoRythmics](https://www.youtube.com/user/AlgoRythmics/videos)
 - [QuickSort vs Heapsort](https://stackoverflow.com/questions/2467751/quicksort-vs-heapsort)
-- [Importance of Stability in Sorting](https://stackoverflow.com/questions/1517793/)
+- [Importance of Stability in Sorting](https://stackoverflow.com/questions/1517793/what-is-stability-in-sorting-algorithms-and-why-is-it-important)
 
 ### Most Common Sorts
 - [Merge Sort | Brilliant.org](https://brilliant.org/wiki/merge/)
@@ -39,8 +46,4 @@
 - [Radix Sort | Brilliant.org](https://brilliant.org/wiki/radix-sort/ "Non-Comparison Sort")
 - [Radix Sort Visualization](https://www.cs.usfca.edu/~galles/visualization/RadixSort.html)
 - [Counting Sort | Brilliant.org](https://brilliant.org/wiki/counting-sort/ "Non-Comparison Sort")
-- [Counting Sort Visualization](https://www.cs.usfca.edu/~galles/visualization/CountingSort.html)
-
-### Recursion
-- [Recursion | Brilliant.org](https://brilliant.org/wiki/recursion-problem-solving/)
-- [Tail Call Optimization in ES6](https://2ality.com/2015/06/tail-call-optimization.html)
+- [Counting Sort Visualization](https://www.cs.usfca.edu/~galles/visualization/CountingSort.html)

Algorithms/Recursion/Fibonacci.ts

@@ -93,6 +93,9 @@ if (import.meta.main) {
 // Fibonacci Iterative 5: 3
 // Fibonacci Iterative 6: 5
 // Fibonacci Iterative 9: 21
+// Fibonacci Iterative 42: 165580141
+// Fibonacci Iterative 50: 7778742049
+// Fibonacci Iterative 100: 218922995834555200000
 
 // ------------ Recursive ------------
 // Input -1 is invalid -_-'
@@ -103,4 +106,5 @@ if (import.meta.main) {
 // Fibonacci Recursive 4: 2
 // Fibonacci Recursive 5: 3
 // Fibonacci Recursive 7: 8
-// Fibonacci Recursive 8: 13
+// Fibonacci Recursive 8: 13
+// Fibonacci Recursive 42: 165580141

Algorithms/Searching/DepthFirstTraversals.ts

@@ -92,4 +92,16 @@ if (import.meta.main) {
   // RUN:   deno run Algorithms/Searching/DepthFirstTraversals.ts
 }
 
-// --------------------------- Terminal Output: ---------------------------
+// --------------------------- Terminal Output: ---------------------------
+// Inorder: [
+//   1, 4, 6, 9,
+//   15, 20, 170
+// ]
+// Preorder: [
+//   9, 4, 1, 6,
+//   20, 15, 170
+// ]
+// Postorder: [
+//   1, 6, 4, 15,
+//   170, 20, 9
+// ]

README.md

@@ -18,7 +18,7 @@
 
 ### Algorithms
 - [X] Recursion
-- [ ] Dynamic Programming
+- [X] Dynamic Programming
 - [X] Comparison Sorting
   - [X] *Merge Sort*
   - [X] *Quicksort*
@@ -36,6 +36,7 @@
 - [Comprehensive List of Data Structures](https://en.wikipedia.org/wiki/List_of_data_structures "Wikipedia: DS List")
 - [Visualizing Data Structures & Algorithms](https://visualgo.net/en)
 - [The Big-O Algorithm Complexity Cheat Sheet](https://www.bigocheatsheet.com/ "Big O Cheat Sheet")
+- [Google Coding Interview](https://youtu.be/XKu_SEDAykw)
 - [Roadmap: Core Data Structures & Algorithms](https://coggle.it/diagram/W5E5tqYlrXvFJPsq/t/master-the-interview-click-here-for-course-link "Course and Mindmap by Andrei Neagoie")
 
 ### Curated Articles