Day 5: If You Give A Seed A Fertilizer

Saving the ranges of each map into a dict then itering over seeds.

def make_map(entries: "list[str]") -> "dict[tuple[int, int], int]":
  out = {}
  for entry in entries:
    items = [int(z) for z in entry.split(" ")]
    dest = items[0]
    src = items[1]
    rng = items[2]

    out[(src, src + rng)] = dest
  
  return out

def get_seeds(line):
  l = line.replace("seeds: ", "")
  return [int(i) for i in l.split(" ")]

def find_or_default(m: "dict[tuple[int, int], int]", t: int) -> int:
  for k in m.keys():
    if k[0] <= t <= k[1]:
      return m[k] + t - k[0]
  
  return t

with open("day5.txt") as f:
  data = f.read()
  seeds = get_seeds(data.split("\n")[0])
  print(seeds)

  zones = data.split("\n\n")[1:]

  maps = []

  for zone in zones:
    maps.append(make_map(zone.split("\n")[1:]))

  d = []
  for s in seeds:
    last = s
    for m in maps:
      last = find_or_default(m, last)
    d.append(last)
    
  print(min(d))

Working backwards; starting at 1 checks every number to see if, starting from the location, the output is a valid seed.

def make_map(entries: "list[str]") -> "dict[tuple[int, int], int]":
  out = {}
  for entry in entries:
    items = [int(z) for z in entry.split(" ")]
    dest = items[0]
    src = items[1]
    rng = items[2] - 1

    out[(dest, dest + rng)] = src
  
  return out

def get_seeds(line):
  l = [int(i) for i in line.replace("seeds: ", "").split(" ")]
  return [(l[x], l[x+1]) for x in range(0, len(l), 2)]

def is_seed(seeds, t) -> bool:
  for pair in seeds:
    if pair[0] <= t <= pair[0] + pair[1] - 1:
      return True
  return False

def find_or_default(m: "dict[tuple[int, int], int]", t: int) -> int:
  for k in m.keys():
    if k[0] <= t <= k[1]:
      return m[k] + t - k[0]
  
  return t

with open("day5.txt") as f:
  data = f.read()
  seeds = get_seeds(data.split("\n")[0].split("seeds: ")[1])

  zones = data.split("\n\n")[1:]

  maps = [make_map(zone.split("\n")[1:]) for zone in zones]

  for x in range(1, 1000000000):
    if x % 10000 == 0:
      print(x)
    last = x
    for m in maps[::-1]:
      last = find_or_default(m, last)
    if is_seed(seeds, last):
      print("DONE", x)
      break

use nom::{
    bytes::complete::tag,
    character::complete::{digit1, newline, space1},
    multi::{many0, many1, separated_list1},
    IResult,
};

#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct Almanac {
    pub seeds: Vec<usize>,
    pub maps: Vec<Vec<RangeMap>>,
}

#[derive(Debug, PartialEq, Eq, Hash, Clone)]
pub struct RangeMap {
    pub destination_range_start: usize,
    pub source_range_start: usize,
    pub range_length: usize,
}

pub fn parse(input: &str) -> IResult<&str, Almanac> {
    let (input, seeds) = parse_seeds(input)?;
    let (input, _) = tag("seed-to-soil map:\n")(input)?;
    let (input, seed_to_soil_map) = parse_map(input)?;
    let (input, _) = tag("soil-to-fertilizer map:\n")(input)?;
    let (input, soil_to_fertilizer_map) = parse_map(input)?;
    let (input, _) = tag("fertilizer-to-water map:\n")(input)?;
    let (input, fertilizer_to_water_map) = parse_map(input)?;
    let (input, _) = tag("water-to-light map:\n")(input)?;
    let (input, water_to_light_map) = parse_map(input)?;
    let (input, _) = tag("light-to-temperature map:\n")(input)?;
    let (input, light_to_temperature_map) = parse_map(input)?;
    let (input, _) = tag("temperature-to-humidity map:\n")(input)?;
    let (input, temperature_to_humidity_map) = parse_map(input)?;
    let (input, _) = tag("humidity-to-location map:\n")(input)?;
    let (input, humidity_to_location_map) = parse_map(input)?;

    Ok((
        input,
        Almanac {
            seeds,
            maps: vec![
                seed_to_soil_map,
                soil_to_fertilizer_map,
                fertilizer_to_water_map,
                water_to_light_map,
                light_to_temperature_map,
                temperature_to_humidity_map,
                humidity_to_location_map,
            ],
        },
    ))
}

