@no-k/hermes 0.1.0

package/templates/array/sample/index.ts

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

package/templates/array/sample/sample.ts

@@ -0,0 +1,10 @@
+// 배열에서 무작위로 원소 하나를 골라 반환한다. 빈 배열이면 null을 반환한다.
+// 각 원소가 균등 확률로 뽑힌다. 난수는 런타임의 Math.random을 사용한다.
+export const sample = <T>(array: T[]): T | null => {
+  if (array.length === 0) {
+    return null;
+  }
+
+  const index = Math.floor(Math.random() * array.length);
+  return array[index];
+};

package/templates/array/shuffle/index.ts

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

package/templates/array/shuffle/shuffle.ts

@@ -0,0 +1,15 @@
+// Fisher-Yates 셔플로 무작위 순서의 새 배열을 반환한다. 입력 배열은 변형하지
+// 않는다. 뒤에서 앞으로 훑으며 각 위치를 [0, index] 구간의 임의 위치와 교환하므로
+// 모든 순열이 균등 확률로 나온다. 난수는 런타임의 Math.random을 사용한다.
+export const shuffle = <T>(array: T[]): T[] => {
+  const result = array.slice();
+
+  for (let index = result.length - 1; index > 0; index -= 1) {
+    const swap = Math.floor(Math.random() * (index + 1));
+    const temp = result[index];
+    result[index] = result[swap];
+    result[swap] = temp;
+  }
+
+  return result;
+};

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

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

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

@@ -0,0 +1,32 @@
+// keyFn이 돌려준 키를 기준으로 오름차순 안정 정렬한 새 배열을 반환한다.
+// 입력 배열은 변형하지 않는다. 키가 같은 항목들은 원래 순서를 유지한다(안정).
+//
+// 키 타입은 number | string로 한정한다. 두 키를 빼거나 직접 비교하는 대신
+// compareKey 하나로 처리해, number는 차이로 string은 사전식으로 비교한다.
+// string 비교에 localeCompare를 쓰지 않는 이유는 로케일에 따라 결과가 달라져
+// 코드 단위 비교(`<`/`>`)가 더 결정적이기 때문이다.
+const compareKey = (a: number | string, b: number | string): number => {
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+
+  const left = String(a);
+  const right = String(b);
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+};
+
+export const sortBy = <T>(array: T[], keyFn: (item: T) => number | string): T[] => {
+  // 키를 항목당 한 번만 계산해 두고(슈워츠 변환) 비교에서 재호출하지 않는다.
+  // index를 함께 들고 가 동점일 때 원래 순서로 풀어 안정성을 보장한다.
+  // (Array.prototype.sort 자체도 ES2019부터 안정이지만, 키 캐싱을 위해 래핑한다.)
+  return array
+    .map((item, index) => ({ item, index, key: keyFn(item) }))
+    .sort((a, b) => compareKey(a.key, b.key) || a.index - b.index)
+    .map((entry) => entry.item);
+};

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

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

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

@@ -0,0 +1,9 @@
+export const sumBy = <T>(array: T[], valueFn: (item: T) => number): number => {
+  let total = 0;
+
+  for (const item of array) {
+    total += valueFn(item);
+  }
+
+  return total;
+};

package/templates/array/take/index.ts

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

package/templates/array/take/take.ts

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

package/templates/array/union/index.ts

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

package/templates/array/union/union.ts

@@ -0,0 +1,5 @@
+export const union = <T>(a: T[], b: T[]): T[] => {
+  // Set이 삽입 순서를 보존하므로 a 먼저, b 다음 순서로 넣으면 등장 순서가 유지되고
+  // 중복은 자동으로 제거된다.
+  return [...new Set([...a, ...b])];
+};

package/templates/array/unique/index.ts

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

package/templates/array/unique/unique.ts

@@ -0,0 +1,5 @@
+// 배열에서 중복을 제거한다. Set의 SameValueZero 동등성으로 판정하며,
+// 각 값의 첫 등장 순서를 그대로 보존한다. 입력 배열은 변형하지 않는다.
+export const unique = <T>(array: readonly T[]): T[] => {
+  return [...new Set(array)];
+};

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

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

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

