Day 10: Hoof It
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)
- You can send code in code blocks by using three backticks, the code, and then three backticks or use something such as https://topaz.github.io/paste/ if you prefer sending it through a URL
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
Uiua
After finally deciding to put aside Day 9 Part 2 for now, this was really easy actually. The longest was figuring out how many extra dimensions I had to give some arrays and where to remove those again (and how). Then part 2 came along and all I had to do was remove a single character (not removing duplicates when landing on the same field by going different ways from the same starting point). Basically, everything in the parentheses of the Trails! macro was my solution for part 1, just that the ^0 was ◴ (deduplicate). Once that was removed, the solution for part 2 was there as well.
Run with example input here
Note: in order to use the code here for the actual input, you have to replace =₈ with =₅₀ because I was too lazy to make it work with variable array sizes this time.
$ 89010123
$ 78121874
$ 87430965
$ 96549874
$ 45678903
$ 32019012
$ 01329801
$ 10456732
.
Adj ← ¤[0_¯1 0_1 ¯1_0 1_0]
Trails! ← (
⊚=0.
⊙¤
≡(□¤)
1
⍥(⊙(≡(□^0/⊂≡(+¤)⊙¤°□)⊙Adj
≡(□▽¬≡/++⊃=₋₁=₈.°□))
+1⟜⊸⍚(▽=⊙(:⟜⊡))
)9
⊙◌◌
⧻/◇⊂
)
PartOne ← (
# &rs ∞ &fo "input-10.txt"
⊜∵⋕≠@\n.
Trails!◴
)
PartTwo ← (
# &rs ∞ &fo "input-10.txt"
⊜∵⋕≠@\n.
Trails!∘
)
&p "Day 10:"
&pf "Part 1: "
&p PartOne
&pf "Part 2: "
&p PartTwo
Kotlin
- Clean ❌
- Fast ❌
- Worked first try ✅
Code:
fun main() {
/**
* The idea is simple: Just simulate the pathing and sum all the end points
*/
fun part1(input: List<String>): Int {
val topologicalMap = Day10Map(input)
val startingPoints = topologicalMap.asIterable().indicesWhere { it == 0 }
val directions = Orientation.entries.map { it.asVector() }
return startingPoints.sumOf { startingPoint ->
var wayPoints = setOf(VecNReal(startingPoint))
val endPoints = mutableSetOf<VecNReal>()
while (wayPoints.isNotEmpty()) {
wayPoints = wayPoints.flatMap { wayPoint ->
directions.map { direction ->
val checkoutLocation = wayPoint + direction
checkoutLocation to runCatching { topologicalMap[checkoutLocation] }.getOrElse { -1 }
}.filter { nextLocation ->
val endPointHeight = topologicalMap[wayPoint]
if (nextLocation.second - 1 == endPointHeight && nextLocation.second == 9) false.also { endPoints.add(nextLocation.first) }
else if (nextLocation.second - 1 == endPointHeight) true
else false
}.map { it.first }
}.toSet()
}
endPoints.count()
}
}
/**
* A bit more complicated, but not by much.
* Main difference is, that node accumulates all the possible paths, thus adding all the possibilities of
* its parent node.
*/
fun part2(input: List<String>): Int {
val topologicalMap = Day10Map(input)
val startingPoints = topologicalMap.asIterable().indicesWhere { it == 0 }
val directions = Orientation.entries.map { it.asVector() }
return startingPoints.sumOf { startingPoint ->
var pathNodes = setOf<Node>(Node(VecNReal(startingPoint), topologicalMap[VecNReal(startingPoint)], 1))
val endNodes = mutableSetOf<Node>()
while (pathNodes.isNotEmpty()) {
pathNodes = pathNodes.flatMap { pathNode ->
directions.map { direction ->
val nextNodeLocation = pathNode.position + direction
val nextNodeHeight = runCatching { topologicalMap[nextNodeLocation] }.getOrElse { -1 }
Node(nextNodeLocation, nextNodeHeight, pathNode.weight)
}.filter { nextNode ->
nextNode.height == pathNode.height + 1
}
}.groupBy { it.position }.map { (position, nodesUnadjusted) ->
val adjustedWeight = nodesUnadjusted.sumOf { node -> node.weight }
Node(position, nodesUnadjusted.first().height, adjustedWeight)
}.filter { node ->
if (node.height == 9) false.also { endNodes.add(node) } else true
}.toSet()
}
endNodes.sumOf { endNode -> endNode.weight }
}
}
val testInput = readInput("Day10_test")
check(part1(testInput) == 36)
check(part2(testInput) == 81)
val input = readInput("Day10")
part1(input).println()
part2(input).println()
}
class Day10Map(input: List<String>): Grid2D<Int>(input.map { row -> row.map { "$it".toInt() } }) {
init { transpose() }
}
data class Node(val position: VecNReal, val height: Int, val weight: Int = 1)
Python
Sets of tuples and iteration for both first and second parts. A list of tuples used as a stack for the conversion of recursion to iteration. Dictionary of legal trail moves for traversal. Type hints for antibugging in VSCode. Couple of seconds runtime for each part.
https://github.com/jdnewmil/aocpy/blob/master/aocpy%2Faoc2024%2Fday10.py
are type hints only for debugging? I never really used them.
your code was interesting, where do you think your script was taking longer than usual to solve? Does VSCode help with this?
my python script only takes 1.5 milliseconds to solve both parts.
Not “debugging” … the value comes before I even try to run the code. The background syntax checker highlights when the types don’t agree into and out of each function call and I don’t get errors like trying to index into an integer.
As for time… I guessed… I did not measure. I have limited time to play with this and don’t optimize unless I find myself waiting excessively for an answer.
TypeScript
Maaaannnn. Today’s solution was really something. I actually got so confused initially that I unknowingly wrote the algorithm for part 2 before I even finished part 1! As an upside, however, I did expand my own Advent of Code standard library ;)
Solution
import { AdventOfCodeSolutionFunction } from "./solutions";
import { Grid } from "./utils/grids";
import { LinkedPoint } from "./utils/structures/linkedPoint";
import { makeGridFromMultilineString, SumArray } from "./utils/utils";
class TrailPoint extends LinkedPoint<number, TrailPoint> {
constructor(x: number, y: number, item: number, grid: Grid<TrailPoint>) {
super(x, y, item, grid);
}
lookAroundValid(): Array<TrailPoint> {
return this.lookAround().filter(v => v.item == this.item + 1);
}
findAllValidPeaks(): Array<TrailPoint> {
if (this.item == 9)
return [this];
// filter for distinct references (this theoretically saves time)
return [...(new Set(this.lookAroundValid().flatMap(v => v.findAllValidPeaks())))];
}
findAllValidPeaksWithReps(): Array<TrailPoint> {
if (this.item == 9)
return [this];
// don't filter
return this.lookAroundValid().flatMap(v => v.findAllValidPeaksWithReps());
}
}
export const solution_10: AdventOfCodeSolutionFunction = (input) => {
const map: Grid<TrailPoint> =
makeGridFromMultilineString(input)
.map((row) => row.map((item) => item != "." ? Number(item) : -1))
.map((row, y) => row.map((item, x) => new TrailPoint(x, y, item, undefined!)));
map.flat().forEach((v) => v.grid = map); // promise is a promise
const startNodes: Array<TrailPoint> = map.flat().filter(v => v.item == 0);
const part_1 = SumArray(startNodes.map(v => v.findAllValidPeaks().length));
const part_2 = SumArray(startNodes.map(v => v.findAllValidPeaksWithReps().length));
return {
part_1, // 557
part_2, // 1062
}
}