fn parse_usize(input: &str) -> IResult<&str, usize> {
    let (input, num) = digit1(input)?;
    let num = num.parse::<usize>().unwrap();

    Ok((input, num))
}

fn parse_seeds(input: &str) -> IResult<&str, Vec<usize>> {
    let (input, _) = tag("seeds: ")(input)?;
    let (input, seeds) = separated_list1(space1, parse_usize)(input)?;
    let (input, _) = many1(newline)(input)?;

    Ok((input, seeds))
}

fn parse_map(input: &str) -> IResult<&str, Vec<RangeMap>> {
    let (input, map) = separated_list1(newline, parse_range)(input)?;
    let (input, _) = many0(newline)(input)?;

    Ok((input, map))
}

fn parse_range(input: &str) -> IResult<&str, RangeMap> {
    let (input, destination_range_start) = parse_usize(input)?;
    let (input, _) = space1(input)?;
    let (input, source_range_start) = parse_usize(input)?;
    let (input, _) = space1(input)?;
    let (input, range_length) = parse_usize(input)?;

    Ok((
        input,
        RangeMap {
            destination_range_start,
            source_range_start,
            range_length,
        },
    ))
}

#![feature(array_chunks)]

use std::{collections::VecDeque, ops::Range};

mod parser;
use parser::{Almanac, RangeMap};

fn main() {
    println!("Part 1: {}", part1(include_str!("../input.txt")));
    println!("Part 2: {}", part2(include_str!("../input.txt")));
}

impl RangeMap {
    fn lookup(&self, number: usize) -> usize {
        let source_range = self.source_range_start..(self.source_range_start + self.range_length);

        if !source_range.contains(&number) {
            return number;
        }

        let idx = number - self.source_range_start;

        self.destination_range_start + idx
    }

    fn range_split(&self, other_range: Range<isize>) -> Vec<Range<isize>> {
        fn range_intersects(r1: &Range<isize>, r2: &Range<isize>) -> bool {
            r1.start >= r2.start && r1.start < r2.end || r2.start >= r1.start && r2.start < r1.end
        }

        let my_range = (self.source_range_start as isize)
            ..((self.source_range_start + self.range_length) as isize);

        if !range_intersects(&my_range, &other_range) {
            return vec![other_range];
        }

        let mut result = Vec::with_capacity(3);

        // Left segment
        let s = my_range.start.min(other_range.start);
        let e = my_range.start.max(other_range.start);

        if s == other_range.start && s != my_range.start {
            result.push(s..e);
        }

        // Middle segment
        let s = my_range.start.max(other_range.start);
        let e = my_range.end.min(other_range.end);

        let shift = self.lookup(s as usize) as isize - s;
        result.push((s + shift)..(e + shift));

        // Right segment
        let s = my_range.end.min(other_range.end);
        let e = my_range.end.max(other_range.end);

        if e == other_range.end && e != my_range.end {
            result.push(s..e);
        }

        result.into_iter().filter(|r| !r.is_empty()).collect()
    }
}

fn lookup_seed_location(almanac: &Almanac, seed: usize) -> usize {
    let mut location_old = seed;
    let mut location = location_old;

    for entries in almanac.maps.iter() {
        for range_map in entries.iter() {
            location = range_map.lookup(location);
            if location != location_old {
                location_old = location;
                break;
            }

            location_old = location;
        }
    }

    location
}

