Inlägg

const { readFileSync} = require('fs')

const findCurrentDiff = (input: number[]) =>
    input.reduce((acc: number[], curr: number, index: number) => {
        if(index === input.length - 1) return acc
        acc.push(input[index+1] - curr)
        return acc
    }, [] as number[])


const findDiffs = (input: number[], diffs: number[]): number[] => {
    const currentDiff = findCurrentDiff(input)

    if(currentDiff.every((number: number) => number === 0)) return diffs

    if(diffs.length === 0) diffs.push(currentDiff[currentDiff.length - 1])
    else diffs.push(currentDiff[currentDiff.length - 1] + diffs[diffs.length - 1])

    return findDiffs(currentDiff, diffs)
}


export const solver = (input: number[][]) =>
    input.reduce((sum, line) => {
        const diffs = findDiffs(line, []);
        return sum + line[line.length - 1] + diffs[diffs.length - 1];
    }, 0);


const input = readFileSync('testInput.txt', 'utf-8')
                .split('\n')
                .map((line: string) => line.split(' '))
                .map((line: string[]) => line.map((word: string) => parseInt(word)))


console.log(solver(input))

const {readFileSync} = require('fs')

type NodeChild = {
    left: string,
    right: string
}

const START_NODE = 'AAA'
const FINAL_NODE = 'ZZZ'

const generateNodes = (input: string[]) => {
    const nodes = new Map<string, NodeChild>()
    for(let i=1; i<input.length; i++) {

        const [parent, child] = input[i].split('=')
        const [left, right] = child.split(',')

        nodes.set(parent.replace('=', '').trim(), {
            left: left.replace('(', '').trim(),
            right: right.replace(')', '').trim()
        })
    }
    return nodes
}

const solver = (input: string[]) => {
console.time('solver')
   const instructions = input[0]

    const NodesMap = generateNodes(input)

    let path: string | null = null
    let i=0
    while(path !== FINAL_NODE) {
        const nodeChild: NodeChild = i === 0 ? NodesMap.get(START_NODE)! : NodesMap.get(path || '')!
        const currentInstruction: string = instructions[i % instructions.length]
        path = currentInstruction === 'L' ? nodeChild?.left : nodeChild?.right
        i++
    }
    console.timeEnd('solver')
    return i

}


const input = readFileSync('testInput.txt', 'utf8')
                .split('\n')
                .map((line: string) => line.trim())
                .filter((line: string) => line.length > 0)

console.log(solver(input))

import { findPathSteps, generateNodes, getLcmFromArray } from "./utils"

const {readFileSync} = require('fs')

const START_NODE = 'AAA'
const FINAL_NODE = 'ZZZ'

const solver = (input: string[]) => {
   const instructions = input[0]
    const {nodes} = generateNodes(input, START_NODE)
    return findPathSteps(START_NODE, nodes, instructions, (path: string | null) => path === FINAL_NODE)
}

const FIRST_NODE_CHAR = 'A'
const LAST_NODE_CHAR = 'Z'

const solver2 = (input: string[]) => {
    const instructions = input[0]
    const {nodes, nodesEndingWithA} = generateNodes(input, FIRST_NODE_CHAR)

    return getLcmFromArray(nodesEndingWithA.reduce((acc: number[], curr: string) => {
        acc.push(findPathSteps(curr, nodes, instructions, (path: string | null) => path?.endsWith(LAST_NODE_CHAR) ||false))
        return acc
    }, []))

}

const input = readFileSync('testInput.txt', 'utf8')
                .split('\n')
                .map((line: string) => line.trim())
                .filter((line: string) => line.length > 0)

console.log(solver(input))
console.log(solver2(input))

type NodeChild = {
    left: string,
    right: string
}

export const findPathSteps = (startNode: string, nodes: Map<string, NodeChild>, instructions: string, isFound: (path: string | null) => boolean) => {
    let path: string | null = null

    let i = 0
    for(i; !isFound(path); i++) {
        const nodeChild: NodeChild = i === 0 ? nodes.get(startNode)! : nodes.get(path || '')!
        const currentInstruction: string = instructions[i % instructions.length]
        path = currentInstruction === 'L' ? nodeChild?.left : nodeChild?.right
    }

    return i
}


export const generateNodes = (input: string[], findNodesStartingWith: string) => {
    const nodes = new Map<string, NodeChild>()
    const nodesEndingWithA: string[] = []

    for(let i=1; i<input.length; i++) {
        const [parent, child] = input[i].split('=')
        const [left, right] = child.split(',')

        const parentToAdd = parent.replace('=', '').trim()

        nodes.set(parentToAdd, {
            left: left.replace('(', '').trim(),
            right: right.replace(')', '').trim()
        })

        if(parentToAdd.endsWith(findNodesStartingWith)) {
            nodesEndingWithA.push(parentToAdd)
        }
    }
    return {nodes, nodesEndingWithA}
}

