aoc 2023 - d5

.js

const { readFileSync } = require("fs")

// const input = readFileSync("example.txt").toString()
const input = readFileSync("input.txt").toString()
const lines = input.split("\n").map(l => l.trim())

const seeds = lines.find(t => t.includes("seeds:"))
   .split(":")[1]
   .split(" ")
   .map(t => t.trim())
   .filter(t => t != "")
   .map(t => Number(t))

/** @typedef {{dst: number, src: number, range: number}} Range */
/** @typedef {{name: string, ranges: Range[]}} Map */

/** @type {Map[]} */
const maps = []
let isMap = false
/** @type {Map} */
let mapBuffer = {}
for (let i = 0; i < lines.length + 1; i++) {
   const line = lines?.[i] ?? ""
   if (line.includes("map:")) {
      isMap = true
      mapBuffer = {
         name: line.split("map")[0].trim(),
         ranges: []
      }
      continue
   }
   
   if (isMap) {
      if (line.trim() == "") {
         maps.push(mapBuffer)
         isMap = false
      } else {
         const [dst, src, range] = line.split(" ").map(l => l.trim())
         mapBuffer.ranges.push({
            dst: Number(dst), 
            src: Number(src), 
            range: Number(range)
         })
      }
   }
}

function transformSeed(value) {
   for (let i = 0; i < maps.length; i++) {
      const map = maps[i];
      for (let j = 0; j < map.ranges.length; j++) {
         const range = map.ranges[j];
         if (range.src <= value && range.src + range.range > value) {
            value = range.dst + (value - range.src)
            break;
         }
      }
   }

   return value
}

function p1() {
   const locations = []
   for (let i = 0; i < seeds.length; i++) {
      const seed = seeds[i];  
      let value = transformSeed(seed)
      locations.push(Number(value))
   }

   console.log("answer p1", Math.min(...locations))
}

// Very slow but too lazy to do anyhting about it
function p2() {
   let lowest = Infinity
   let iter = 0;
   for (let i = 0; i < seeds.length; i += 2) {
      const from = seeds[i]
      const range = seeds[i+1]
      for (let seed = from; seed < from + range; seed++) {
         lowest = Math.min(lowest, transformSeed(seed))
         if (iter % 10000000 == 0) {
            console.log("iteration:", iter, "left in this seed:", from+range - seed, 
               Math.floor((seed-from)/range*100)+"%", `${i/2} of ${seeds.length/2}`)
         }
         iter ++
      }

      console.log("finished values", from, range)
   }

   console.log("answer p2", lowest)
}

console.time("p1")
p1()
console.timeEnd("p1")
console.time("p2")
p2()
console.timeEnd("p2")

horrible brute forcing, there is probably a better way of doing it but gotta go fast