@@ -0,0 +1,19 @@
+// keyFn이 돌려준 키를 기준으로 중복을 제거한다. 같은 키가 처음 나온 항목만
+// 남기고 첫 등장 순서를 보존한다. 입력 배열은 변형하지 않는다.
+// 키 비교는 Set의 SameValueZero 동등성을 따른다.
+export const uniqueBy = <T, K>(array: readonly T[], keyFn: (item: T) => K): T[] => {
+  const seen = new Set<K>();
+  const result: T[] = [];
+
+  for (const item of array) {
+    const key = keyFn(item);
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    result.push(item);
+  }
+
+  return result;
+};

package/templates/array/windowed/index.ts

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

package/templates/array/windowed/windowed.ts

@@ -0,0 +1,15 @@
+export const windowed = <T>(array: T[], size: number, step = 1): T[][] => {
+  if (size <= 0 || step <= 0) {
+    return [];
+  }
+
+  const result: T[][] = [];
+
+  // 마지막 시작 인덱스는 size만큼 꽉 찬 윈도우가 나오는 지점까지다.
+  // array.length < size면 루프가 한 번도 돌지 않아 빈 배열이 된다.
+  for (let index = 0; index + size <= array.length; index += step) {
+    result.push(array.slice(index, index + size));
+  }
+
+  return result;
+};

package/templates/array/zip/index.ts

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

package/templates/array/zip/zip.ts

@@ -0,0 +1,11 @@
+export const zip = <A, B>(a: A[], b: B[]): [A, B][] => {
+  // 길이가 다르면 짧은 쪽에서 멈춘다. 남는 원소는 짝이 없으므로 버린다.
+  const length = Math.min(a.length, b.length);
+  const result: [A, B][] = [];
+
+  for (let index = 0; index < length; index += 1) {
+    result.push([a[index], b[index]]);
+  }
+
+  return result;
+};

package/templates/boolean/parse-boolean/index.ts

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

package/templates/boolean/parse-boolean/parse-boolean.ts

@@ -0,0 +1,17 @@
+// 다양한 입력을 boolean으로 해석한다.
+// true/"true"/"1"/"yes"/"y"/"on"(대소문자·앞뒤 공백 무시)과 0이 아닌 숫자는 true,
+// 그 외(false/0/null/undefined/빈 문자열 등)는 false.
+const TRUTHY = new Set(["true", "1", "yes", "y", "on"]);
+
+export const parseBoolean = (value: unknown): boolean => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  if (typeof value === "string") {
+    return TRUTHY.has(value.trim().toLowerCase());
+  }
+  return false;
+};

package/templates/boolean/toggle/index.ts

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

package/templates/boolean/toggle/toggle.ts

@@ -0,0 +1,2 @@
+// boolean 값을 반전한다.
+export const toggle = (value: boolean): boolean => !value;

package/templates/boolean/xor/index.ts

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

package/templates/boolean/xor/xor.ts

@@ -0,0 +1,2 @@
+// 배타적 논리합. 두 boolean 중 정확히 하나만 true일 때 true.
+export const xor = (a: boolean, b: boolean): boolean => a !== b;

package/templates/data-structure/deque/deque.ts

