2024 d1: Add walkthrough, clean and original solution

Author: mebeim

2024/README.md

@@ -1,8 +1,94 @@
 Advent of Code 2024 walkthrough
 ===============================
 
-*Coming soon!*
+Table of Contents
+-----------------
 
+- [Day 1 - Historian Hysteria][d01]
+<!--
+- [Day 2 - xxx][d02]
+- [Day 3 - xxx][d03]
+- [Day 4 - xxx][d04]
+- [Day 5 - xxx][d05]
+- [Day 6 - xxx][d06]
+- [Day 7 - xxx][d07]
+- [Day 8 - xxx][d08]
+- [Day 9 - xxx][d09]
+- [Day 10 - xxx][d10]
+- [Day 11 - xxx][d11]
+- [Day 12 - xxx][d12]
+- [Day 13 - xxx][d13]
+- [Day 14 - xxx][d14]
+- [Day 15 - xxx][d15]
+- [Day 16 - xxx][d16]
+- [Day 17 - xxx][d17]
+- [Day 18 - xxx][d18]
+- [Day 19 - xxx][d19]
+- [Day 20 - xxx][d20]
+- [Day 21 - xxx][d20]
+- [Day 22 - xxx][d20]
+- [Day 23 - xxx][d20]
+- [Day 24 - xxx][d20]
+- [Day 25 - xxx][d20]
+-->
+
+
+
+Day 1 - Historian Hysteria
+--------------------------
+
+[Problem statement][d01-problem] — [Complete solution][d01-solution] — [Back to top][top]
+
+### Part 1
+
+All right, let's get this year started! We have two lists of integers and need
+to find differences between their elements, pairing them up in increasing order.
+First, read each input line, split it and convert to `int` using
+[`map()`][py-builtin-map].
+
+```python
+fin = open(...)
+
+total = 0
+left = []
+right = []
+
+for line in fin:
+    l, r = map(int, line.split())
+    left.append(l)
+    right.append(r)
+```
+
+Now all we need to do is [`.sort()`][py-list-sort] them, then then iterate over
+the sorted pairs obtained via [`zip()`][py-builtin-zip] summing up their
+differences. For that, [`sum()`][py-builtin-sum] plus a [generator
+expression][py-gen-expr] will do the trick.
+
+
+```python
+left.sort()
+right.sort()
+
+total = sum(abs(l - r) for l, r in zip(left, right))
+print('Part 1:', total)
+```
+
+### Part 2
+
+Now instead of summing differences we need to sum products. Each number on the
+left list needs to be multiplied by the number of times it appears on the right
+list. We can again use a generator expression or convert everything into a `for`
+loop to do both parts at once. The number of occurrences can be obtained via
+[`.count()`][py-list-count].
+
+```python
+for l, r in zip(left, right):
+    total1 += abs(l - r)
+    total2 += l * right.count(l)
+
+print('Part 1:', total1)
+print('Part 2:', total2)
+```
 
 ---
 
@@ -86,3 +172,12 @@ Advent of Code 2024 walkthrough
 [d22-solution]: solutions/day22.py
 [d24-solution]: solutions/day24.py
 [d25-solution]: solutions/day25.py
+
+
+[py-gen-expr]: https://docs.python.org/3/reference/expressions.html#generator-expressions
+
+[py-builtin-map]: https://docs.python.org/3/library/functions.html#map
+[py-builtin-sum]: https://docs.python.org/3/library/functions.html#sum
+[py-builtin-zip]: https://docs.python.org/3/library/functions.html#zip
+[py-list-count]:  https://docs.python.org/3/tutorial/datastructures.html#more-on-lists
+[py-list-sort]:   https://docs.python.org/3/tutorial/datastructures.html#more-on-lists

2024/original_solutions/day01.py

@@ -2,60 +2,25 @@
 
 from utils.all import *
 
-# advent.setup(2024, )
-DEBUG = 'debug' in map(str.lower, sys.argv)
-fin = advent.get_input() if not DEBUG else io.StringIO('''\
+advent.setup(2024, 1)
 
-''')
-eprint(*fin, sep='', end='----- end of input -----\n\n'); fin.seek(0, 0)
+fin = advent.get_input()
+lines = read_lines(fin)
 
-try: data = fin.read(); fin.seek(0, 0)
-except: pass
-try: ints = extract_ints(data)
-except: pass
-try: intmat = read_int_matrix(fin); fin.seek(0, 0)
-except: pass
-try: lines = read_lines(fin); fin.seek(0, 0)
-except: pass
-try: grid = read_char_matrix(fin); fin.seek(0, 0)
-except: pass
-try: intgrid = read_digit_matrix(fin); fin.seek(0, 0)
-except: pass
-try: g = graph_from_grid(grid, find='QWERTYUIOPASDFGHJKLZXCVBNM', avoid='#', coords=False, get_neighbors=neighbors4)
-except: pass
-timer_start()
+l = []
+r = []
 
-ans1 = ans2 = 0
-# g = defaultdict(list)
+for line in lines:
+	a, b = map(int, line.split())
+	l.append(a)
+	r.append(b)
 
-# for r, row in enumerate(grid):
-# 	for c, char in enumerate(row):
-# 		pass
+l.sort()
+r.sort()
 
-# for r, row in enumerate(intgrid):
-# 	for c, num in enumerate(row):
-# 		pass
+for a, b in zip(l, r):
+	ans1 += abs(a - b)
+	ans2 += a * r.count(a)
 
-# for line in lines:
-
-
-
-
-
-
-advent.print_and_submit(1, ans1)
-# advent.print_answer(1, ans1)
-
-
-
-
-
-
-advent.print_and_submit(2, ans2)
-# advent.print_answer(2, ans2)
-
-
-# - Can you memoize some state for which the solution will always be the same?
-# - Can you batch operations together instead of doing them singularly?
-# - Too many points? Coordinate compression? Shoelace formula?
-# - Can you go blind with Z3 (or GCC+IDA+Z3) instead of reverse engineering?
+advent.print_answer(1, ans1)
+advent.print_answer(2, ans2)

2024/solutions/day01.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+
+import sys
+
+# Open the first argument as input or use stdin if no arguments were given
+fin = open(sys.argv[1]) if len(sys.argv) > 1 else sys.stdin
+
+total1 = total2 = 0
+
+left = []
+right = []
+
+for line in fin:
+	l, r = map(int, line.split())
+	left.append(l)
+	right.append(r)
+
+left.sort()
+right.sort()
+
+for l, r in zip(left, right):
+	total1 += abs(l - r)
+	total2 += l * right.count(l)
+
+print('Part 1:', total1)
+print('Part 2:', total2)