fn lookup_best_seed(almanac: &Almanac, start: usize, length: usize) -> usize {
    let mut q = VecDeque::new();
    let mut r = Vec::new();

    q.push_front(((start as isize)..(start as isize + length as isize), 0, 0));

    while let Some((rng, map_id, entry_id)) = q.pop_front() {
        if map_id >= almanac.maps.len() {
            r.push(rng.start as usize);
            continue;
        }

        let map = &almanac.maps[map_id];

        if entry_id >= map.len() {
            q.push_back((rng.clone(), map_id + 1, 0));
            continue;
        }

        let entry = &map[entry_id];

        let new_rngs = entry.range_split(rng.clone());

        for new_rng in new_rngs.iter() {
            if rng.clone().start == new_rng.start && rng.clone().end == new_rng.end {
                q.push_back((rng.clone(), map_id, entry_id + 1));
            } else {
                q.push_back((new_rng.clone(), map_id + 1, 0));
            }
        }
    }

    r.into_iter().min().unwrap_or(start)
}

fn part1(input: &str) -> usize {
    let almanac = parser::parse(input).unwrap().1;

    almanac
        .seeds
        .iter()
        .cloned()
        .map(|seed| lookup_seed_location(&almanac, seed))
        .min()
        .unwrap()
}

fn part2(input: &str) -> usize {
    let almanac = parser::parse(input).unwrap().1;

    let mut minimum = usize::MAX;

    for [start, length] in almanac.seeds.array_chunks() {
        let cur_best = lookup_best_seed(&almanac, *start, *length);

        if cur_best < minimum {
            minimum = cur_best;
        }
    }

    minimum
}

import sys

bks = [ bks.splitlines() for bks in sys.stdin.read().split( "\n\n" ) ]
sds = [ int( i ) for i in bks[ 0 ][ 0 ].split()[ 1 : ] ]
mps = [ [ [ int( i ) for i in ln.split() ]
          for ln in bk[ 1 : ] ]
        for bk in bks[ 1 : ] ]


# vls = [ ( b, b + 1 ) for b in sds ]                                   # For Part 1
vls = [ ( b, b + l ) for b, l in zip( sds[ : : 2 ], sds[ 1 : : 2 ] ) ]  # For Part 2
for mp in mps:
    nxtm = []
    for rd, rs, rl in mp:
        nxtr = []
        for vl, vh in vls:
            s = sorted( [ vl, vh, rs, rs + rl ] )
            for l, h in zip( s, s[ 1 : ] ):
                if vl <= l < h <= vh:
                    if rs <= l < h <= rs + rl:
                        nxtm.append( ( l - rs + rd, h - rs + rd ) )
                    else:
                        nxtr.append( ( l, h ) )
        vls = nxtr
    vls += nxtm

print( min( l for l, h in vls ) )

module Main (main) where

import AOCTools ( splitBy )

main :: IO ()
main = do
    input <- readFile "./input.txt"
    putStrLn $ "Part 1: " ++ show (solve1 $ parseInput input)
    putStrLn $ "Part 2: " ++ show (solve2 $ parseInput input)

-- Data Types & Parsing

data ProductionMapping = Mapping {
    sourceName :: String,
    destinationName :: String,
    mappings :: [RangeMap]
} deriving (Show)

data RangeMap = RangeMap {
    destinationStart :: Integer,
    sourceStart :: Integer,
    rangeLength :: Integer
} deriving (Show)

data Range = Range {
    start :: Integer,
    end :: Integer
} deriving (Show)

parseInput :: String -> ([Integer], [ProductionMapping])
parseInput input = (seeds, prodMaps) where
    sections = splitBy "\n\n" input
    seeds = map read (tail . words . head $ sections)
    prodMaps = map parseProductionMapping $ tail sections

parseProductionMapping :: String -> ProductionMapping
parseProductionMapping input = Mapping source dest maps where
    [source, _, dest] = take 3 (splitBy "-" (head (words input)))
    maps = map parseRangeMap $ tail (lines input)