@@ -0,0 +1,79 @@
+export class Deque<T> {
+  private items = new Map<number, T>();
+  private head = 0;
+  private tail = 0;
+
+  size() {
+    return this.tail - this.head;
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  pushFront(value: T) {
+    this.head -= 1;
+    this.items.set(this.head, value);
+  }
+
+  pushBack(value: T) {
+    this.items.set(this.tail, value);
+    this.tail += 1;
+  }
+
+  popFront(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    const value = this.items.get(this.head) as T;
+    this.items.delete(this.head);
+    this.head += 1;
+
+    return value;
+  }
+
+  popBack(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    this.tail -= 1;
+    const value = this.items.get(this.tail) as T;
+    this.items.delete(this.tail);
+
+    return value;
+  }
+
+  front(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    return this.items.get(this.head) as T;
+  }
+
+  back(): T | null {
+    if (this.isEmpty()) {
+      return null;
+    }
+
+    return this.items.get(this.tail - 1) as T;
+  }
+
+  clear() {
+    this.items.clear();
+    this.head = 0;
+    this.tail = 0;
+  }
+
+  toArray() {
+    const result: T[] = [];
+
+    for (let index = this.head; index < this.tail; index += 1) {
+      result.push(this.items.get(index) as T);
+    }
+
+    return result;
+  }
+}

package/templates/data-structure/deque/index.ts

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

package/templates/data-structure/fenwick-tree/fenwick-tree.ts

@@ -0,0 +1,76 @@
+export class FenwickTree {
+  private tree: number[];
+  private values: number[];
+
+  constructor(sizeOrValues: number | number[]) {
+    const size = Array.isArray(sizeOrValues) ? sizeOrValues.length : sizeOrValues;
+    this.tree = Array(size + 1).fill(0);
+    this.values = Array(size).fill(0);
+
+    if (Array.isArray(sizeOrValues)) {
+      sizeOrValues.forEach((value, index) => {
+        this.set(index, value);
+      });
+    }
+  }
+
+  size() {
+    return this.values.length;
+  }
+
+  update(index: number, delta: number) {
+    this.assertIndex(index);
+
+    this.values[index] += delta;
+
+    for (let current = index + 1; current < this.tree.length; current += current & -current) {
+      this.tree[current] += delta;
+    }
+  }
+
+  set(index: number, value: number) {
+    this.assertIndex(index);
+    this.update(index, value - this.values[index]);
+  }
+
+  get(index: number) {
+    this.assertIndex(index);
+
+    return this.values[index];
+  }
+
+  prefixSum(index: number) {
+    if (index < 0) {
+      return 0;
+    }
+
+    if (index >= this.size()) {
+      throw new RangeError("index is out of range");
+    }
+
+    let result = 0;
+
+    for (let current = index + 1; current > 0; current -= current & -current) {
+      result += this.tree[current];
+    }
+
+    return result;
+  }
+
+  rangeSum(left: number, right: number) {
+    if (left > right) {
+      return 0;
+    }
+
+    this.assertIndex(left);
+    this.assertIndex(right);
+
+    return this.prefixSum(right) - this.prefixSum(left - 1);
+  }
+
+  private assertIndex(index: number) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.size()) {
+      throw new RangeError("index is out of range");
+    }
+  }
+}

package/templates/data-structure/fenwick-tree/index.ts

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

package/templates/data-structure/heap/heap.ts

