add dynamic programming

Author: sangtrandev00

src/algorithm/dynamic-programming/climbing-stair.test.ts

@@ -0,0 +1 @@
+

src/algorithm/dynamic-programming/climbing-stair.ts

@@ -0,0 +1,41 @@
+
+// const caching: any = new Map()
+// caching.set(2, 2)
+// caching.set(3, 3)
+// function fibonacciDP(n: number): number {
+//     if (n <= 1) return 1
+//     if (caching.has(n)) {
+//         return caching.get(n)
+//     } else {
+//         const result = fibonacciDP(n - 1) + fibonacciDP(n - 2)
+//         caching.set(n, result)
+//         console.log("caching", caching);
+//         return result
+//     }
+// }
+
+// console.log(fibonacciDP(8));
+
+const cachingNumber: any = new Map()
+cachingNumber.set(2, 2)
+cachingNumber.set(3, 3)
+//0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233...
+let calculations = 0;
+
+function climbStairs(n: number): number {
+    if (n <= 1) return 1
+    if (n <= 3) return n
+    // Khá giống với tìm số fiboncci
+    let i = 3;
+    let sum = cachingNumber.get(i - 1) + cachingNumber.get(i - 2);
+    while (i < n) {
+        sum = cachingNumber.get(i) + cachingNumber.get(i - 1);
+        cachingNumber.set(i + 1, sum)
+        i++
+    }
+    return sum;
+    // O(n): Time complexity
+    // O(n): Space complexity
+};
+
+console.log("climbStairs", climbStairs(6));

src/algorithm/dynamic-programming/dynamic-example.ts

@@ -0,0 +1,42 @@
+
+
+function addTo80(n: number) {
+    console.log('take very long time');
+    return n + 80
+}
+
+// Chuyện gì sẽ xảy ra nếu n cùng một giá trị nhưng gọi nhiều lần ?
+// Có kỹ thuật nào tối ưu hơn không ?
+
+const cache: { [key: number]: number } = {};
+function memoizedAddTo80(n: number) {
+    if (cache[n]) {
+        return cache[n]
+    } else {
+        cache[n] = 80 + n
+    }
+}
+
+console.log("memoizedAddTo80(5)", memoizedAddTo80(5));
+console.log("memoizedAddTo80(5)", memoizedAddTo80(5));
+
+function closure() {
+    debugger
+    const cache: any = {}
+    // Using closure to memorized things in JS!
+    return function (n: number) {
+        if (cache[n]) {
+            return cache[n]
+        } else {
+            console.log("take a long time!");
+            cache[n] = 80 + n
+        }
+    }
+}
+
+const memoized = closure()
+console.log(memoized(5));
+console.log(memoized(5));
+console.log(memoized(6));
+console.log(memoized(7));
+console.log(memoized(6));

src/algorithm/dynamic-programming/fibonacci.ts

@@ -0,0 +1,63 @@
+
+let calculations = 0
+function fibonacci(n: number): number {
+    calculations++
+    if (n <= 2) return 1
+    return fibonacci(n - 1) + fibonacci(n - 2)
+}
+
+// console.log(fibonacci(10))
+// console.log("calculation", calculations);
+
+// Việc tính như vậy khá lâu, và không tối ưu (Caching)
+function dp() {
+    const caching: any = new Map()
+    caching.set(0, 0)
+    caching.set(1, 1)
+    return function fibonacciDP(number: number): number {
+        calculations++
+        if (caching.has(number)) {
+            return caching.get(number)
+        } else {
+            const result = fibonacciDP(number - 1) + fibonacciDP(number - 2)
+            caching.set(number, result)
+            console.log("caching!", caching);
+            return result
+        }
+    }
+}
+
+const fib = dp()
+console.log("slow", fibonacci(20)); // 13529 lần gọi function => Tốn rất nhiều bộ nhớ khi sử dụng recursive function! => Rất dễ gây nghẽn (exceed bộ nhớ!)
+console.log("fast", fib(20)); // 39 lần gọi function => Super fast
+
+// Performance testing
+// console.time("fib(20) - First Call");
+// console.log("fib(20)", fib(20));
+// console.timeEnd("fib(20) - First Call");
+
+// console.time("fib(20) - Second Call");
+// console.log("fib(20)", fib(20));
+// console.timeEnd("fib(20) - Second Call");
+
+// console.time("fib(19)");
+// console.log("fib(19)", fib(19));
+// console.timeEnd("fib(19)");
+
+// console.time("fib(21)");
+// console.log("fib(21)", fib(21));
+// console.timeEnd("fib(21)");
+
+// console.time("fib(21)");
+// console.log("fib(21)", fib(21));
+// console.timeEnd("fib(21)");
+
+// console.time("fib(30)");
+// console.log("fib(30)", fib(30));
+// console.timeEnd("fib(30)");
+
+// console.time("fib(30)");
+// console.log("fib(30)", fib(30));
+// console.timeEnd("fib(30)");
+
+console.log("calculations", calculations);

src/algorithm/recursion/recursion-fibonacci.ts

@@ -22,7 +22,8 @@ export function fibonacciIterative(n: number) {
         i++ // 3, 4, 5, 6, 7
     }
     return sum
-
+    // O(n): Time complexity
+    // O(1): Space complexity
 }
 
 console.log('fibonacciIterative(6)', fibonacciIterative(100));

src/algorithm/searching/linear-search.ts

@@ -0,0 +1,9 @@
+
+function linearSearch(array: number[], target: number): number {
+    for (let i = 0; i < array.length; i++) {
+        if (array[i] === target) {
+            return i
+        }
+    }
+    return -1
+}