[이병현] Week 1

contains-duplicate/tolluset.ts

@@ -0,0 +1,7 @@
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function containsDuplicate(nums: number[]): boolean {
+  return nums.length !== new Set(nums).size;
+}

kth-smallest-element-in-a-bst/tolluset.ts

@@ -0,0 +1,42 @@
+class TreeNode {
+  val: number;
+  left: TreeNode | null;
+  right: TreeNode | null;
+  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+    this.val = val === undefined ? 0 : val;
+    this.left = left === undefined ? null : left;
+    this.right = right === undefined ? null : right;
+  }
+}
+
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function kthSmallest(root: TreeNode, k: number): number {
+  let count = 0;
+  let result: null | number = null;
+
+  const inOrder = (node: TreeNode | null) => {
+    if (!node || result !== null) {
+      return false;
+    }
+
+    if (inOrder(node.left)) {
+      return true;
+    }
+
+    count++;
+
+    if (count === k) {
+      result = node.val;
+      return true;
+    }
+
+    inOrder(node.right);
+  };
+
+  inOrder(root);
+
+  return result!;
+}

number-of-1-bits/tolluset.ts

@@ -0,0 +1,10 @@
+/*
+ * TC: O(logn)
+ * SC: O(logn)
+ * */
+function hammingWeight(n: number): number {
+  return n
+    .toString(2)
+    .split("")
+    .filter((s) => s === "1").length;
+}

palindromic-substrings/tolluset.ts

@@ -0,0 +1,59 @@
+/*
+ * TC: O(n)
+ * SC: O(n)
+ * */
+function countSubstrings(s: string): number {
+  const t = "#" + s.split("").join("#") + "#";
+  const n = t.length;
+  const p = new Array(n).fill(0);
+  let center = 0,
+    right = 0,
+    l = 0;
+
+  const mirror = (i: number, p: number[], c: number, r: number) => {
+    return Math.min(r - i, p[c * 2 - i]);
+  };
+
+  const isRightBound = (i: number, p: number[], n: number) => {
+    return i + p[i] + 1 < n;
+  };
+
+  const isLeftBound = (i: number, p: number[]) => {
+    return i - p[i] - 1 >= 0;
+  };
+
+  const isPalindrome = (i: number, p: number[], t: string) => {
+    return t[i + p[i] + 1] === t[i - p[i] - 1];
+  };
+
+  const isLongest = (i: number, p: number[], r: number) => {
+    return i + p[i] > r;
+  };
+
+  const calcTotal = (i: number, p: number[]) => {
+    return Math.floor((p[i] + 1) / 2);
+  };
+
+  for (let i = 0; i < n; i++) {
+    if (i < right) {
+      p[i] = mirror(i, p, center, right);
+    }
+
+    while (
+      isRightBound(i, p, n) &&
+      isLeftBound(i, p) &&
+      isPalindrome(i, p, t)
+    ) {
+      p[i]++;
+    }
+
+    if (isLongest(i, p, right)) {
+      center = i;
+      right = i + p[i];
+    }
+
+    l += calcTotal(i, p);
+  }
+
+  return l;
+}

top-k-frequent-elements/tolluset.ts

@@ -0,0 +1,27 @@
+type Nums = [number, number][];
+
+/*
+ * TC: O(nlogn)
+ * SC: O(n)
+ * */
+function topKFrequent(nums: number[], k: number): number[] {
+  const counting = (arr: number[]) =>
+    arr.reduce((acc, n) => {
+      const val = acc.get(n) ?? 0;
+      acc.set(n, val + 1);
+      return acc;
+    }, new Map<number, number>());
+
+  const toValues = (map: Map<number, number>) => Array.from(map.entries());
+
+  const sorting = (arr: Nums) => arr.sort((a, b) => b[1] - a[1]);
+
+  const getK = (arr: Nums, k: number) => arr.slice(0, k).map((v) => v[0]);
+
+  return pipe(counting, toValues, sorting, (arr: Nums) => getK(arr, k))(nums);
+}
+
+const pipe =
+  (...fns: Function[]) =>
+  (x: any) =>
+    fns.reduce((v, f) => f(v), x);