Phryxia

type Remove<R extends unknown[], I extends number, Out extends unknown[] = [], Count extends unknown[] = []>
  = R extends []
    ? Out
    : R extends [infer First, ...infer Rest]
      ? Count['length'] extends I
        ? Remove<Rest, I, Out, [...Count, 0]>
        : Remove<Rest, I, [...Out, First], [...Count, 0]>
      : never

type X = Remove<['a', 'b', 'c'], 1>

Phryxia

type RecursiveArray<T> = (T | RecursiveArray<T>)[]

type UtilizedRecursiveArray<T> = RecursiveArray<T> & {
    get(...indices: number[]): T | RecursiveArray<T>
    set(value: T, ...indices: number[]): T
}

function utilize<T>(rarr: RecursiveArray<T>): UtilizedRecursiveArray<T> {
    const res = rarr as any
    

Phryxia

interface BinaryTrieNode<T> {
    value?: T
    lc?: BinaryTrieNode<T>
    rc?: BinaryTrieNode<T>
}

class BinaryTrie<T> {
    root: BinaryTrieNode<T> = {}

    constructor(public readonly depth: number) {}

Phryxia

export function* combinateWithoutReplacement<T>(candidates: T[]) {
  const indices = candidates.map((_, i) => i)

  yield indices.map((i) => candidates[i])

  const c = indices.map(() => 0)
  let i = 1
  while (i < indices.length) {
    if (c[i] < i) {
      if (i % 2 === 0) {

Phryxia

export function* combinateWithReplacement<T>(candidates: T[], length: number) {
  if (length <= 0) return
  
  for (let i = 0; i < candidates.length ** length; ++i) {
    const result = new Array<T>(length)
    let j = i
    for (let k = length - 1; k >= 0; --k) {
      result[k] = candidates[j % candidates.length]
      j = Math.floor(j / candidates.length)
    }

Phryxia

import { AnchorHTMLAttributes, MouseEvent as ReactMouseEvent, useCallback } from 'react'

const InternalUrlRegexp = /^\.?\//
const StartingDotRegexp = /^\./

export function Anchor({
  children,
  href,
  onClick,
  ...rest

Phryxia

function* permutate<T>(domain: T[], length: number) {
  function* recurse(stack: T[] = [], depth: number = 0): Generator<T[]> {
    if (depth >= length) {
      yield stack.slice()
      return
    }

    for (const element of domain) {
      stack[depth] = element
      yield* recurse(stack, depth + 1)

Phryxia

class CumulativeSum {
    private sums: number[] = [0];

    constructor(itr: Iterable<number>) {
        const values = [...itr];

        for (let i = 0; i < values.length; ++i) {
            this.sums[i + 1] = this.sums[i] + values[i];
        }
    }

Phryxia

import { Vector2 } from 'three';

export function findCircumCircle(vertices: Vector2[]) {
    if (vertices.length === 1) {
        return [vertices[0], 0];
    }
    if (vertices.length === 2) {
        return [
            vertices[0].clone().add(vertices[1]).multiplyScalar(0.5),
            vertices[0].distanceTo(vertices[1]) * 0.5,

Phryxia

interface FloodingParams<T> {
    seeds: T[];
    spanner(seed: T): T[];
    serializer(seed: T): number | string;
    iterationLimit?: number;
}

export function flooding<T>({
    seeds,
    spanner,