Skip to content
TypeScript
2.2 KB
Raw Blame
/**
 * 결정적 subset (PRD §6).
 * 같은 (bench, tasks, seed) → 항상 같은 subset. Math.random 금지, sha256 정렬.
 */
import { createHash } from "node:crypto";

export type Difficulty = "easy" | "medium" | "hard";

function rank(seed: number, id: string): string {
  return createHash("sha256").update(`${seed}:${id}`).digest("hex");
}

/** sha256(`${seed}:${id}`) 오름차순 정렬 후 앞 k 개. */
export function selectSubset(catalog: string[], k: number, seed: number): string[] {
  if (k <= 0) return [];
  const sorted = [...new Set(catalog)].sort((a, b) => {
    const ra = rank(seed, a);
    const rb = rank(seed, b);
    return ra < rb ? -1 : ra > rb ? 1 : a < b ? -1 : a > b ? 1 : 0;
  });
  return sorted.slice(0, k);
}

/**
 * easy/medium/hard 버킷 균형 선택 (난이도 메타 있는 벤치만).
 * 각 버킷 내부는 결정적 sha256 정렬. 라운드로빈으로 k 개를 채운다.
 */
export function selectBalanced(
  catalog: string[],
  k: number,
  seed: number,
  difficultyMap: Record<string, Difficulty>,
): string[] {
  if (k <= 0) return [];
  const buckets: Record<Difficulty, string[]> = { easy: [], medium: [], hard: [] };
  const unknown: string[] = [];
  for (const id of new Set(catalog)) {
    const d = difficultyMap[id];
    if (d) buckets[d].push(id);
    else unknown.push(id);
  }
  for (const d of ["easy", "medium", "hard"] as Difficulty[]) {
    buckets[d] = selectSubset(buckets[d], buckets[d].length, seed);
  }
  const orderedUnknown = selectSubset(unknown, unknown.length, seed);

  const order: Difficulty[] = ["easy", "medium", "hard"];
  const out: string[] = [];
  const cursors: Record<Difficulty, number> = { easy: 0, medium: 0, hard: 0 };
  let progressed = true;
  while (out.length < k && progressed) {
    progressed = false;
    for (const d of order) {
      if (out.length >= k) break;
      const arr = buckets[d];
      const c = cursors[d];
      if (c < arr.length) {
        out.push(arr[c]!);
        cursors[d] = c + 1;
        progressed = true;
      }
    }
  }
  // 버킷이 모자라면 난이도 미상으로 채움
  for (const id of orderedUnknown) {
    if (out.length >= k) break;
    out.push(id);
  }
  return out.slice(0, k);
}