@@ -0,0 +1,88 @@
+export abstract class Heap<T> {
+  items: T[];
+  compareBy: (item: T) => number;
+
+  constructor(options: { compareBy: Heap<T>["compareBy"] }) {
+    this.items = [];
+    this.compareBy = options.compareBy;
+  }
+
+  size() {
+    return this.items.length;
+  }
+
+  peek(): T | null {
+    if (!this.size()) {
+      return null;
+    }
+
+    return this.items[0];
+  }
+
+  push(value: T) {
+    this.items.push(value);
+    this.bubbleUp();
+  }
+
+  pop(): T | null {
+    if (!this.size()) {
+      return null;
+    }
+
+    const top = this.items[0];
+    const last = this.items[this.size() - 1];
+    this.items.pop();
+
+    if (this.size()) {
+      this.items[0] = last;
+      this.bubbleDown();
+    }
+
+    return top;
+  }
+
+  swap(a: number, b: number) {
+    [this.items[a], this.items[b]] = [this.items[b], this.items[a]];
+  }
+
+  /**
+   * 루트에 더 가까워야 하는(우선순위가 높은) 쪽을 음수로 반환합니다.
+   * MinHeap은 값이 작을수록, MaxHeap은 값이 클수록 우선순위가 높습니다.
+   */
+  abstract compare(aIndex: number, bIndex: number): number;
+
+  bubbleUp() {
+    let index = this.size() - 1;
+
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+
+      if (this.compare(parentIndex, index) <= 0) {
+        break;
+      }
+
+      this.swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+
+  bubbleDown() {
+    let index = 0;
+
+    while (index * 2 + 1 < this.size()) {
+      const leftIndex = index * 2 + 1;
+      const rightIndex = index * 2 + 2;
+
+      const isRightHigherPriority = rightIndex < this.size() && this.compare(rightIndex, leftIndex) < 0;
+
+      const targetIndex = isRightHigherPriority ? rightIndex : leftIndex;
+
+      if (this.compare(index, targetIndex) <= 0) {
+        break;
+      }
+
+      this.swap(index, targetIndex);
+      index = targetIndex;
+    }
+  }
+}

package/templates/data-structure/heap/index.ts

@@ -0,0 +1,3 @@
+export * from "./heap";
+export * from "./min-heap";
+export * from "./max-heap";

package/templates/data-structure/heap/max-heap.ts

@@ -0,0 +1,7 @@
+import { Heap } from "./heap";
+
+export class MaxHeap<T> extends Heap<T> {
+  compare(aIndex: number, bIndex: number): number {
+    return this.compareBy(this.items[bIndex]) - this.compareBy(this.items[aIndex]);
+  }
+}

package/templates/data-structure/heap/min-heap.ts

@@ -0,0 +1,7 @@
+import { Heap } from "./heap";
+
+export class MinHeap<T> extends Heap<T> {
+  compare(aIndex: number, bIndex: number): number {
+    return this.compareBy(this.items[aIndex]) - this.compareBy(this.items[bIndex]);
+  }
+}

package/templates/data-structure/priority-queue/index.ts

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

package/templates/data-structure/priority-queue/priority-queue.ts

@@ -0,0 +1,44 @@
+import { Heap } from "../heap/heap";
+
+type Compare<T> = (a: T, b: T) => number;
+
+const defaultCompare = <T>(a: T, b: T) => {
+  if (a < b) {
+    return -1;
+  }
+
+  if (a > b) {
+    return 1;
+  }
+
+  return 0;
+};
+
+export class PriorityQueue<T> extends Heap<T> {
+  private compareItems: Compare<T>;
+
+  constructor(options: { compare?: Compare<T> } = {}) {
+    super({ compareBy: () => 0 });
+    this.compareItems = options.compare ?? defaultCompare;
+  }
+
+  compare(aIndex: number, bIndex: number): number {
+    return this.compareItems(this.items[aIndex], this.items[bIndex]);
+  }
+
+  enqueue(value: T) {
+    this.push(value);
+  }
+
+  dequeue(): T | null {
+    return this.pop();
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  clear() {
+    this.items = [];
+  }
+}

package/templates/data-structure/queue/index.ts

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

package/templates/data-structure/queue/queue.ts

@@ -0,0 +1,66 @@
+class Node<T> {
+  value: T;
+  next: Node<T> | null;
+
+  constructor(value: T) {
+    this.value = value;
+    this.next = null;
+  }
+}
+
+export class Queue<T> {
+  _size: number;
+  _head: Node<T> | null;
+  _tail: Node<T> | null;
+
+  constructor() {
+    this._size = 0;
+    this._head = null;
+    this._tail = null;
+  }
+
+  enqueue(newValue: T) {
+    const newNode = new Node(newValue);
+
+    if (this._head === null) {
+      this._head = this._tail = newNode;
+      this._size += 1;
+      return;
+    }
+
+    if (this._tail) {
+      this._tail.next = newNode;
+    }
+
+    this._tail = newNode;
+    this._size += 1;
+  }
+
+  dequeue(): T | null {
+    if (this._head) {
+      const value = this._head.value;
+      this._head = this._head.next;
+      this._size -= 1;
+
+      return value;
+    }
+
+    return null;
+  }
+
+  peek() {
+    if (this._head) {
+      return this._head;
+    }
+
+    return null;
+  }
+
+  size() {
+    return this._size;
+  }
+
+  isEmpty() {
+    return this._size === 0;
+  }
+}

package/templates/data-structure/segment-tree/index.ts

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