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
Haskell
A nice easy one today: didn’t even have to hit this with the optimization hammer.
import Data.Char
import Data.List
import Data.Map (Map)
import Data.Map qualified as Map
readInput :: String -> Map (Int, Int) Int
readInput s =
Map.fromList
[ ((i, j), digitToInt c)
| (i, l) <- zip [0 ..] (lines s),
(j, c) <- zip [0 ..] l
]
findTrails :: Map (Int, Int) Int -> [[[(Int, Int)]]]
findTrails input =
Map.elems . Map.map (filter ((== 10) . length)) $
Map.restrictKeys accessible starts
where
starts = Map.keysSet . Map.filter (== 0) $ input
accessible = Map.mapWithKey getAccessible input
getAccessible (i, j) h
| h == 9 = [[(i, j)]]
| otherwise =
[ (i, j) : path
| (di, dj) <- [(-1, 0), (0, 1), (1, 0), (0, -1)],
let p = (i + di, j + dj),
input Map.!? p == Just (succ h),
path <- accessible Map.! p
]
main = do
trails <- findTrails . readInput <$> readFile "input10"
mapM_
(print . sum . (`map` trails))
[length . nub . map last, length]
Haskell
Cool task, nothing to optimize
import Control.Arrow
import Data.Array.Unboxed (UArray)
import Data.Set (Set)
import qualified Data.Char as Char
import qualified Data.List as List
import qualified Data.Set as Set
import qualified Data.Array.Unboxed as UArray
parse :: String -> UArray (Int, Int) Int
parse s = UArray.listArray ((1, 1), (n, m)) . map Char.digitToInt . filter (/= '\n') $ s
where
n = takeWhile (/= '\n') >>> length $ s
m = filter (== '\n') >>> length >>> pred $ s
reachableNeighbors :: (Int, Int) -> UArray (Int, Int) Int -> [(Int, Int)]
reachableNeighbors p@(py, px) a = List.filter (UArray.inRange (UArray.bounds a))
>>> List.filter ((a UArray.!) >>> pred >>> (== (a UArray.! p)))
$ [(py-1, px), (py+1, px), (py, px-1), (py, px+1)]
distinctTrails :: (Int, Int) -> UArray (Int, Int) Int -> Int
distinctTrails p a
| a UArray.! p == 9 = 1
| otherwise = flip reachableNeighbors a
>>> List.map (flip distinctTrails a)
>>> sum
$ p
reachableNines :: (Int, Int) -> UArray (Int, Int) Int -> Set (Int, Int)
reachableNines p a
| a UArray.! p == 9 = Set.singleton p
| otherwise = flip reachableNeighbors a
>>> List.map (flip reachableNines a)
>>> Set.unions
$ p
findZeros = UArray.assocs
>>> filter (snd >>> (== 0))
>>> map fst
part1 a = findZeros
>>> map (flip reachableNines a)
>>> map Set.size
>>> sum
$ a
part2 a = findZeros
>>> map (flip distinctTrails a)
>>> sum
$ a
main = getContents
>>= print
. (part1 &&& part2)
. parse
Nim
As many others today, I’ve solved part 2 first and then fixed a ‘bug’ to solve part 1. =)
type Vec2 = tuple[x,y:int]
const Adjacent = [(x:1,y:0),(-1,0),(0,1),(0,-1)]
proc path(start: Vec2, grid: seq[string]): tuple[ends, trails: int] =
var queue = @[@[start]]
var endNodes: HashSet[Vec2]
while queue.len > 0:
let path = queue.pop()
let head = path[^1]
let c = grid[head.y][head.x]
if c == '9':
inc result.trails
endNodes.incl head
continue
for d in Adjacent:
let nd = (x:head.x + d.x, y:head.y + d.y)
if nd.x < 0 or nd.y < 0 or nd.x > grid[0].high or nd.y > grid.high:
continue
if grid[nd.y][nd.x].ord - c.ord != 1: continue
queue.add path & nd
result.ends = endNodes.len
proc solve(input: string): AOCSolution[int, int] =
let grid = input.splitLines()
var trailstarts: seq[Vec2]
for y, line in grid:
for x, c in line:
if c == '0':
trailstarts.add (x,y)
for start in trailstarts:
let (ends, trails) = start.path(grid)
result.part1 += ends
result.part2 += trails
Nice to have a really simple one for a change, both my day 1 and 2 solutions worked on their very first attempts.
I rewrote the code to combine the two though, since the implementations were almost identical for both solutions, and also to replace the recursion with a search list instead.
C#
int[] heights = new int[0];
(int, int) size = (0, 0);
public void Input(IEnumerable<string> lines)
{
size = (lines.First().Length, lines.Count());
heights = string.Concat(lines).Select(c => int.Parse(c.ToString())).ToArray();
}
int trails = 0, trailheads = 0;
public void PreCalc()
{
for (int y = 0; y < size.Item2; ++y)
for (int x = 0; x < size.Item1; ++x)
if (heights[y * size.Item1 + x] == 0)
{
var unique = new HashSet<(int, int)>();
trails += CountTrails((x, y), unique);
trailheads += unique.Count;
}
}
public void Part1()
{
Console.WriteLine($"Trailheads: {trailheads}");
}
public void Part2()
{
Console.WriteLine($"Trails: {trails}");
}
int CountTrails((int, int) from, HashSet<(int,int)> unique)
{
int found = 0;
List<(int,int)> toSearch = new List<(int, int)>();
toSearch.Add(from);
while (toSearch.Any())
{
var cur = toSearch.First();
toSearch.RemoveAt(0);
int height = heights[cur.Item2 * size.Item1 + cur.Item1];
for (int y = -1; y <= 1; ++y)
for (int x = -1; x <= 1; ++x)
{
if ((y != 0 && x != 0) || (y == 0 && x == 0))
continue;
var newAt = (cur.Item1 + x, cur.Item2 + y);
if (newAt.Item1 < 0 || newAt.Item1 >= size.Item1 || newAt.Item2 < 0 || newAt.Item2 >= size.Item2)
continue;
int newHeight = heights[newAt.Item2 * size.Item1 + newAt.Item1];
if (newHeight - height != 1)
continue;
if (newHeight == 9)
{
unique.Add(newAt);
found++;
continue;
}
toSearch.Add(newAt);
}
}
return found;
}
Rust
Definitely a nice and easy one, I accidentally solved part 2 first, because I skimmed the challenge and missed the unique part.
#[cfg(test)]
mod tests {
const DIR_ORDER: [(i8, i8); 4] = [(-1, 0), (0, 1), (1, 0), (0, -1)];
fn walk_trail(board: &Vec<Vec<i8>>, level: i8, i: i8, j: i8) -> Vec<(i8, i8)> {
let mut paths = vec![];
if i < 0 || j < 0 {
return paths;
}
let actual_level = match board.get(i as usize) {
None => return paths,
Some(line) => match line.get(j as usize) {
None => return paths,
Some(c) => c,
},
};
if *actual_level != level {
return paths;
}
if *actual_level == 9 {
return vec![(i, j)];
}
for dir in DIR_ORDER.iter() {
paths.extend(walk_trail(board, level + 1, i + dir.0, j + dir.1));
}
paths
}
fn count_unique(p0: &Vec<(i8, i8)>) -> u32 {
let mut dedup = vec![];
for p in p0.iter() {
if !dedup.contains(p) {
dedup.push(*p);
}
}
dedup.len() as u32
}
#[test]
fn day10_part1_test() {
let input = std::fs::read_to_string("src/input/day_10.txt").unwrap();
let board = input
.trim()
.split('\n')
.map(|line| {
line.chars()
.map(|c| {
if c == '.' {
-1
} else {
c.to_digit(10).unwrap() as i8
}
})
.collect::<Vec<i8>>()
})
.collect::<Vec<Vec<i8>>>();
let mut total = 0;
for (i, row) in board.iter().enumerate() {
for (j, pos) in row.iter().enumerate() {
if *pos == 0 {
let all_trails = walk_trail(&board, 0, i as i8, j as i8);
total += count_unique(&all_trails);
}
}
}
println!("{}", total);
}
#[test]
fn day10_part2_test() {
let input = std::fs::read_to_string("src/input/day_10.txt").unwrap();
let board = input
.trim()
.split('\n')
.map(|line| {
line.chars()
.map(|c| {
if c == '.' {
-1
} else {
c.to_digit(10).unwrap() as i8
}
})
.collect::<Vec<i8>>()
})
.collect::<Vec<Vec<i8>>>();
let mut total = 0;
for (i, row) in board.iter().enumerate() {
for (j, pos) in row.iter().enumerate() {
if *pos == 0 {
total += walk_trail(&board, 0, i as i8, j as i8).len();
}
}
}
println!("{}", total);
}
}