parseRangeMap :: String -> RangeMap
parseRangeMap s = RangeMap dst src rng where
    [dst, src, rng] = map read $ words s

-- Helper Functions

rangeIntersection:: Range -> Range -> Maybe Range
rangeIntersection(Range a b) (Range c d)
    | b <= c = Nothing
    | a >= d = Nothing
    | otherwise = Just $ Range (max a c) (min b d)

rangeSubtraction :: Range -> Range -> [Range]
rangeSubtraction (Range a b) (Range c d) = filter (\r -> start r < end r) ranges where
    ranges = [Range a (min b c), Range (max a d) b]

-- Part 1

solve1 :: ([Integer], [ProductionMapping]) -> Integer
solve1 (seeds, prodMaps) = minimum locations where
    locations = map (findLocation "seed") seeds
    findLocation :: String -> Integer -> Integer
    findLocation "location" val = val
    findLocation stage val = uncurry findLocation $ findNextStage prodMaps stage val

findNextStage :: [ProductionMapping] -> String -> Integer -> (String, Integer)
findNextStage prodMaps stage val = (stage', val') where
    mapping = head $ filter (\m -> sourceName m == stage) prodMaps
    stage' = destinationName mapping
    val' = processStage (mappings mapping) val

processStage :: [RangeMap] -> Integer -> Integer
processStage [] v = v
processStage ((RangeMap dst src rng):remMaps) v
    | src <= v && v < src + rng = v - src + dst
    | otherwise = processStage remMaps v

-- Part 2

solve2 :: ([Integer], [ProductionMapping]) -> Integer
solve2 (seeds, prodMaps) = minimum (map start locations) where
    seedRanges = pairUp seeds where
        pairUp [] = []
        pairUp (a:b:t) = Range a (a+b) : pairUp t
    locations = findLocation "seed" seedRanges
    findLocation :: String -> [Range] -> [Range]
    findLocation "location" ranges = ranges
    findLocation stage ranges = uncurry findLocation $ findNextStageRange prodMaps stage ranges

findNextStageRange :: [ProductionMapping] -> String -> [Range] -> (String, [Range])
findNextStageRange prodMaps stage ranges = (stage', ranges') where
    mapping = head $ filter (\m -> sourceName m == stage) prodMaps
    stage' = destinationName mapping
    ranges' = concatMap (processStageRange (mappings mapping)) ranges

processStageRange :: [RangeMap] -> Range -> [Range]
processStageRange [] r = [r]
processStageRange ((RangeMap dst src rng):remMaps) r = case rangeIntersection r srcRange of
    Nothing -> processStageRange remMaps r
    Just (Range a b) -> overlap : remainder where
        overlap = Range (a - src + dst) (b - src + dst)
        remainder = concatMap (processStageRange remMaps) (rangeSubtraction r srcRange)
    where
        srcRange = Range src (src + rng)

data Range = Range {
    start :: Integer,
    end :: Integer
} deriving (Show)

rangeIntersection :: Range -> Range -> Maybe Range
rangeIntersection (Range a b) (Range c d)
    | b <= c = Nothing
    | a >= d = Nothing
    | otherwise = Just $ Range (max a c) (min b d)

rangeSubtraction :: Range -> Range -> [Range]
rangeSubtraction (Range a b) (Range c d) = filter (\r -> start r < end r) ranges where
    ranges = [Range a (min b c), Range (max a d) b]

package aoc2023

object Day5 {
    data class Range(val start: Long, val end: Long, val shift: Long)