export function getLcmFromArray(arr: number[]) {
    let currentLcm = arr[0];
    for (let i = 1; i < arr.length; i++) {
        currentLcm = lcm(currentLcm, arr[i]);
    }
    return currentLcm;
}

function gcd(a: number, b: number) {
    if (!b) {
        return a;
    }

    return gcd(b, a % b);
}

function lcm(a: number, b: number) {
    return (a * b) / gcd(a, b);
}

const parseLine = (line: string) => {
    const newLine = line.split(':')

    // Plockar bort "Card 1" eftersom den hamnar i newLine[0] så returnerar jag allt till höger.
    return newLine[1].trim()
}

const file = readFileSync('testInput.txt', 'utf-8')
    .split('\n')
    .map((line: string) => parseLine(line))

const AmoutOfWinsMap = new Map<number, number>()

const getWins = (line: string, index: number) => {
    if(AmoutOfWinsMap.has(index)) {
        return AmoutOfWinsMap.get(index) || 0
    }

    const [winningNumbers, actualNumbers] = line.split('|')
    const winningNumbersArray = winningNumbers.split(' ')
    const actualNumbersArray = actualNumbers.split(' ')

    const intersection = winningNumbersArray.filter((number: string) => parseInt(number) && actualNumbersArray.includes(number))

    const wins = intersection.length
    AmoutOfWinsMap.set(index, wins)
    return wins
}


const part1 = (input: string[]) => {
    return input.reduce((acc: number, curr: string, index) => {
        const wins = getWins(curr, index)
        if(wins === 0) return acc

        const lineSum = Math.pow(2, wins-1)
        return acc + lineSum
    }, 0)
}


const countTotalCards = (allLines: string[], index: number) : number => {
    if(index >= allLines.length - 1) return 1

    const wins = getWins(allLines[index], index)
    if(wins === 0) return 1

    let totalCards = 1
    for(let i=1; i<=wins; i++) {
        if(index + i < allLines.length){
            totalCards += countTotalCards(allLines, index + i);
        }
    }

    return totalCards
}

const part2 = (input: string[]) => {
    return input.reduce((acc: number, curr: string, index: number) => {
        const wins = countTotalCards(input, index)
       return acc + wins
    }, 0)
}

const numbersMap = new Map<string, number>([
    ['one', 1],
    ['two', 2],
    ['three', 3],
    ['four', 4],
    ['five', 5],
    ['six', 6],
    ['even', 7],
    ['eight', 8],
    ['nine', 9]
])

const parseLintPart2 = (line: string) => {
    for (const number of numbersMap.keys()) {
        if(line.includes(number)) {
            line = line.replace(number, `${number}${numbersMap.get(number)!.toString()}${number}`)
        }
    }

    return line
}

const solver = (input: string[], part: number) =>
    input.reduce((acc, line) => {
        const newLines = part === 1 ? line : parseLintPart2(line)

        const numbers: number[] = []
            for(const char of newLines) {
                if(Number(char)) numbers.push(parseInt(char))
            }

        if(numbers.length >= 1) {
            acc += (numbers[0] * 10) + numbers[numbers.length - 1]
        }
        return acc
    }, 0)

import { parseInput } from "../parseInput"

const blueRegex = /(\d+)\sblue/g;
const redRegex = /(\d+)\sred/g;
const greenRegex = /(\d+)\sgreen/g;

const getMaxColor = (line: string, colorRegex: RegExp) => {
    const matches = [...line.matchAll(colorRegex)];
    return matches.length > 0 ? Math.max(...matches.map(match => parseInt(match[1]))) : 0;
}

const getMaxColors = (line: string) => {
    return {
        maxBlue: getMaxColor(line, blueRegex),
        maxRed: getMaxColor(line, redRegex),
        maxGreen: getMaxColor(line, greenRegex)
    };
}

const part1 = (input: string[]) =>  input.reduce((acc, line, index) => {
        const {maxBlue, maxRed, maxGreen } = getMaxColors(line)

        if(maxBlue <= 14 && maxRed <= 12 && maxGreen <= 13) {
            acc += index + 1
        }
        return acc
    }, 0)


const part2 = (input: string[]) => input.reduce((acc, line, index) => {
    const {maxBlue, maxRed, maxGreen } = getMaxColors(line)
    const product = maxBlue * maxRed * maxGreen

    return acc + product
  }, 0)


const parsedInput = parseInput('part1')
console.log(part1(parsedInput))
console.log(part2(parsedInput))