Merge pull request #181 from yolophg/main

[Helena] Week 11 solutions

Author: DaleSeo

coin-change/yolophg.js

@@ -0,0 +1,40 @@
+// Time Complexity: O(amount * coins.length)
+// Space Complexity: O(amount)
+
+var coinChange = function (coins, amount) {
+  // if the amount is 0, no coins are needed
+  if (amount === 0) return 0;
+
+  // a queue to hold the current amount and coins used to reach that amount
+  let queue = [{ amount: 0, steps: 0 }];
+
+  // a set to keep track of visited amounts to avoid revisiting them
+  let visited = new Set();
+  visited.add(0);
+
+  // start the BFS loop
+  while (queue.length > 0) {
+    // dequeue the first element
+    let { amount: currentAmount, steps } = queue.shift();
+
+    // iterate through each coin
+    for (let coin of coins) {
+      // calculate the new amount by adding the coin to the current amount
+      let newAmount = currentAmount + coin;
+
+      // if the new amount equals the target amount, return the number of steps plus one
+      if (newAmount === amount) {
+        return steps + 1;
+      }
+
+      // if the new amount is less than the target amount and hasn't been visited, enqueue it
+      if (newAmount < amount && !visited.has(newAmount)) {
+        queue.push({ amount: newAmount, steps: steps + 1 });
+        visited.add(newAmount);
+      }
+    }
+  }
+
+  // if the loop completes without finding the target amount, return -1
+  return -1;
+};

decode-ways/yolophg.js

@@ -0,0 +1,39 @@
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+
+var numDecodings = function (s) {
+  const n = s.length;
+
+  // if the string is empty or starts with '0', it cannot be decoded
+  if (n === 0 || s[0] === "0") return 0;
+
+  // initialize variables to store and decode up to the previous and the current index
+  // corresponds to dp[i-1]
+  let prev1 = 1;
+  // corresponds to dp[i-2]
+  let prev2 = 1;
+
+  // iterate through the string from the second character onwards
+  for (let i = 1; i < n; i++) {
+    let current = 0;
+
+    // single digit decoding
+    let oneDigit = parseInt(s.substring(i, i + 1));
+    if (oneDigit >= 1 && oneDigit <= 9) {
+      current += prev1;
+    }
+
+    // two digit decoding
+    let twoDigits = parseInt(s.substring(i - 1, i + 1));
+    if (twoDigits >= 10 && twoDigits <= 26) {
+      current += prev2;
+    }
+
+    // update prev2 and prev1 for the next iteration
+    prev2 = prev1;
+    prev1 = current;
+  }
+
+  // the way to decode the entire string, stored in prev1
+  return prev1;
+};

maximum-product-subarray/yolophg.js

@@ -0,0 +1,24 @@
+// Time Complexity: O(n)
+// Space Complexity: O(1)
+
+var maxProduct = function (nums) {
+  // the current maximum product, and the current minimum product
+  let maxProduct = nums[0];
+  let currMax = nums[0];
+  let currMin = nums[0];
+
+  // iterate through the array starting from the second element
+  for (let i = 1; i < nums.length; i++) {
+    let num = nums[i];
+
+    // update the current maximum and minimum products
+    currMax = Math.max(num, num * currMax);
+    currMin = Math.min(num, num * currMin);
+
+    // update the overall maximum product
+    maxProduct = Math.max(maxProduct, currMax);
+  }
+
+  // return the maximum product found
+  return maxProduct;
+};

palindromic-substrings/yolophg.js

@@ -0,0 +1,38 @@
+// Time Complexity: O(n^2)
+// Space Complexity: O(n^2)
+
+var countSubstrings = function (s) {
+  const n = s.length;
+  // a 2D array to store palindrome information
+  let dp = Array.from(Array(n), () => Array(n).fill(false));
+  let count = 0;
+
+  // every single character is a palindrome
+  for (let i = 0; i < n; i++) {
+    dp[i][i] = true;
+    count++;
+  }
+
+  // check for palindromic substrings of length 2
+  for (let i = 0; i < n - 1; i++) {
+    if (s[i] === s[i + 1]) {
+      dp[i][i + 1] = true;
+      count++;
+    }
+  }
+
+  // check for palindromic substrings of length 3 and more
+  for (let len = 3; len <= n; len++) {
+    for (let i = 0; i < n - len + 1; i++) {
+      //eEnding index of the current substring
+      let j = i + len - 1;
+      if (s[i] === s[j] && dp[i + 1][j - 1]) {
+        dp[i][j] = true;
+        count++;
+      }
+    }
+  }
+
+  // return the total count
+  return count;
+};

word-break/yolophg.js

@@ -0,0 +1,28 @@
+// Time Complexity: O(n^2 * m) m : the average length of the words in the dictionary
+// Space Complexity: O(n)
+
+var wordBreak = function (s, wordDict) {
+  const n = s.length;
+
+  // a dp array where dp[i] means s[0..i-1] can be segmented into words
+  let dp = Array(n + 1).fill(false);
+
+  // to segment an empty string
+  dp[0] = true;
+
+  for (let i = 1; i <= n; i++) {
+    // check every substring s[j..i-1]
+    for (let j = 0; j < i; j++) {
+      // if s[0..j-1] can be segmented and s[j..i-1] is a word
+      if (dp[j] && wordDict.includes(s.substring(j, i))) {
+        dp[i] = true;
+        // no need to check further, we found a valid segmentation
+        break;
+      }
+      ``;
+    }
+  }
+
+  // whether s[0..n-1] can be segmented
+  return dp[n];
+};