jjhiggz

import { buildMatrix } from "./build-matrix";

describe("Build Matrix", () => {
  it("Should turn my shit into matrix of rows", () => {
    expect(
      buildMatrix({
        // prettier-ignore
        elements: [
                1/1,
                1/3, 2/3,

jjhiggz

function reduce<T, U>(
  arr: T[], 
  reducer: (acc: U, currentValue: T, index: number, array: T[]) => U, 
  initialValue: U, 
  index: number = 0
): U {
  // Base case: if the index is out of bounds, return the accumulated value
  if (index >= arr.length) {
    return initialValue;
  }

jjhiggz

const at = <T,>(arr: T[], index: number) => index < 0 
    ? arr[arr.length + index] 
    : arr[index];

let recursiveFibCount = 0
const rFibonnaci = (num = 1, prevSeq: number[] = [0]): number => {
    if(prevSeq.length === num) {
       return at(prevSeq, -1)
    } 
    if(prevSeq.length === 1) return rFibonnaci(num, [0, 1])

jjhiggz

function moveAllInstancesToEnd<T extends any[] | string>(
    input: T, 
    shouldMoveCb: (input: T[number]) => unknown
): T {
   if(Array.isArray(input)){
    let notMoved: any = [] 
    let moved: any = []
    for(let el of input){
        if(shouldMoveCb(el)){
              moved.push(el)

jjhiggz

const getCounts = <T,>(
    input: Iterable<T>,
    shouldCountCb: (input: T) => unknown,
    serializeKey: (input: T) => any = input => input,
) => {
     let counts = {} as Record<any, number>
     for(let val of input){
        if(shouldCountCb(val)){
         counts[serializeKey(val)] = (counts[serializeKey(val)] ?? 0) + 1
        }

jjhiggz

export const Accordion = (
  {
     children, 
     show
  } : {
     children: ReactNode, 
     show: boolean
  }
) => {
return show ? 

jjhiggz

const result = <T,E extends Error>(cb: () => T): [null, E] | [T, null] => {
    try {
        return [cb(), null]
    } catch(e){
       return [null,e as E]
    }
}
const failsSometimes = () => {
    if(Math.random() > .5){
        throw new Error("Failed")

jjhiggz

class SyncPromise<T> {
    private value?: T;
    private error?: any;
    private isFulfilled: boolean = false;
    private isRejected: boolean = false;

    constructor(executor: () => T) {
        try {
            this.resolve(executor());
        } catch (e) {

jjhiggz

import { sumBy } from "remeda";
import { Matrix, MatrixCell, MatrixPosition } from "./data-structures/matrix";

const exampleText = await Bun.file("example.txt").text();

const buildMatrix = (input: string) =>
  new Matrix(input.split("\n").map((n) => n.split("")));

const tagValues = (input: Matrix<string>) => {
  let count = 0;

jjhiggz

// let's say I want to find the most occurring year here
const years = [1999,1993, 1992, 1991, 1991, 1999, 1993, 1993]

// I can use a Record<number, number> to create a map like so
// {1999: 2, 1993: 3, 1992: 1, 1991: 2, }

const yearMap: Record<number, number> = {}

for(let year of years){
   if(year in yearMap){