organize js files into directories. add implementations for DP

Author: beck chen

sessions/dynamic programming/bottomUp.js

@@ -0,0 +1,27 @@
+// solving this problem with DP bottom up approach
+function waysToClimb(totalNumOfSteps) {
+    // the number of elements = totalNumberOfSteps + 1 because 
+    // you need to count in 0 too. 0 step is your base case, which represents do nothing
+    const elements = Array(totalNumOfSteps + 1).fill(0);
+    elements[0] = 1; // base case
+
+    for (let currentIndex = 0; currentIndex < elements.length; currentIndex++) {
+        // say you have 8 steps total, then your elements will be 0-8
+        // so we will process a[ii+1] if ii+1 < numberOfElements = 9
+        if (currentIndex + 1 < elements.length) {
+            elements[currentIndex + 1] += elements[currentIndex];
+        }
+
+        if (currentIndex + 3 < elements.length) {
+            elements[currentIndex + 3] += elements[currentIndex];
+        }
+
+        if (currentIndex + 5 < elements.length) {
+            elements[currentIndex + 5] += elements[currentIndex];
+        }
+    }
+
+    return elements[elements.length - 1];
+}
+
+console.log(waysToClimb(8)); // this should return 19

sessions/dynamic programming/coinChange.js

@@ -0,0 +1,18 @@
+function coinChange(targetAmount, coinValues) {
+    // initialize an array from 0 to targetAmount
+    // length is targetAmount + 1 to take 0 into account
+    const elements = Array(targetAmount + 1).fill(0);
+    elements[0] = 1;
+    for (const coinValue of coinValues) {
+        // notice that we start from ii=coinValue instead of ii=0 here
+        // there's no way of making 0, 1, or 2 dollars with 3 dollar coins
+        // also if ii < coinValue, then ii-coinValue < 0 and is out of range
+        for (let ii = coinValue; ii < elements.length; ii++) {
+            elements[ii] = elements[ii] + elements[ii - coinValue];
+        }
+    }
+
+    return elements[targetAmount];
+}
+
+console.log(coinChange(5, [1, 2, 5]));

sessions/fibonacciDynamicProgramming.js renamed to sessions/dynamic programming/fibonacciDP.js

@@ -0,0 +1,34 @@
+function longestIncreasingSubsequence(arr) {
+    let currentLIS = 1;
+    if (!arr || arr.length === 0) { return 0; }
+
+    // create an array to store the LIS for every element of arr
+    const lisArr = Array(arr.length).fill(1);
+    for (let ii = 0; ii < arr.length; ii++) {
+        // calculate the LIS for every array element up till ii
+        for (let jj = 0; jj < ii; jj++) {
+            /* 
+            ** if element jj is less than element ii, then
+            ** LIS[ii] could either be:
+            **  1. LIS[jj] + 1, or
+            **  2. LIS[ii]
+            ** Therefore we take the max of the two
+            */
+            if (arr[jj] < arr[ii]) {
+                lisArr[ii] = Math.max(lisArr[jj] + 1, lisArr[ii]);
+            }
+        }
+
+        /* 
+        ** say we have the array [1, 3, 2, 5, 3, 5, 6] and we are at the first 3 (ii == 1).
+        ** at this point our currentLIS is still 1, and our lisArr[1] is 2, so we take the 2 as our lisArr[1].
+        ** however, say we're at the second 3 (ii=4). In this case lisArr[4] is only 2, but our currentLIS = 3
+        ** from the [1, 2, 5]. So we take the currentLIS over the lisArr[4]
+        */
+        currentLIS = Math.max(currentLIS, lisArr[ii]);
+    }
+
+    return currentLIS;
+}
+
+console.log(longestIncreasingSubsequence([1, 3, 2, 5, 3, 5, 6])); // this should return 5, for [1, 2, 3, 5, 6]

sessions/dynamic programming/longestIncreasingSubsequence.js

@@ -0,0 +1,18 @@
+// solving this problem with DP top down approach
+function waysToClimb(totalNumberOfSteps) {
+    const elements = Array(totalNumberOfSteps + 1).fill(0);
+    elements[0] = 1; // base case
+
+    // notice we iterate from 1, not 0. 0 is our base case
+    for (ii = 1; ii < elements.length; ii++) {
+        const valueAtIndexMinusOne = ii - 1 < 0 ? 0 : elements[ii - 1];
+        const valueAtIndexMinusThree = ii - 3 < 0 ? 0 : elements[ii - 3];
+        const valueAtIndexMinusFive = ii - 5 < 0 ? 0 : elements[ii - 5];
+
+        elements[ii] = valueAtIndexMinusOne + valueAtIndexMinusThree + valueAtIndexMinusFive;
+    }
+
+    return elements[totalNumberOfSteps];
+}
+
+console.log(waysToClimb(8)); // should return 19