    fun parse(input: String): Pair<List<Long>, List<List<Range>>> {
        fun longsOf(s: String) = Regex("""\d+""").findAll(s).map { it.value.toLong() }
        fun rangeOf(s: String) = longsOf(s).toList().let { (dest, src, n) -> Range(src, src + n, dest - src) }
        fun augment(map: List<Range>): List<Range> {
            val sentinels = mutableListOf<Range>()
            if (map.first().start != 0L) {
                sentinels.add(Range(0, map.first().start, 0))
            }
            for (i in map.indices.drop(1)) {
                if (map[i - 1].end != map[i].start) {
                    sentinels.add(Range(map[i - 1].end, map[i].start, 0))
                }
            }
            if (map.last().end != Long.MAX_VALUE) {
                sentinels.add(Range(map.last().end, Long.MAX_VALUE, 0))
            }
            return (map + sentinels).sortedBy { it.start }
        }

        fun mapOf(s: String) = s.lines().drop(1).map { rangeOf(it) }.sortedBy { it.start }.let { augment(it) }
        val parts = input.trim().split("\n\n")
        val seeds = longsOf(parts.first()).toList()
        val maps = parts.drop(1).map { mapOf(it) }
        return Pair(seeds, maps)
    }

    fun part1(input: String): Long {
        val (seeds, maps) = parse(input)
        fun convert(seed: Long, maps: List<List<Range>>) = maps.fold(seed) { num, map ->
            val range = map.first { it.start <= num && num < it.end }
            num + range.shift
        }
        return seeds.minOf { convert(it, maps) }
    }

    fun part2(input: String): Long {
        val (seeds, maps) = parse(input)
        val chunks0 = seeds.chunked(2).map { (start, n) -> Range(start, start + n, 0) }
        fun convert1(chunk0: Range, map: List<Range>): List<Range> {
            val inChunks = ArrayDeque<Range>()
            inChunks.addLast(chunk0)
            val outChunks = ArrayDeque<Range>()
            while (inChunks.isNotEmpty()) {
                val chunk = inChunks.removeFirst()
                val range = map.first { it.start <= chunk.start && chunk.start < it.end }
                if (chunk.end <= range.end) {
                    outChunks.addLast(Range(chunk.start + range.shift, chunk.end + range.shift, 0))
                } else {
                    outChunks.addLast(Range(chunk.start + range.shift, range.end + range.shift, 0))
                    inChunks.addLast(Range(range.end, chunk.end, 0))
                }
            }
            return outChunks
        }
        return maps.fold(chunks0) { chunks, map -> chunks.flatMap { chunk -> convert1(chunk, map) } }.minOf { it.start }
    }
}

import json
from copy import copy


class Solver:

    def __init__(self):
        with open('info.json', 'r', encoding='utf-8') as f:
            self.raw_data = json.load(f)
        self.data = self.parse_lines()

    def parse_lines(self):
        data = {
            'seeds': [int(x) for x in self.raw_data['seeds'].split()],
            'maps': [self.parse_map(x) for x in self.raw_data['maps']]
        }
        return data

    @classmethod
    def parse_map(cls, map_set):
        return [cls.parse_one_entry(x) for x in map_set.split('\n')]

    @staticmethod
    def parse_one_entry(entry):
        destination = int(entry.split()[0])
        source = int(entry.split()[1])
        length = int(entry.split()[2])
        return {
            'destination': destination,
            'source': source,
            'length': length,
            'difference': destination - source,
            'min': source,
            'max': source + length,
        }

    def run(self):
        seeds = copy(self.data['seeds'])
        for seed_map in self.data['maps']:
            seeds = [self.do_map(seed, seed_map) for seed in seeds]
        return min(seeds)

    @staticmethod
    def do_map(n, seed_map):
        for map_item in seed_map:
            if map_item['max'] > n >= map_item['min']:
                return n + map_item['difference']
        return n


if __name__ == '__main__':
    print(Solver().run())

import json
from copy import deepcopy


