[casentino] WEEK 03 solutions

[casentino] WEEK 03 solutions

Author: casentino

combination-sum/casentino.ts

@@ -0,0 +1,20 @@
+function combinationSum(candidates: number[], target: number): number[][] {
+  const results: number[][] = [];
+
+  function comb(index: number, arr: number[], sum: number) {
+    if (sum === target) {
+      results.push([...arr]);
+      return;
+    }
+    if (sum > target || candidates.length <= index) {
+      return;
+    }
+    arr.push(candidates[index]);
+    comb(index, arr, sum + candidates[index]);
+    arr.pop();
+    comb(index + 1, arr, sum);
+  }
+
+  comb(0, [], 0);
+  return results;
+}

decode-ways/casentino.ts

@@ -0,0 +1,21 @@
+function numDecodings(s: string): number {
+  if (s.length === 1 && s[0] !== "0") {
+    return 1;
+  }
+  if (s[0] === "0") {
+    return 0;
+  }
+  const dp = new Array(s.length + 1).fill(0);
+  dp[0] = 1;
+  dp[1] = 1;
+  for (let i = 2; i <= s.length; i++) {
+    if (s[i - 1] !== "0") {
+      dp[i] += dp[i - 1];
+    }
+    const doubleNum = parseInt(s[i - 2] + s[i - 1]);
+    if (doubleNum >= 10 && doubleNum <= 26) {
+      dp[i] += dp[i - 2];
+    }
+  }
+  return dp[s.length];
+}

maximum-subarray/casentino.ts

@@ -0,0 +1,30 @@
+function maxSubArray(nums: number[]): number {
+  function subSums(arr: number[], left: number, right: number) {
+    if (left === right) {
+      return nums[left];
+    }
+    const middle = Math.floor((left + right) / 2);
+
+    const leftMax = subSums(arr, left, middle);
+    const rightMax = subSums(arr, middle + 1, right);
+    let leftSum = 0;
+    let leftMaxSum = Number.NEGATIVE_INFINITY;
+    for (let i = middle; i >= left; i--) {
+      leftSum += arr[i];
+      if (leftMaxSum < leftSum) {
+        leftMaxSum = leftSum;
+      }
+    }
+    let rightSum = 0;
+    let rightMaxSum = Number.NEGATIVE_INFINITY;
+    for (let i = middle + 1; i <= right; i++) {
+      rightSum += arr[i];
+      if (rightMaxSum < rightSum) {
+        rightMaxSum = rightSum;
+      }
+    }
+
+    return Math.max(leftMaxSum + rightMaxSum, leftMax, rightMax);
+  }
+  return subSums(nums, 0, nums.length - 1);
+}

number-of-1-bits/casentino.ts

@@ -0,0 +1,16 @@
+function hammingWeight(n: number): number {
+  let num = n;
+  let output = 0;
+  while (num !== 1) {
+    if (num % 2 === 1) {
+      output += 1;
+      num = (num - 1) / 2;
+    } else {
+      num = num / 2;
+    }
+  }
+  if (num === 1) {
+    output += 1;
+  }
+  return output;
+}

valid-palindrome/casentino.ts

@@ -0,0 +1,38 @@
+function isPalindrome(s: string): boolean {
+  let start = 0;
+  let last = s.length - 1;
+  while (start < last) {
+    while (start < last && !isAlphanumeric(s.charAt(start))) {
+      start += 1;
+    }
+    while (start < last && !isAlphanumeric(s.charAt(last))) {
+      last -= 1;
+    }
+    if (s.charAt(start).toLowerCase() !== s.charAt(last).toLowerCase()) {
+      return false;
+    }
+    start += 1;
+    last -= 1;
+  }
+  return true;
+}
+
+function isAlphanumeric(character: string) {
+  const characterCode = character.charCodeAt(0);
+  const lowerStart = "a".charCodeAt(0);
+  const lowerEnd = "z".charCodeAt(0);
+  const upperStart = "A".charCodeAt(0);
+  const upperEnd = "Z".charCodeAt(0);
+  const numericStart = "0".charCodeAt(0);
+  const numericEnd = "9".charCodeAt(0);
+  if (upperStart <= characterCode && upperEnd >= characterCode) {
+    return true;
+  }
+  if (lowerStart <= characterCode && lowerEnd >= characterCode) {
+    return true;
+  }
+  if (numericStart <= characterCode && numericEnd >= characterCode) {
+    return true;
+  }
+  return false;
+}