Skip to content

Instantly share code, notes, and snippets.

View Phryxia's full-sized avatar

Phryxia Phryxia

  • South Korea
View GitHub Profile
@Phryxia
Phryxia / curry.ts
Created May 27, 2024 03:00
TypeScript implementation of currying for generalized axis
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
Phryxia / recursiveArray.ts
Last active March 10, 2024 04:01
TypeScript implementation of Infinite Dimension Array
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
Phryxia / randomDataStructure.ts
Last active March 2, 2024 06:10
Random data structure using bless of dimensionality
interface BinaryTrieNode<T> {
value?: T
lc?: BinaryTrieNode<T>
rc?: BinaryTrieNode<T>
}
class BinaryTrie<T> {
root: BinaryTrieNode<T> = {}
constructor(public readonly depth: number) {}
@Phryxia
Phryxia / combinateWithoutReplacement.ts
Created January 17, 2024 09:41
TypeScript implementation of combination without replacement (i.e. Heap's Algorithm)
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
Phryxia / combinateWithReplacement.ts
Last active January 17, 2024 09:29
TypeScript implementation of combination with replacement of given elements with arbitrary length.
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
Phryxia / anchor.tsx
Last active January 17, 2024 07:25
React wrapper for vanilla anchor element considering `href` to internal pages
import { AnchorHTMLAttributes, MouseEvent as ReactMouseEvent, useCallback } from 'react'
const InternalUrlRegexp = /^\.?\//
const StartingDotRegexp = /^\./
export function Anchor({
children,
href,
onClick,
...rest
@Phryxia
Phryxia / permutation.ts
Created January 7, 2024 13:34
TypeScript implementation of permutation of given elements with specific length.
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
Phryxia / cumulativeSum.ts
Created August 13, 2023 11:54
TypeScript implementation of fast cumulative sum
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
Phryxia / circumcircle.ts
Created August 13, 2023 11:32
TypeScript implementation of circumcircle finder
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
Phryxia / flooding.ts
Created August 9, 2023 16:02
TypeScript implementation of universal flooding algorithm
interface FloodingParams<T> {
seeds: T[];
spanner(seed: T): T[];
serializer(seed: T): number | string;
iterationLimit?: number;
}
export function flooding<T>({
seeds,
spanner,