class Solver:

    def __init__(self):
        with open('info.json', 'r', encoding='utf-8') as f:
            self.raw_data = json.load(f)
        self.data = self.parse_lines()

    def parse_lines(self):
        data = {
            'seeds': [self.parse_seed(x) for x in self.raw_data['seeds'].split(';')],
            'maps': [self.parse_map(x) for x in self.raw_data['maps']]
        }
        return data

    @staticmethod
    def parse_seed(seed):
        start = int(seed.split()[0])
        length = int(seed.split()[1])
        return {
            'min': start,
            'max': start + length - 1
        }

    @classmethod
    def parse_map(cls, map_set):
        return [cls.parse_one_entry(x) for x in map_set.split('\n')]

    @staticmethod
    def parse_one_entry(entry):
        destination = int(entry.split()[0])
        source = int(entry.split()[1])
        length = int(entry.split()[2])
        return {
            'difference': destination - source,
            'min': source,
            'max': source + length - 1,
        }

    def run(self):
        seeds = deepcopy(self.data['seeds'])
        for seed_map in self.data['maps']:
            found_this_round = []
            not_found_yet = []
            for map_item in seed_map:
                not_found_yet = []
                print(f'about to process: {str(seeds)}')
                for seed in seeds:
                    if map_item['max'] < seed['min']:
                        print(f'case 1 - {str(seed)}')
                        not_found_yet.append(seed)
                        continue
                    if map_item['min'] > seed['max']:
                        print(f'case 2 - {str(seed)}')
                        not_found_yet.append(seed)
                        continue
                    if map_item['min'] <= seed['min'] and map_item['max'] >= seed['max']:
                        # map contains the entire seed round; we dont need to look anymore
                        print(f'case 3 - {str(seed)}')
                        found_this_round.append({
                            'min': seed['min'] + map_item['difference'],
                            'max': seed['max'] + map_item['difference'],
                        })
                        continue
                    if seed['min'] < map_item['min'] <= seed['max'] <= map_item['max']:
                        # the map item min is between seed min and seed max
                        print(f'case 4 - {str(seed)}')
                        # what we didnt find
                        not_found_yet.append({
                            'min': seed['min'],
                            'max': map_item['min'] - 1
                        })
                        # what we found
                        found_this_round.append({
                            'min': map_item['min'] + map_item['difference'],
                            'max': seed['max'] + map_item['difference']
                        })
                    if map_item['min'] <= seed['min'] <= map_item['max'] < seed['max']:
                        print(f'case 5 - {str(seed)}')
                        found_this_round.append({
                            'min': seed['min'] + map_item['difference'],
                            'max': map_item['max'] + map_item['difference']
                        })
                        not_found_yet.append({
                            'min': map_item['max'] + 1,
                            'max': seed['max']
                        })
                    if map_item['min'] > seed['min'] and map_item['max'] < seed['max']:
                        print(f'case 6 - {str(seed)}')
                        found_this_round.append({
                            'min': map_item['min'] + map_item['difference'],
                            'max': map_item['max'] + map_item['difference'],
                        })
                        not_found_yet.append({
                            'min': seed['min'],
                            'max': map_item['min'] - 1,
                        })
                        not_found_yet.append({
                            'min': map_item['max'] + 1,
                            'max': seed['max'],
                        })
                seeds = not_found_yet
                print(f"one map range: {str(seeds)} ({map_item['min']} -> {map_item['max']})")
            seeds = found_this_round + not_found_yet
            print(f"new entire round**************: {str(seeds)}")

        return min([seed['min'] for seed in seeds])

    @staticmethod
    def do_map(n, seed_map):
        for map_item in seed_map:
            if map_item['max'] > n >= map_item['min']:
                return n + map_item['difference']
        return n


if __name__ == '__main__':
    print(Solver().run())

Dim Seeds() As LongLong
Dim SeedSoilMap() As New RangeMap
Dim SoilToFertilizerMap() As New RangeMap
Dim FertilizerToWaterMap() As New RangeMap
Dim WaterToLightMap() As New RangeMap
Dim LightToTemperatureMap() As New RangeMap
Dim TemperatureToHumidityMap() As New RangeMap
Dim HumidityToLocationMap() As New RangeMap

