Day 5: If You Give a Seed a Fertilizer
Megathread guidelines
- Keep top level comments as only solutions, if you want to say something other than a solution put it in a new post. (replies to comments can be whatever)
- Code block support is not fully rolled out yet but likely will be in the middle of the event. Try to share solutions as both code blocks and using something such as https://topaz.github.io/paste/ , pastebin, or github (code blocks to future proof it for when 0.19 comes out and since code blocks currently function in some apps and some instances as well if they are running a 0.19 beta)
FAQ
- What is this?: Here is a post with a large amount of details: https://programming.dev/post/6637268
- Where do I participate?: https://adventofcode.com/
- Is there a leaderboard for the community?: We have a programming.dev leaderboard with the info on how to join in this post: https://programming.dev/post/6631465
πThis post will be unlocked when there is a decent amount of submissions on the leaderboard to avoid cheating for top spots
π Unlocked after 27 mins (current record for time, hard one today)
Rust
Ooof. Part 1 was easy enough, but for part two I initially went with the naive solution of trying every single seed which took more than a minute (I never really measured). Although that got me the right answer, to me that was just unacceptable.
I proceeded to try and combine all mappings into one but gave up after spending way too much time on it.
Then I had the idea that the lowest number in the end must lie at the beginning of a range somewhere. Either the start of a seed range in the beginning or the start of a range in one of the mappings. Any in-between numbers must end up with a higher result. So I considered the start points of all ranges, went through the mappings in reverse to find out if that point is actually within a seed range, and only tested those starting points.
Finally I had only 183 points to test which ran much faster (0.9ms).
Then I had the idea that the lowest number in the end must lie at the beginning of a range somewhere. Either the start of a seed range in the beginning or the start of a range in one of the mappings.
This really helped me out. I was stuck on either trying every single seed, or working backwards and trying every single location from 0 to infinity, and couldnβt wrap my head around how to filter down the list to be manageable. Your comment made it all make sense.
In the end, was able to work backwards with the 172 lowest locations in each range to get potential seeds, and from there was able to get a short list of 89 valid seeds (including the original seed values) to then figure out which one has the shortest location.
Thanks!
Iβm a little confused about this one. The mappings are total, that is any number that is not defined explicitly gets mapped to itself. So itβs easy to create an example where the lowest number does not get mentioned within a range:
seeds: 0 3
seed-to-soil map:
10 0 2
soil-to-fertilizer map:
100 200 5
fertilizer-to-water map:
100 200 5
water-to-light map:
100 200 5
light-to-temperature map:
100 200 5
temperature-to-humidity map:
100 200 5
humidity-to-location map:
100 200 5
Here, we have seeds 0, 1 and 2. seed 0 gets mapped to location 10, seed 1 gets mapped to location 11 and seed 2 gets mapped to location 2. That means location 2 would be the answer, but itβs not a start of any range. I guess this just doesnβt happen in any of the inputs?
EDIT: actually itβs double weird. If you implemented a backwards search, that is you create reverse mappings and then try out all locations (which is what I and many others did), the result of the above example is location 0, whereas if you create a forwards brute force of all seeds, the result is 2. For the reverse approach to work in all cases, the mappings would have to be bijective.
Indeed, my solution fails on this input (returns 10, which is the location to seed 0), but it can be easily solved by also adding the ends of each range as well.
Maybe the input was quite forgiving. Thinking about it more, reversing the mapping can get quite involved, because it is neither surjective nor injective, so the inverse can actually have any number of results.
In your example there is no input that maps to 0, but there are two inputs that map to 11 (1 and 11). If the seed-to-soil map also included 10 20 2
, 21 would also map to 11.
[JavaScript] Well that was by far the hardest out of all of the days, part 1 was relatively fine but part 2 took me awhile of trying different things
Ended up solving it by working backwards by trying different location values and seeing if that can become a valid seed. Takes around 3 secs to compute the answer.
Part 1 Code Block
// Part 1
// ======
function part1(input) {
const split = input.split("\r\n\r\n");
let pastValues = split[0].match(/\d+/g).map((x) => parseInt(x));
let currentValues = [];
for (const section of split.slice(1)) {
for (const line of section.split("\r\n")) {
const values = line.match(/\d+/g)?.map((x) => parseInt(x));
if (!values) {
continue;
}
const sourceStart = values[1];
const destinationStart = values[0];
const length = values[2];
for (let i = 0; i < pastValues.length; i++) {
if (
pastValues[i] >= sourceStart &&
pastValues[i] < sourceStart + length
) {
currentValues.push(destinationStart + pastValues[i] - sourceStart);
pastValues.splice(i, 1);
i--;
}
}
}
for (let i = 0; i < pastValues.length; i++) {
currentValues.push(pastValues[i]);
}
pastValues = [...currentValues];
currentValues = [];
}
return Math.min(...pastValues);
}
Part 2 Code Block
// Part 2
// ======
function part2(input) {
const split = input.split("\r\n\r\n");
let seeds = split[0].match(/\d+/g).map((x) => parseInt(x));
seeds = seeds
.filter((x, i) => i % 2 == 0)
.map((x, i) => [x, seeds[i * 2 + 1]]);
const maps = split
.slice(1)
.map((x) => {
const lines = x.split("\r\n");
return lines
.map((x) => x.match(/\d+/g)?.map((x) => parseInt(x)))
.filter((x) => x);
})
.reverse();
for (let i = 0; true; i++) {
let curValue = i;
for (const map of maps) {
for (const line of map) {
const sourceStart = line[1];
const destinationStart = line[0];
const length = line[2];
if (
curValue >= destinationStart &&
curValue < destinationStart + length
) {
curValue = sourceStart + curValue - destinationStart;
break;
}
}
}
for (const [seedRangeStart, seedRangeLength] of seeds) {
if (
curValue >= seedRangeStart &&
curValue < seedRangeStart + seedRangeLength
) {
return i;
}
}
}
}
Ended up solving it by working backwards by trying different location values and seeing if that can become a valid seed.
Huh, thatβs clever.
Haskell
Not hugely proud of this one; part one would have been easier if Iβd spend more time reading the question and not started on an overly-general solution, and I lost a lot of time on part two to a missing a +
. More haste, less speed, eh?
import Data.List
import Data.List.Split
readInput :: String -> ([Int], [(String, [(Int, Int, Int)])])
readInput s =
let (seedsChunk : mapChunks) = splitOn [""] $ lines s
seeds = map read $ tail $ words $ head seedsChunk
maps = map readMapChunk mapChunks
in (seeds, maps)
where
readMapChunk (title : rows) =
let name = head $ words title
entries = map ((\[a, b, c] -> (a, b, c)) . map read . words) rows
in (name, entries)
part1 (seeds, maps) =
let f = foldl1' (flip (.)) $ map (ref . snd) maps
in minimum $ map f seeds
where
ref [] x = x
ref ((a, b, c) : rest) x =
let i = x - b
in if i >= 0 && i < c
then a + i
else ref rest x
mapRange :: [(Int, Int, Int)] -> (Int, Int) -> [(Int, Int)]
mapRange entries (start, end) =
go start $ sortOn (\(_, b, _) -> b) entries
where
go i [] = [(i, end)]
go i es@((a, b, c) : rest)
| i > end = []
| b > end = go i []
| b + c <= i = go i rest
| i < b = (i, b - 1) : go b es
| otherwise =
let d = min (b + c - 1) end
in (a + i - b, a + d - b) : go (d + 1) rest
part2 (seeds, maps) =
let seedRanges = map (\[a, b] -> (a, a + b - 1)) $ chunksOf 2 seeds
in minimum $ map fst $ foldl' (flip mapRanges) seedRanges $ map snd maps
where
mapRanges m = concatMap (mapRange m)
main = do
input <- readInput <$> readFile "input05"
print $ part1 input
print $ part2 input
Odin
When I read the problem description I expected the input to also be 2 digit numbers. When I looked at it I just had to say βhuh.β
Second part I think you definitely have to do in reverse (edit: if you are doing a linear search for the answer), as that allows you to nope out as soon as you find a match, whereas with doing it forward you have to keep checking just in case.
package day5
import "core:fmt"
import "core:strings"
import "core:slice"
import "core:strconv"
Range :: struct {
dest: int,
src: int,
range: int,
}
Mapper :: struct {
ranges: []Range,
}
parse_range :: proc(s: string) -> (ret: Range) {
rest := s
parseLen := -1
destOk: bool
ret.dest, destOk = strconv.parse_int(rest, 10, &parseLen)
rest = strings.trim_left_space(rest[parseLen:])
srcOk: bool
ret.src, srcOk = strconv.parse_int(rest, 10, &parseLen)
rest = strings.trim_left_space(rest[parseLen:])
rangeOk: bool
ret.range, rangeOk = strconv.parse_int(rest, 10, &parseLen)
return
}
parse_mapper :: proc(ss: []string) -> (ret: Mapper) {
ret.ranges = make([]Range, len(ss)-1)
for s, i in ss[1:] {
ret.ranges[i] = parse_range(s)
}
return
}
parse_mappers :: proc(ss: []string) -> []Mapper {
mapsStr := make([dynamic][]string)
defer delete(mapsStr)
restOfLines := ss
isLineEmpty :: proc(s: string)->bool {return len(s)==0}
for i, found := slice.linear_search_proc(restOfLines, isLineEmpty);
found;
i, found = slice.linear_search_proc(restOfLines, isLineEmpty) {
append(&mapsStr, restOfLines[:i])
restOfLines = restOfLines[i+1:]
}
append(&mapsStr, restOfLines[:])
return slice.mapper(mapsStr[1:], parse_mapper)
}
apply_mapper :: proc(mapper: Mapper, num: int) -> int {
for r in mapper.ranges {
if num >= r.src && num - r.src < r.range do return num - r.src + r.dest
}
return num
}
p1 :: proc(input: []string) {
maps := parse_mappers(input)
defer {
for m in maps do delete(m.ranges)
delete(maps)
}
restSeeds := input[0][len("seeds: "):]
min := 0x7fffffff
for len(restSeeds) > 0 {
seedLen := -1
seed, seedOk := strconv.parse_int(restSeeds, 10, &seedLen)
restSeeds = strings.trim_left_space(restSeeds[seedLen:])
fmt.print(seed)
for m in maps {
seed = apply_mapper(m, seed)
fmt.print(" ->", seed)
}
fmt.println()
if seed < min do min = seed
}
fmt.println(min)
}
apply_mapper_reverse :: proc(mapper: Mapper, num: int) -> int {
for r in mapper.ranges {
if num >= r.dest && num - r.dest < r.range do return num - r.dest + r.src
}
return num
}
p2 :: proc(input: []string) {
SeedRange :: struct {
start: int,
len: int,
}
seeds := make([dynamic]SeedRange)
restSeeds := input[0][len("seeds: "):]
for len(restSeeds) > 0 {
seedLen := -1
seedS, seedSOk := strconv.parse_int(restSeeds, 10, &seedLen)
restSeeds = strings.trim_left_space(restSeeds[seedLen:])
seedL, seedLOk := strconv.parse_int(restSeeds, 10, &seedLen)
restSeeds = strings.trim_left_space(restSeeds[seedLen:])
append(&seeds, SeedRange{seedS, seedL})
}
maps := parse_mappers(input)
defer {
for m in maps do delete(m.ranges)
delete(maps)
}
for i := 0; true; i += 1 {
rseed := i
#reverse for m in maps {
rseed = apply_mapper_reverse(m, rseed)
}
found := false
for sr in seeds {
if rseed >= sr.start && rseed < sr.start + sr.len {
found = true
break
}
}
if found {
fmt.println(i)
break
}
}
}
Finally. :cries:
Part 1 was fine, I was figuring I might be able to practice classes.
Part 2 told me that nope, memory management required for you. In the end instead of calculating seeds, I resolved the whole thing down to a single mapping of seeds to locations. Then I could just sort by location ranges and try to see if they were a seed. Code is full of old parts from failed solutions but Iβve had enough of day 5, so I no longer care to clean it up.