update

Author: realdennis

src/01-matrix.ts

@@ -0,0 +1,26 @@
+function updateMatrix(mat: number[][]): number[][] {
+  const M = mat.length;
+  const N = mat[0].length;
+  const dp = Array.from({ length: M }, () =>
+    Array.from({ length: N }, () => Number.MAX_SAFE_INTEGER)
+  );
+
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      if (mat[i][j] === 0) {
+        dp[i][j] = 0;
+      }
+
+      if (i + 1 < M) dp[i + 1][j] = Math.min(dp[i][j] + 1, dp[i + 1][j]);
+      if (j + 1 < N) dp[i][j + 1] = Math.min(dp[i][j] + 1, dp[i][j + 1]);
+    }
+  }
+
+  for (let i = M - 1; i >= 0; i--) {
+    for (let j = N - 1; j >= 0; j--) {
+      if (i - 1 >= 0) dp[i - 1][j] = Math.min(dp[i][j] + 1, dp[i - 1][j]);
+      if (j - 1 >= 0) dp[i][j - 1] = Math.min(dp[i][j] + 1, dp[i][j - 1]);
+    }
+  }
+  return dp;
+}

src/best-sightseeing-pair.ts

@@ -0,0 +1,23 @@
+function maxScoreSightseeingPair(A: number[]): number {
+  const N = A.length;
+
+  // find the max A[i] + A[j] + i - j;
+  // |----------> (A[i] + i)    + (A[j] - j);
+
+  // i < j
+  let ret = 0;
+  let i = 0,
+    j = 1;
+
+  while (j < N) {
+    const localRes = A[i] + A[j] + i - j;
+    ret = Math.max(ret, localRes);
+
+    if (A[i] + i < A[j] + j) i = j;
+    // now we found the pos j is the best point pos[k]+k in current
+    // updadte the i pos
+
+    j++;
+  }
+  return ret;
+}

src/best-time-to-buy-and-sell-stock.ts

@@ -0,0 +1,10 @@
+function maxProfit(prices: number[]): number {
+  const N = prices.length;
+  // [7,1,5,3,6,4] --> [-6,4,-2,3,-2]
+  let ret = 0;
+  for (let i = 0; i < N - 1; i++) {
+    const profit = prices[i + 1] - prices[i];
+    if (profit > 0) ret += profit;
+  }
+  return ret;
+}

src/merge-sorted-array.ts

@@ -0,0 +1,33 @@
+/**
+ Do not return anything, modify nums1 in-place instead.
+ */
+function merge(nums1: number[], m: number, nums2: number[], n: number): void {
+  let pos1 = m - 1,
+    pos2 = n - 1,
+    pos3 = nums1.length - 1;
+
+  while (pos3 >= 0) {
+    if (pos1 < 0) {
+      nums1[pos3] = nums2[pos2];
+      pos2--;
+      pos3--;
+      continue;
+    }
+    if (pos2 < 0) {
+      nums1[pos3] = nums1[pos1];
+      pos1--;
+      pos3--;
+      continue;
+    }
+
+    if (nums1[pos1] > nums2[pos2]) {
+      nums1[pos3] = nums1[pos1];
+      pos1--;
+      pos3--;
+    } else {
+      nums1[pos3] = nums2[pos2];
+      pos2--;
+      pos3--;
+    }
+  }
+}

src/multiply-strings.ts

@@ -0,0 +1,28 @@
+function multiply(num1: string, num2: string): string {
+  if (num1 === "0" || num2 === "0") return "0";
+
+  const M = num1.length,
+    N = num2.length;
+  const ret = Array.from({ length: M + N }, () => 0);
+
+  const getNum = (digit: string): number =>
+    digit.charCodeAt(0) - "0".charCodeAt(0);
+
+  for (let i = 0; i < M; i++) {
+    for (let j = 0; j < N; j++) {
+      const localRes = getNum(num1[i]) * getNum(num2[j]);
+      const carry = Math.floor(localRes / 10);
+      const digit = localRes % 10;
+      ret[i + j] += carry;
+      ret[i + j + 1] += digit;
+    }
+  }
+  for (let i = M + N - 1; i > 0; i--) {
+    const carry = Math.floor(ret[i] / 10);
+    ret[i] %= 10;
+    ret[i - 1] += carry;
+  }
+  if (ret.length !== 0 && ret[0] === 0) ret.shift();
+
+  return ret.join("");
+}

src/squares-of-a-sorted-array.ts

@@ -0,0 +1,34 @@
+function sortedSquares(nums: number[]): number[] {
+  const N = nums.length;
+  const positiveIdx = nums.findIndex((val) => val >= 0);
+
+  const negative = nums.slice(0, positiveIdx).reverse();
+  const positive = nums.slice(positiveIdx);
+
+  const ret = [];
+
+  let pos1 = 0,
+    pos2 = 0;
+  for (let i = 0; i < N; i++) {
+    if (pos2 === positive.length) {
+      ret.push(negative[pos1] ** 2);
+      pos1++;
+      continue;
+    }
+
+    if (pos1 === negative.length) {
+      ret.push(positive[pos2] ** 2);
+      pos2++;
+      continue;
+    }
+
+    if (Math.abs(negative[pos1]) < Math.abs(positive[pos2])) {
+      ret.push(negative[pos1] ** 2);
+      pos1++;
+    } else {
+      ret.push(positive[pos2] ** 2);
+      pos2++;
+    }
+  }
+  return ret;
+}

src/two-sum.ts

@@ -0,0 +1,10 @@
+function twoSum(nums: number[], target: number): number[] {
+  const N = nums.length;
+  const map: Map<number, number> = new Map(nums.map((val, idx) => [val, idx])); // map array to entries
+
+  for (let i = 0; i < N; i++) {
+    const t = target - nums[i];
+    if (map.has(t) && map.get(t) !== i) return [i, map.get(t)];
+  }
+  return [];
+}