Function ParseInput(Problem As String)
    Lines = Split(Problem, vbCr & vbLf)
    
    'Seeds
    SeedsRaw = Split(Lines(0), " ")
    SeedCount = GetLength(SeedsRaw) - 1
    ReDim Seeds(0 To SeedCount - 1)
    For i = 0 To SeedCount - 1
        Casted = CLngLng(SeedsRaw(i + 1))
        Seeds(i) = Casted
    Next i
    
    ParseMap Lines, "seed-to-soil", SeedSoilMap
    ParseMap Lines, "soil-to-fertilizer", SoilToFertilizerMap
    ParseMap Lines, "fertilizer-to-water", FertilizerToWaterMap
    ParseMap Lines, "water-to-light", WaterToLightMap
    ParseMap Lines, "light-to-temperature", LightToTemperatureMap
    ParseMap Lines, "temperature-to-humidity", TemperatureToHumidityMap
    ParseMap Lines, "humidity-to-location", HumidityToLocationMap
End Function

Sub ParseMap(Lines As Variant, Name As String, ByRef Target As Variant)
    found = False
    Index = 0
    ReDim Target(0)
    
    For Each Line In Lines
        If found And Line = "" Then
            Exit For
        ElseIf found Then
            Cols = Split(Line, " ")
            ReDim Preserve Target(Index)
            Set Target(Index) = New RangeMap
            Target(Index).From CLngLng(Cols(0)), CLngLng(Cols(1)), CLngLng(Cols(2))
            Index = Index + 1
        ElseIf Line = Name & " map:" Then
            found = True
        End If
    Next Line
End Sub


Function GetLength(a As Variant) As Integer
    If IsEmpty(a) Then
        GetLength = 0
    Else
        GetLength = UBound(a) - LBound(a) + 1
    End If
End Function

Function GetMappedRange(ByRef Ranges As Variant, ByVal Index As LongLong) As LongLong
    For Each Rng In Ranges
        If Rng.Src <= Index And Rng.SrcEnd >= Index Then
            Offset = Index - Rng.Src
            GetMappedRange = Rng.Dest + Offset
            Exit Function
        End If
    Next Rng
    'If unmapped, then use the same output
    GetMappedRange = Index
End Function

Function Solve1() As String
    Debug.Print "New Solve1"
    Out = 9.22337203685478E+18
    For Each Seed In Seeds
        Soil = GetMappedRange(SeedSoilMap, Seed)
        Fertilizer = GetMappedRange(SoilToFertilizerMap, Soil)
        Water = GetMappedRange(FertilizerToWaterMap, Fertilizer)
        Light = GetMappedRange(WaterToLightMap, Water)
        Temperature = GetMappedRange(LightToTemperatureMap, Light)
        Humidity = GetMappedRange(TemperatureToHumidityMap, Temperature)
        Location = GetMappedRange(HumidityToLocationMap, Humidity)
        
        Debug.Print Seed & " - " & Soil & " - " & Fertilizer & " - " & Water & " - " & Light & " - " & Temperature & " - " & Humidity & " - " & Location
        If Location < Out Then
            Out = Location
        End If
    Next Seed
    Solve1 = Out
End Function

Function Solve2() As String
    Debug.Print "New Solve2"
    Out = 9.22337203685478E+18
    For i = 0 To GetLength(Seeds) - 1 Step 2
        RangeStart = Seeds(i)
        RangeLen = Seeds(i + 1)
        For Seed = RangeStart To RangeStart + RangeLen
            Soil = GetMappedRange(SeedSoilMap, Seed)
            Fertilizer = GetMappedRange(SoilToFertilizerMap, Soil)
            Water = GetMappedRange(FertilizerToWaterMap, Fertilizer)
            Light = GetMappedRange(WaterToLightMap, Water)
            Temperature = GetMappedRange(LightToTemperatureMap, Light)
            Humidity = GetMappedRange(TemperatureToHumidityMap, Temperature)
            Location = GetMappedRange(HumidityToLocationMap, Humidity)
            
            Debug.Print Seed & " - " & Soil & " - " & Fertilizer & " - " & Water & " - " & Light & " - " & Temperature & " - " & Humidity & " - " & Location
            If Location < Out Then
                Out = Location
            End If
        Next Seed
    Next i
    Solve2 = Out
