@no-k/hermes 0.1.0

package/templates/algorithm/tree/avl-tree/avl-tree.ts

@@ -0,0 +1,197 @@
+type Compare<T> = (a: T, b: T) => number;
+
+type AvlTreeNode<T> = {
+  value: T;
+  height: number;
+  left: AvlTreeNode<T> | null;
+  right: AvlTreeNode<T> | null;
+};
+
+const defaultCompare = <T>(a: T, b: T) => {
+  if (a < b) {
+    return -1;
+  }
+
+  if (a > b) {
+    return 1;
+  }
+
+  return 0;
+};
+
+const createNode = <T>(value: T): AvlTreeNode<T> => ({
+  value,
+  height: 1,
+  left: null,
+  right: null,
+});
+
+export class AvlTree<T> {
+  private root: AvlTreeNode<T> | null = null;
+  private length = 0;
+  private compare: Compare<T>;
+
+  constructor(options: { compare?: Compare<T> } = {}) {
+    this.compare = options.compare ?? defaultCompare;
+  }
+
+  insert(value: T): boolean {
+    const result = this.insertNode(this.root, value);
+    this.root = result.node;
+
+    if (result.inserted) {
+      this.length += 1;
+    }
+
+    return result.inserted;
+  }
+
+  has(value: T): boolean {
+    let current = this.root;
+
+    while (current !== null) {
+      const compared = this.compare(value, current.value);
+
+      if (compared === 0) {
+        return true;
+      }
+
+      current = compared < 0 ? current.left : current.right;
+    }
+
+    return false;
+  }
+
+  inOrder(): T[] {
+    const values: T[] = [];
+    const stack: Array<AvlTreeNode<T>> = [];
+    let current = this.root;
+
+    while (current !== null || stack.length > 0) {
+      while (current !== null) {
+        stack.push(current);
+        current = current.left;
+      }
+
+      const node = stack.pop() as AvlTreeNode<T>;
+      values.push(node.value);
+      current = node.right;
+    }
+
+    return values;
+  }
+
+  height() {
+    return this.getHeight(this.root);
+  }
+
+  size() {
+    return this.length;
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+
+  private insertNode(node: AvlTreeNode<T> | null, value: T): { node: AvlTreeNode<T>; inserted: boolean } {
+    if (node === null) {
+      return {
+        node: createNode(value),
+        inserted: true,
+      };
+    }
+
+    const compared = this.compare(value, node.value);
+
+    if (compared === 0) {
+      return {
+        node,
+        inserted: false,
+      };
+    }
+
+    if (compared < 0) {
+      const result = this.insertNode(node.left, value);
+      node.left = result.node;
+
+      return {
+        node: this.balance(node),
+        inserted: result.inserted,
+      };
+    }
+
+    const result = this.insertNode(node.right, value);
+    node.right = result.node;
+
+    return {
+      node: this.balance(node),
+      inserted: result.inserted,
+    };
+  }
+
+  private balance(node: AvlTreeNode<T>) {
+    this.updateHeight(node);
+
+    const balanceFactor = this.getBalanceFactor(node);
+
+    if (balanceFactor > 1) {
+      if (this.getBalanceFactor(node.left) < 0) {
+        node.left = this.rotateLeft(node.left as AvlTreeNode<T>);
+      }
+
+      return this.rotateRight(node);
+    }
+
+    if (balanceFactor < -1) {
+      if (this.getBalanceFactor(node.right) > 0) {
+        node.right = this.rotateRight(node.right as AvlTreeNode<T>);
+      }
+
+      return this.rotateLeft(node);
+    }
+
+    return node;
+  }
+
+  private rotateLeft(node: AvlTreeNode<T>) {
+    const pivot = node.right as AvlTreeNode<T>;
+    const pivotLeft = pivot.left;
+
+    pivot.left = node;
+    node.right = pivotLeft;
+
+    this.updateHeight(node);
+    this.updateHeight(pivot);
+
+    return pivot;
+  }
+
+  private rotateRight(node: AvlTreeNode<T>) {
+    const pivot = node.left as AvlTreeNode<T>;
+    const pivotRight = pivot.right;
+
+    pivot.right = node;
+    node.left = pivotRight;
+
+    this.updateHeight(node);
+    this.updateHeight(pivot);
+
+    return pivot;
+  }
+
+  private updateHeight(node: AvlTreeNode<T>) {
+    node.height = Math.max(this.getHeight(node.left), this.getHeight(node.right)) + 1;
+  }
+
+  private getBalanceFactor(node: AvlTreeNode<T> | null) {
+    if (node === null) {
+      return 0;
+    }
+
+    return this.getHeight(node.left) - this.getHeight(node.right);
+  }
+
+  private getHeight(node: AvlTreeNode<T> | null) {
+    return node?.height ?? 0;
+  }
+}

package/templates/algorithm/tree/avl-tree/index.ts

@@ -0,0 +1 @@
+export * from "./avl-tree";

package/templates/algorithm/tree/binary-search-tree/binary-search-tree.ts

@@ -0,0 +1,144 @@
+type Compare<T> = (a: T, b: T) => number;
+
+type BinarySearchTreeNode<T> = {
+  value: T;
+  left: BinarySearchTreeNode<T> | null;
+  right: BinarySearchTreeNode<T> | null;
+};
+
+const defaultCompare = <T>(a: T, b: T) => {
+  if (a < b) {
+    return -1;
+  }
+
+  if (a > b) {
+    return 1;
+  }
+
+  return 0;
+};
+
+const createNode = <T>(value: T): BinarySearchTreeNode<T> => ({
+  value,
+  left: null,
+  right: null,
+});
+
+export class BinarySearchTree<T> {
+  private root: BinarySearchTreeNode<T> | null = null;
+  private length = 0;
+  private compare: Compare<T>;
+
+  constructor(options: { compare?: Compare<T> } = {}) {
+    this.compare = options.compare ?? defaultCompare;
+  }
+
+  insert(value: T): boolean {
+    if (this.root === null) {
+      this.root = createNode(value);
+      this.length += 1;
+
+      return true;
+    }
+
+    let current = this.root;
+
+    while (true) {
+      const compared = this.compare(value, current.value);
+
+      if (compared === 0) {
+        return false;
+      }
+
+      if (compared < 0) {
+        if (current.left === null) {
+          current.left = createNode(value);
+          this.length += 1;
+
+          return true;
+        }
+
+        current = current.left;
+        continue;
+      }
+
+      if (current.right === null) {
+        current.right = createNode(value);
+        this.length += 1;
+
+        return true;
+      }
+
+      current = current.right;
+    }
+  }
+
+  has(value: T): boolean {
+    let current = this.root;
+
+    while (current !== null) {
+      const compared = this.compare(value, current.value);
+
+      if (compared === 0) {
+        return true;
+      }
+
+      current = compared < 0 ? current.left : current.right;
+    }
+
+    return false;
+  }
+
+  inOrder(): T[] {
+    const values: T[] = [];
+    const stack: Array<BinarySearchTreeNode<T>> = [];
+    let current = this.root;
+
+    while (current !== null || stack.length > 0) {
+      while (current !== null) {
+        stack.push(current);
+        current = current.left;
+      }
+
+      const node = stack.pop() as BinarySearchTreeNode<T>;
+      values.push(node.value);
+      current = node.right;
+    }
+
+    return values;
+  }
+
+  min(): T | null {
+    let current = this.root;
+    if (current === null) {
+      return null;
+    }
+
+    while (current.left !== null) {
+      current = current.left;
+    }
+
+    return current.value;
+  }
+
+  max(): T | null {
+    let current = this.root;
+    if (current === null) {
+      return null;
+    }
+
+    while (current.right !== null) {
+      current = current.right;
+    }
+
+    return current.value;
+  }
+
+  size() {
+    return this.length;
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}

package/templates/algorithm/tree/binary-search-tree/index.ts

@@ -0,0 +1 @@
+export * from "./binary-search-tree";

package/templates/algorithm/tree/lca/index.ts

@@ -0,0 +1 @@
+export * from "./lca";

package/templates/algorithm/tree/lca/lca.ts

@@ -0,0 +1,119 @@
+export class LowestCommonAncestor {
+  private parents: number[][];
+  private depths: number[];
+
+  constructor(graph: number[][], root = 0) {
+    if (graph.length === 0) {
+      throw new RangeError("graph must contain at least one node");
+    }
+
+    this.assertNode(root, graph.length);
+
+    const maxLevel = Math.max(1, Math.ceil(Math.log2(graph.length)) + 1);
+    this.parents = Array.from({ length: maxLevel }, () => Array(graph.length).fill(-1));
+    this.depths = Array(graph.length).fill(-1);
+
+    this.build(graph, root);
+  }
+
+  lca(a: number, b: number) {
+    this.assertConnectedNode(a);
+    this.assertConnectedNode(b);
+
+    let left = a;
+    let right = b;
+
+    if (this.depths[left] < this.depths[right]) {
+      [left, right] = [right, left];
+    }
+
+    left = this.lift(left, this.depths[left] - this.depths[right]);
+
+    if (left === right) {
+      return left;
+    }
+
+    for (let level = this.parents.length - 1; level >= 0; level -= 1) {
+      if (this.parents[level][left] !== this.parents[level][right]) {
+        left = this.parents[level][left];
+        right = this.parents[level][right];
+      }
+    }
+
+    return this.parents[0][left];
+  }
+
+  distance(a: number, b: number) {
+    const ancestor = this.lca(a, b);
+
+    return this.depths[a] + this.depths[b] - this.depths[ancestor] * 2;
+  }
+
+  depth(node: number) {
+    this.assertConnectedNode(node);
+
+    return this.depths[node];
+  }
+
+  private build(graph: number[][], root: number) {
+    const stack = [root];
+    this.parents[0][root] = root;
+    this.depths[root] = 0;
+
+    while (stack.length > 0) {
+      const node = stack.pop() as number;
+
+      for (const next of graph[node]) {
+        this.assertNode(next, graph.length);
+
+        if (next === this.parents[0][node]) {
+          continue;
+        }
+
+        if (this.depths[next] !== -1) {
+          continue;
+        }
+
+        this.parents[0][next] = node;
+        this.depths[next] = this.depths[node] + 1;
+        stack.push(next);
+      }
+    }
+
+    for (let level = 1; level < this.parents.length; level += 1) {
+      for (let node = 0; node < graph.length; node += 1) {
+        const parent = this.parents[level - 1][node];
+        this.parents[level][node] = parent === -1 ? -1 : this.parents[level - 1][parent];
+      }
+    }
+  }
+
+  private lift(node: number, distance: number) {
+    let current = node;
+    let remainingDistance = distance;
+
+    for (let level = 0; remainingDistance > 0; level += 1) {
+      if (remainingDistance % 2 === 1) {
+        current = this.parents[level][current];
+      }
+
+      remainingDistance = Math.floor(remainingDistance / 2);
+    }
+
+    return current;
+  }
+
+  private assertConnectedNode(node: number) {
+    this.assertNode(node, this.depths.length);
+
+    if (this.depths[node] === -1) {
+      throw new RangeError("node is not connected to the root");
+    }
+  }
+
+  private assertNode(node: number, nodeCount: number) {
+    if (!Number.isInteger(node) || node < 0 || node >= nodeCount) {
+      throw new RangeError("node is out of range");
+    }
+  }
+}

package/templates/array/chunk/chunk.ts

@@ -0,0 +1,13 @@
+export const chunk = <T>(array: T[], size: number): T[][] => {
+  if (size <= 0) {
+    return [];
+  }
+
+  const result: T[][] = [];
+
+  for (let index = 0; index < array.length; index += size) {
+    result.push(array.slice(index, index + size));
+  }
+
+  return result;
+};

package/templates/array/chunk/index.ts

@@ -0,0 +1 @@
+export * from "./chunk";

package/templates/array/compact/compact.ts

@@ -0,0 +1,8 @@
+type Falsy = false | null | undefined | 0 | "";
+
+// NaN은 number 타입이라 위 Falsy 리터럴 유니온으로는 표현할 수 없다.
+// 런타임에서는 Boolean(NaN) === false라 함께 걸러지고, 타입 위에서는
+// 입력의 number 부분이 그대로 T로 남는다(예: compact([1, 0, 2]) -> number[]).
+export const compact = <T>(array: ReadonlyArray<T | Falsy>): T[] => {
+  return array.filter((value): value is T => Boolean(value));
+};

package/templates/array/compact/index.ts

@@ -0,0 +1 @@
+export * from "./compact";

package/templates/array/count-by/count-by.ts

@@ -0,0 +1,12 @@
+// 배열 항목을 keyFn이 돌려주는 키로 묶어 키별 개수를 센다. 입력 배열은
+// 변형하지 않고 { 키: 개수 } 객체를 새로 반환한다.
+export const countBy = <T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, number> => {
+  const result = {} as Record<K, number>;
+
+  for (const item of array) {
+    const key = keyFn(item);
+    result[key] = (result[key] ?? 0) + 1;
+  }
+
+  return result;
+};

package/templates/array/count-by/index.ts

@@ -0,0 +1 @@
+export * from "./count-by";

package/templates/array/difference/difference.ts

@@ -0,0 +1,6 @@
+export const difference = <T>(a: T[], b: T[]): T[] => {
+  // b를 Set으로 만들어 포함 검사를 O(1)로 한다. a의 순서와 중복은 그대로 보존된다.
+  const exclude = new Set(b);
+
+  return a.filter((value) => !exclude.has(value));
+};

package/templates/array/difference/index.ts

@@ -0,0 +1 @@
+export * from "./difference";

package/templates/array/drop/drop.ts

@@ -0,0 +1,7 @@
+// 배열 앞에서 n개를 제외한 나머지를 새 배열로 반환한다. 입력 배열은 변형하지 않는다.
+// n이 0 이하면 전체 복사본, n이 길이 이상이면 빈 배열을 돌려준다.
+// slice의 음수 인덱스 해석을 피하려고 n을 [0, length]로 먼저 클램프한다.
+export const drop = <T>(array: readonly T[], n: number): T[] => {
+  const count = Math.min(Math.max(n, 0), array.length);
+  return array.slice(count);
+};

package/templates/array/drop/index.ts

@@ -0,0 +1 @@
+export * from "./drop";

package/templates/array/group-by/group-by.ts

@@ -0,0 +1,18 @@
+// 배열 항목을 keyFn이 돌려주는 키로 묶는다. 같은 키의 항목들은 등장 순서대로
+// 한 배열에 모인다. 입력 배열은 변형하지 않고 새 객체를 반환한다.
+export const groupBy = <T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T[]> => {
+  const result = {} as Record<K, T[]>;
+
+  for (const item of array) {
+    const key = keyFn(item);
+    const bucket = result[key];
+
+    if (bucket === undefined) {
+      result[key] = [item];
+    } else {
+      bucket.push(item);
+    }
+  }
+
+  return result;
+};

package/templates/array/group-by/index.ts

@@ -0,0 +1 @@
+export * from "./group-by";

package/templates/array/intersection/index.ts

@@ -0,0 +1 @@
+export * from "./intersection";

package/templates/array/intersection/intersection.ts

@@ -0,0 +1,15 @@
+export const intersection = <T>(a: T[], b: T[]): T[] => {
+  // b는 포함 검사용, seen은 중복 제거용. 순서는 a를 한 번 훑으며 결정한다.
+  const include = new Set(b);
+  const seen = new Set<T>();
+  const result: T[] = [];
+
+  for (const value of a) {
+    if (include.has(value) && !seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+
+  return result;
+};

package/templates/array/key-by/index.ts

@@ -0,0 +1 @@
+export * from "./key-by";

package/templates/array/key-by/key-by.ts

@@ -0,0 +1,11 @@
+// 배열을 keyFn이 돌려주는 키로 인덱싱해 { 키: 항목 } 객체를 만든다.
+// 같은 키가 여러 번 나오면 마지막 항목이 우선한다. 입력 배열은 변형하지 않는다.
+export const keyBy = <T, K extends PropertyKey>(array: readonly T[], keyFn: (item: T) => K): Record<K, T> => {
+  const result = {} as Record<K, T>;
+
+  for (const item of array) {
+    result[keyFn(item)] = item;
+  }
+
+  return result;
+};

package/templates/array/max-by/index.ts

@@ -0,0 +1 @@
+export * from "./max-by";

package/templates/array/max-by/max-by.ts

@@ -0,0 +1,20 @@
+export const maxBy = <T>(array: T[], valueFn: (item: T) => number): T | null => {
+  if (array.length === 0) {
+    return null;
+  }
+
+  let best = array[0];
+  let bestValue = valueFn(best);
+
+  for (let index = 1; index < array.length; index += 1) {
+    const item = array[index];
+    const value = valueFn(item);
+
+    if (value > bestValue) {
+      best = item;
+      bestValue = value;
+    }
+  }
+
+  return best;
+};

package/templates/array/min-by/index.ts

@@ -0,0 +1 @@
+export * from "./min-by";

package/templates/array/min-by/min-by.ts

@@ -0,0 +1,20 @@
+export const minBy = <T>(array: T[], valueFn: (item: T) => number): T | null => {
+  if (array.length === 0) {
+    return null;
+  }
+
+  let best = array[0];
+  let bestValue = valueFn(best);
+
+  for (let index = 1; index < array.length; index += 1) {
+    const item = array[index];
+    const value = valueFn(item);
+
+    if (value < bestValue) {
+      best = item;
+      bestValue = value;
+    }
+  }
+
+  return best;
+};

package/templates/array/partition/index.ts

@@ -0,0 +1 @@
+export * from "./partition";

package/templates/array/partition/partition.ts

@@ -0,0 +1,16 @@
+// 배열을 predicate 통과 여부로 두 그룹으로 나눈다. [통과한 항목, 실패한 항목]
+// 튜플을 반환하며 각 그룹은 등장 순서를 보존한다. 입력 배열은 변형하지 않는다.
+export const partition = <T>(array: readonly T[], predicate: (item: T) => boolean): [T[], T[]] => {
+  const passed: T[] = [];
+  const failed: T[] = [];
+
+  for (const item of array) {
+    if (predicate(item)) {
+      passed.push(item);
+    } else {
+      failed.push(item);
+    }
+  }
+
+  return [passed, failed];
+};

package/templates/array/range/index.ts

@@ -0,0 +1 @@
+export * from "./range";

package/templates/array/range/range.ts

@@ -0,0 +1,22 @@
+// [start, end) 구간을 step 간격으로 채운 숫자 배열을 반환한다. step 기본값은 1.
+// step이 0이면(전진하지 않으므로) 빈 배열을 돌려준다.
+// 음수 step도 지원한다: start > end 일 때 감소 수열을 만든다.
+// 방향(step 부호)과 구간 방향이 어긋나면(예: start < end 인데 step < 0) 빈 배열이 된다.
+export const range = (start: number, end: number, step = 1): number[] => {
+  if (step === 0) {
+    return [];
+  }
+
+  const result: number[] = [];
+  if (step > 0) {
+    for (let value = start; value < end; value += step) {
+      result.push(value);
+    }
+  } else {
+    for (let value = start; value > end; value += step) {
+      result.push(value);
+    }
+  }
+
+  return result;
+};