[01-binary] WEEK 03 solutions

climbing-stairs/01-binary.js

@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+
+var climbStairs = function (n) {
+  if (n === 1) return 1;
+  if (n === 2) return 2;
+  const arr = [0, 1, 2];
+  let i = 3;
+  while (i <= n) {
+    const temp = arr[i - 1] + arr[i - 2];
+    arr.push(temp);
+    i++;
+  }
+
+  return arr[n];
+};

house-robber/01-binary.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var rob = function (nums) {
+  const memo = new Map();
+  return dfs(nums, 0, memo);
+};
+
+const dfs = (nums, i, memo) => {
+  if (i >= nums.length) return 0;
+  if (memo.has(i)) return memo.get(i);
+  const result = Math.max(
+    nums[i] + dfs(nums, i + 2, memo),
+    dfs(nums, i + 1, memo),
+  );
+  memo.set(i, result);
+  return result;
+};

longest-consecutive-sequence/01-binary.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestConsecutive = function (nums) {
+  const unique_arr = Array.from(new Set(nums));
+  const temp = unique_arr.sort((a, b) => a - b);
+  let a = 1;
+  let max = 0;
+  for (let i = 0; i < temp.length; i++) {
+    if (temp[i] + 1 === temp[i + 1]) {
+      a++;
+    } else {
+      max = Math.max(a, max);
+      a = 1;
+    }
+  }
+  return max;
+};

number-of-1-bits/01-binary.js

@@ -0,0 +1,13 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var hammingWeight = function (n) {
+  let cnt = 1;
+  while (n >= 2) {
+    const r = n % 2;
+    n = Math.floor(n / 2);
+    if (r === 1) cnt++;
+  }
+  return cnt;
+};

product-of-array-except-self/01-binary.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function (nums) {
+  const r = Array.from(nums.length);
+  const l = Array.from(nums.length);
+  const a = Array.from(nums.length);
+  for (let i = 0; i < nums.length; i++) {
+    const temp = r[i - 1] ?? 1;
+    const temp2 = nums[i - 1] ?? 1;
+    r[i] = temp * temp2;
+  }
+  for (let i = nums.length - 1; i > -1; i--) {
+    const temp = l[i + 1] ?? 1;
+    const temp2 = nums[i + 1] ?? 1;
+    l[i] = temp * temp2;
+  }
+  for (let i = 0; i < nums.length; i++) {
+    a[i] = l[i] * r[i];
+  }
+
+  return a;
+};

top-k-frequent-elements/01-binary.js

@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var topKFrequent = function (nums, k) {
+  const map = new Map();
+  for (let i = 0; i < nums.length; i++) {
+    const temp = map.get(nums[i]);
+    map.set(nums[i], temp !== undefined ? temp + 1 : 1);
+  }
+  const sortedMap = new Map([...map.entries()].sort((a, b) => b[1] - a[1]));
+
+  const iter = sortedMap.keys();
+  const result = [];
+  for (let i = 0; i < k; i++) {
+    result.push(iter.next().value);
+  }
+  return result;
+};

two-sum/01-binary.js

@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  for (let i = 0; i < nums.length - 1; i++) {
+    for (let j = i + 1; j < nums.length; j++) {
+      if (nums[i] + nums[j] === target) {
+        return [i, j];
+      }
+    }
+  }
+};

valid-palindrome/01-binary.js

@@ -0,0 +1,8 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function (s) {
+  const result = s.toLowerCase().replace(/[^a-z0-9]/g, '');
+  return result === result.split('').reverse().join('');
+};