End Function

Private Sub CommandButton1_Click()
    ParseInput (InputBox.Value)
    OutputBox.Value = Solve1()
End Sub

Private Sub CommandButton2_Click()
    ParseInput (InputBox.Value)
    OutputBox.Value = Solve2()
End Sub

RangeMap.cls

'[Dest, Dest + Len)
Public Dest As LongLong
'[Src, Src + Len)
Public Src As LongLong
Public Length As LongLong

Public Sub From(d As LongLong, s As LongLong, l As LongLong)
    Dest = d
    Src = s
    Length = l
End Sub


'Index of the last src member
Public Property Get DestEnd() As LongLong
    DestEnd = Dest + Length - 1
End Property

'Index of the last src member
Public Property Get SrcEnd() As LongLong
    SrcEnd = Src + Length - 1
End Property

use std::fmt::{Debug, Formatter};
use std::io;
use std::io::Read;
use rayon::prelude::*;

/// Map from a src-dst to another range of the same size
struct RangeMap {
    pub src: u64,
    pub dst: u64,
    pub len: u64,
}

impl RangeMap {
    pub fn src_end(&self) -> u64 {
        self.src + self.len - 1
    }
    pub fn dst_end(&self) -> u64 {
        self.dst + self.len - 1
    }
}

impl Debug for RangeMap {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}..={} -> {}..={}", self.src, self.src_end(), self.dst, self.dst_end())
    }
}

#[derive(Debug)]
struct Problem {
    pub seeds: Vec<u64>,
    pub maps: Vec<Vec<RangeMap>>,
}

fn parse_input(input: &str) -> Problem {
    let mut lines = input.lines();
    // parse seed
    let seed_line = lines.next().unwrap();
    let seeds = seed_line["seeds: ".len()..].split(" ").map(|i| i.parse().unwrap()).collect();

    let _ = lines.next().unwrap();
    // parse the maps
    let mut maps = Vec::new();
    let mut cur_map = None;
    for line in lines {
        if line == "" {
            continue
        } else if line.ends_with(" map:") {
            maps.push(Vec::new());
            cur_map = maps.last_mut();
        } else {
            let mut numbers = line.split(" ").map(|v| v.parse().unwrap());
            cur_map.as_mut().unwrap().push(RangeMap {
                dst: numbers.next().unwrap(),
                src: numbers.next().unwrap(),
                len: numbers.next().unwrap(),
            })
        }
    }

    Problem {
        seeds,
        maps,
    }
}

fn get_mapped(ranges: &Vec<RangeMap>, input: u64) -> u64 {
    for range in ranges {
        if range.src <= input && range.src_end() >= input {
            let offset = input - range.src;
            return range.dst + offset;
        }
    }
    // If unmatched, then return input
    input
}

fn walk_ranges(ranges: &Vec<Vec<RangeMap>>, input: u64) -> u64 {
    let mut out = input;
    for range in ranges {
        out = get_mapped(range, out);
    }
    return out;
}

fn main() {
    let mut stdin = io::stdin();
    let mut input = String::new();
    stdin.read_to_string(&mut input).unwrap();

    let problem = parse_input(&input);
    println!("{:?}", problem);

    // let problem1 = problem.seeds.iter().map(|v| walk_ranges(&problem.maps, *v)).min().unwrap();
    // println!("Problem1: {}", problem1);

    let ranges: Vec<_> = problem.seeds.chunks(2)
        .map(|v| v[0]..(v[0]+v[1]))
        .collect();

    println!("total pairs: {}", ranges.len());

    let problem2 = ranges.into_par_iter()
        .map(|rng| {
            rng.into_iter().map(|v| walk_ranges(&problem.maps, v)).min().unwrap()
        })
        .inspect(|min_val| {
            println!("Finished a range -> {}", min_val);
        })
        .min().unwrap();
    println!("Problem2: {}", problem2);
}