2022 cleanup

2022/01_calories.py

@@ -2,16 +2,7 @@
 import sys
 from heapq import nlargest
 
-def calories_per_elf(lines):
-    cal = 0
-    for line in lines:
-        if line == '\n':
-            yield cal
-            cal = 0
-        else:
-            cal += int(line)
-    yield cal
-
-top3 = nlargest(3, calories_per_elf(sys.stdin))
+top3 = nlargest(3, (sum(map(int, group.split()))
+                    for group in sys.stdin.read().split('\n\n')))
 print(top3[0])
 print(sum(top3))

2022/05_stacks.py

@@ -1,33 +1,18 @@
 #!/usr/bin/env python3
 import sys
+from itertools import islice, takewhile
 
 def parse(f):
-    stacks = [[] for i in range(9)]
-    moves = []
-
-    for line in f:
-        if line.startswith(' 1 '):
-            break
-        for i, crate in enumerate(line[1::4]):
-            if crate != ' ':
-                stacks[i].append(ord(crate))
-    for stack in stacks:
-        stack.reverse()
-
-    next(f)
-    for line in f:
-        num, src, dst = map(int, line.split()[1::2])
-        moves.append((num, src - 1, dst - 1))
-
-    return stacks, moves
+    rows = (l[1::4] for l in takewhile(lambda l: not l.startswith(' 1'), f))
+    yield [[ord(c) for c in reversed(col) if c != ' '] for col in zip(*rows)]
+    yield [(int(num), int(src) - 1, int(dst) - 1)
+           for (_, num, _, src, _, dst) in map(str.split, islice(f, 1, None))]
 
 def move(stacks, moves, multipop):
     for num, src, dst in moves:
         popped = stacks[src][-num:]
         del stacks[src][-num:]
-        if not multipop:
-            popped.reverse()
-        stacks[dst].extend(popped)
+        stacks[dst].extend(popped if multipop else reversed(popped))
     return ''.join(chr(stack[-1]) for stack in stacks)
 
 stacks, moves = parse(sys.stdin)

2022/08_trees.py

@@ -1,47 +1,29 @@
 #!/usr/bin/env python3
 import sys
 
-def parse(f):
-    first = next(f).rstrip()
-    grid = list(map(int, first))
-    for line in f:
-        grid.extend(map(int, line.rstrip()))
-    return grid, len(first)
-
-def visible(grid, size):
-    vis = [False] * len(grid)
-
-    def walk(start, step):
-        prev = -1
-        for i in range(start, start + step * size, step):
-            tree = grid[i]
-            if tree > prev:
-                vis[i] = True
-                prev = tree
-
-    for i in range(size):
-        walk(i, size)
-        walk(len(grid) - i - 1, -size)
-        walk(i * size, 1)
-        walk((i + 1) * size - 1, -1)
-
-    return sum(vis)
-
-def score(grid, size, i):
-    def walk(step, stop):
+def spread(grid, w, i):
+    yield range(i + 1, i - i % w + w)
+    yield range(i - 1, i - i % w - 1, -1)
+    yield range(i + w, len(grid), w)
+    yield range(i - w, -1, -w)
+
+def visible(grid, w):
+    return sum(any(all(grid[j] < tree for j in d) for d in spread(grid, w, i))
+               for i, tree in enumerate(grid))
+
+def score(grid, w, i):
+    def walk(direction):
         vis = 0
-        for j in range(i + step, stop, step):
+        for j in direction:
             vis += 1
             if grid[j] >= grid[i]:
                 break
-            j += step
         return vis
-
-    return walk(1, i + size - i % size) \
-         * walk(-1, i - i % size - 1) \
-         * walk(size, len(grid)) \
-         * walk(-size, -1)
-
-grid, size = parse(sys.stdin)
-print(visible(grid, size))
-print(max(score(grid, size, i) for i in range(len(grid))))
+    right, left, down, up = map(iter, spread(grid, w, i))
+    return walk(right) * walk(left) * walk(down) * walk(up)
+
+inp = sys.stdin.read()
+w = inp.index('\n')
+grid = [int(n) for n in inp if n != '\n']
+print(visible(grid, w))
+print(max(score(grid, w, i) for i, tree in enumerate(grid)))

2022/11_monkeys.py

@@ -2,6 +2,7 @@
 import sys
 from operator import add, mul, pow
 from functools import reduce
+from heapq import nlargest
 
 def parse(f):
     for line in f:
@@ -24,7 +25,7 @@ def business(monkeys, rounds, divisor):
                 queues[false if worry % div else true].append(worry)
             inspects[i] += len(items)
             items.clear()
-    return mul(*sorted(inspects)[-2:])
+    return mul(*nlargest(2, inspects))
 
 monkeys = list(parse(sys.stdin))
 print(business(monkeys, 20, 3))