test: add unit test for part one

.gitignore

@@ -1 +1,2 @@
 bin/aoc
+*.test

Makefile

@@ -4,10 +4,58 @@ BIN = bin/aoc
 .PHONY: build test clean
 
 build:
-	$(GO) build -o $(BIN) ./cmd/aoc
+	@mkdir -p $(dir $(BIN))
+	@$(GO) build -o $(BIN) ./cmd/aoc
 
 test:
-	$(GO) test ./...
+	@$(GO) test ./internal/...
 
 clean:
-	rm -f $(BIN)
+	@rm -f $(BIN)
+
+%:
+	@DAY_ARG=$@; \
+	if echo $$DAY_ARG | grep -qE '^[0-9]{4}D[0-9]+$$'; then \
+		YEAR=$$(echo $$DAY_ARG | sed 's/D.*//'); \
+		DAY_NUM=$$(echo $$DAY_ARG | sed 's/.*D//'); \
+		DAY_NAME=$$(case $$DAY_NUM in \
+			1) echo "One" ;; \
+			2) echo "Two" ;; \
+			3) echo "Three" ;; \
+			4) echo "Four" ;; \
+			5) echo "Five" ;; \
+			6) echo "Six" ;; \
+			7) echo "Seven" ;; \
+			8) echo "Eight" ;; \
+			9) echo "Nine" ;; \
+			10) echo "Ten" ;; \
+			11) echo "Eleven" ;; \
+			12) echo "Twelve" ;; \
+			13) echo "Thirteen" ;; \
+			14) echo "Fourteen" ;; \
+			15) echo "Fifteen" ;; \
+			16) echo "Sixteen" ;; \
+			17) echo "Seventeen" ;; \
+			18) echo "Eighteen" ;; \
+			19) echo "Nineteen" ;; \
+			20) echo "Twenty" ;; \
+			21) echo "TwentyOne" ;; \
+			22) echo "TwentyTwo" ;; \
+			23) echo "TwentyThree" ;; \
+			24) echo "TwentyFour" ;; \
+			25) echo "TwentyFive" ;; \
+			*) echo "Unknown" ;; \
+		esac); \
+		mkdir -p internal/$$YEAR/Day$$DAY_NAME; \
+		mkdir -p internal/data/$$YEAR/Day$$DAY_NAME; \
+		touch internal/$$YEAR/Day$$DAY_NAME/code.go; \
+		touch internal/$$YEAR/Day$$DAY_NAME/code_test.go; \
+		if [ -n "$$ADVENTOFCODE_SESSION" ]; then \
+			curl -s -H "Cookie: session=$$ADVENTOFCODE_SESSION" \
+				https://adventofcode.com/$$YEAR/day/$$DAY_NUM/input \
+				| perl -pe 'chomp if eof' > internal/data/$$YEAR/Day$$DAY_NAME/input.txt; \
+		else \
+			touch internal/data/$$YEAR/Day$$DAY_NAME/input.txt; \
+		fi; \
+		echo "$$DAY_ARG ready to be solved."; \
+	fi

README.md

@@ -8,41 +8,69 @@ It uses pure Go, no external dependencies.
 
 Also, it's a fresh start from 2025. I do some exercises from other years along the way, which explains why no year is complete and why everything is in "recent" Go.
 
+Ultimately, my goal is to complete all the years of Advent of Code here.
+
 ## Requirements
 
 - Go 1.25
-- Puzzle input
+- Puzzle input (or your session cookie to have it downloaded automatically)
 
 ## Repository Structure
 
 ```
 ├── cmd/
 │   └── aoc/
-│       └── main.go                # CLI entry point that runs solutions
+│       └── main.go               # CLI entry point for running puzzles
 └── internal/
     ├── 2020/
+    │   ├── register.go           # Aggregates import for main.go
     │   ├── DayOne/
-    │   │   ├── code.go            # Go solution for Day 1 (2020)
-    │   │   └── code_test.go       # Unit tests for Day 1
-    │   └── ...
+    │   │   ├── code.go           # Day 1 solution for 2020
+    │   │   └── code_test.go      # Unit tests for Day 1 solution
+    │   └── ...                   # Other days for 2020
     ├── 2021/
-    │   └── ...                    # Additional years and days
+    │   └── ...                   # 2021 days code and tests
     ├── registry/
-    │   └── registry.go            # Central registry for day runners
+    │   └── registry.go           # Central map/registry for finding and running days
     └── data/
         ├── 2020/
         │   ├── DayOne/
-        │   │   └── input.txt      # Puzzle input for Day 1 (2020)
-        │   └── ...
-        └── ...
+        │   │   └── input.txt     # Puzzle input for Day 1 (2020)
+        │   └── ...               # Inputs for other days
+        └── ...                   # Inputs for other years
 ```
 
 Each day's solution is organized into its own folder, named according to the day number (e.g., `DayOne`, `DayTwo`). Inside each folder, you'll find a `code.go` file with the Go implementation of the solution and a `code_test.go` file containing corresponding tests. The input data for each puzzle is located in the `internal/data` directory, mirroring the code structure for easy access.
 
-To connect each solution to the CLI, the repository uses a central registry located in `internal/registry/registry.go`. This registry is essentially a map linking a day key (combining year and day number) to assign a "day runner" which is a struct that specifies the `ParseInput`, `PartOne` and `PartTwo` functions of the day's problem.
+Each year has its own `register.go` file to aggregate imports. To connect each solution to the CLI, the repository uses a central registry located in `internal/registry/registry.go`. This registry is essentially a map linking a day key (combining year and day number) to assign a "day runner" which is a struct that specifies the `ParseInput`, `PartOne` and `PartTwo` functions of the day's problem.
 
 When running a solution, the CLI (`cmd/aoc/main.go`) looks up the appropriate runner from the registry based on your command-line input, uses the parsing function to load the input data, and then runs the desired part (or both parts) using the registered solution functions.
 
+### Starting a new day
+
+```bash
+make 2020D1
+```
+
+If the `ADVENTOFCODE_SESSION` environment variable is set with your Advent of Code session cookie, the input will be downloaded from the AOC website right into the corresponding `internal/data` directory, else it will create an empty `input.txt` file.
+
+Then, it will create the following files:
+
+```bash
+internal/2020/DayOne/code.go
+internal/2020/DayOne/code_test.go
+```
+
+### Handling string answers
+
+Occasionally, a puzzle requires a string as the answer. However, my solution framework expects PartOne/PartTwo functions to return integers.
+
+To work around this, I print the string result (see [2018D2P2](https://git.kharec.info/Kharec/advent-of-code/tree/main/internal/2018/DayTwo/code.go)) and return a dummy integer to satisfy the type requirements.
+
+Meanwhile, the corresponding [test](https://git.kharec.info/Kharec/advent-of-code/tree/main/internal/2018/DayTwo/code_test.go) captures the output and verifies that the correct string is produced.
+
+It's not the most elegant solution, but since only a handful of days across all Advent of Code years require a string result, this compromise keeps the rest of the code simple.
+
 ## Usage
 
 Build the CLI tool:

cmd/aoc/main.go

@@ -1,21 +1,22 @@
 package main
 
 import (
-	"advent-of-code/internal/registry"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
 	"regexp"
 
-	_ "advent-of-code/internal/2020/DayFour"
-	_ "advent-of-code/internal/2020/DayOne"
-	_ "advent-of-code/internal/2020/DaySix"
-	_ "advent-of-code/internal/2020/DayThree"
-	_ "advent-of-code/internal/2020/DayTwo"
-	_ "advent-of-code/internal/2021/DayOne"
-	_ "advent-of-code/internal/2021/DayThree"
-	_ "advent-of-code/internal/2021/DayTwo"
+	"advent-of-code/internal/registry"
+
+	_ "advent-of-code/internal/2015"
+	_ "advent-of-code/internal/2016"
+	_ "advent-of-code/internal/2017"
+	_ "advent-of-code/internal/2018"
+	_ "advent-of-code/internal/2020"
+	_ "advent-of-code/internal/2021"
+	_ "advent-of-code/internal/2022"
+	_ "advent-of-code/internal/2025"
 )
 
 func capitalize(day string) string {

internal/2015/DayEight/code.go

@@ -0,0 +1,61 @@
+package dayeight
+
+import (
+	"os"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D8", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	result := 0
+	for _, line := range data {
+		codeLength := len(line)
+		memoryLength := 0
+		for idx := 1; idx < len(line)-1; idx++ {
+			if line[idx] == '\\' && idx+1 < len(line)-1 {
+				switch line[idx+1] {
+				case '\\', '"':
+					memoryLength++
+					idx++
+				case 'x':
+					if idx+3 < len(line)-1 {
+						memoryLength++
+						idx += 3
+					}
+				}
+			} else {
+				memoryLength++
+			}
+		}
+		result += codeLength - memoryLength
+	}
+	return result
+}
+
+func PartTwo(data []string) int {
+	result := 0
+	for _, line := range data {
+		originalLength := len(line)
+		encodedLength := 2
+		for _, char := range line {
+			switch char {
+			case '\\', '"':
+				encodedLength += 2
+			default:
+				encodedLength++
+			}
+		}
+		result += encodedLength - originalLength
+	}
+	return result
+}

internal/2015/DayEight/code_test.go

@@ -0,0 +1,26 @@
+package dayeight
+
+import "testing"
+
+var testInput = []string{
+	`""`,
+	`"abc"`,
+	`"aaa\"aaa"`,
+	`"\x27"`,
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 12
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 19
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/DayEleven/code.go

@@ -0,0 +1,97 @@
+package dayeleven
+
+import (
+	"os"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D11", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func findNextValidPassword(data string) string {
+	bytes := []byte(data)
+
+	increment := func() {
+		for idx := len(bytes) - 1; idx >= 0; idx-- {
+			if bytes[idx] == 'z' {
+				bytes[idx] = 'a'
+			} else {
+				bytes[idx]++
+				if bytes[idx] == 'i' || bytes[idx] == 'o' || bytes[idx] == 'l' {
+					bytes[idx]++
+				}
+				for j := idx + 1; j < len(bytes); j++ {
+					bytes[j] = 'a'
+				}
+				return
+			}
+		}
+	}
+
+	increment()
+
+	for {
+		forbiddenPosition := -1
+		for idx := range bytes {
+			if bytes[idx] == 'i' || bytes[idx] == 'o' || bytes[idx] == 'l' {
+				forbiddenPosition = idx
+				break
+			}
+		}
+
+		if forbiddenPosition != -1 {
+			bytes[forbiddenPosition]++
+			if bytes[forbiddenPosition] == 'i' || bytes[forbiddenPosition] == 'o' || bytes[forbiddenPosition] == 'l' {
+				bytes[forbiddenPosition]++
+			}
+			for j := forbiddenPosition + 1; j < len(bytes); j++ {
+				bytes[j] = 'a'
+			}
+			continue
+		}
+
+		hasStraight := false
+		for idx := 0; idx < len(bytes)-2; idx++ {
+			if bytes[idx+1] == bytes[idx]+1 && bytes[idx+2] == bytes[idx]+2 {
+				hasStraight = true
+				break
+			}
+		}
+
+		pairChars := make(map[byte]bool)
+		for idx := 0; idx < len(bytes)-1; idx++ {
+			if bytes[idx] == bytes[idx+1] {
+				pairChars[bytes[idx]] = true
+				idx++
+			}
+		}
+
+		if hasStraight && len(pairChars) >= 2 {
+			break
+		}
+
+		increment()
+	}
+
+	return string(bytes)
+}
+
+func PartOne(data string) int {
+	result := findNextValidPassword(data)
+	println(result)
+	return 0
+}
+
+func PartTwo(data string) int {
+	firstPassword := findNextValidPassword(data)
+	secondPassword := findNextValidPassword(firstPassword)
+	println(secondPassword)
+	return 0
+}

internal/2015/DayFifteen/code.go

@@ -0,0 +1,141 @@
+package dayfifteen
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2015D15", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+type ingredient struct {
+	capacity   int
+	durability int
+	flavor     int
+	texture    int
+	calories   int
+}
+
+func parseIngredient(line string) ingredient {
+	parts := strings.Split(line, ": ")
+	props := strings.Split(parts[1], ", ")
+	var cap, dur, flav, tex, cal int
+
+	for _, prop := range props {
+		var name string
+		var value int
+		fmt.Sscanf(prop, "%s %d", &name, &value)
+		switch name {
+		case "capacity":
+			cap = value
+		case "durability":
+			dur = value
+		case "flavor":
+			flav = value
+		case "texture":
+			tex = value
+		case "calories":
+			cal = value
+		}
+	}
+
+	return ingredient{
+		capacity:   cap,
+		durability: dur,
+		flavor:     flav,
+		texture:    tex,
+		calories:   cal,
+	}
+}
+
+func calculateScore(ingredients []ingredient, amounts []int) int {
+	var capacity, durability, flavor, texture int
+	for idx, ing := range ingredients {
+		capacity += ing.capacity * amounts[idx]
+		durability += ing.durability * amounts[idx]
+		flavor += ing.flavor * amounts[idx]
+		texture += ing.texture * amounts[idx]
+	}
+	if capacity < 0 {
+		capacity = 0
+	}
+	if durability < 0 {
+		durability = 0
+	}
+	if flavor < 0 {
+		flavor = 0
+	}
+	if texture < 0 {
+		texture = 0
+	}
+	return capacity * durability * flavor * texture
+}
+
+func calculateCalories(ingredients []ingredient, amounts []int) int {
+	var calories int
+	for idx, ing := range ingredients {
+		calories += ing.calories * amounts[idx]
+	}
+	return calories
+}
+
+func PartOne(data []string) int {
+	var ingredients []ingredient
+	for _, line := range data {
+		ingredients = append(ingredients, parseIngredient(line))
+	}
+	amounts := make([]int, len(ingredients))
+	var findMaxScore func(remaining int, index int) int
+	findMaxScore = func(remaining int, index int) int {
+		if index == len(ingredients)-1 {
+			amounts[index] = remaining
+			return calculateScore(ingredients, amounts)
+		}
+		maxScore := 0
+		for idx := 0; idx <= remaining; idx++ {
+			amounts[index] = idx
+			score := findMaxScore(remaining-idx, index+1)
+			if score > maxScore {
+				maxScore = score
+			}
+		}
+		return maxScore
+	}
+	return findMaxScore(100, 0)
+}
+
+func PartTwo(data []string) int {
+	var ingredients []ingredient
+	for _, line := range data {
+		ingredients = append(ingredients, parseIngredient(line))
+	}
+	amounts := make([]int, len(ingredients))
+	var findMaxScoreWithCalories func(remaining int, index int) int
+	findMaxScoreWithCalories = func(remaining int, index int) int {
+		if index == len(ingredients)-1 {
+			amounts[index] = remaining
+			if calculateCalories(ingredients, amounts) == 500 {
+				return calculateScore(ingredients, amounts)
+			}
+			return 0
+		}
+		maxScore := 0
+		for idx := 0; idx <= remaining; idx++ {
+			amounts[index] = idx
+			score := findMaxScoreWithCalories(remaining-idx, index+1)
+			if score > maxScore {
+				maxScore = score
+			}
+		}
+		return maxScore
+	}
+	return findMaxScoreWithCalories(100, 0)
+}

internal/2015/DayFifteen/code_test.go

@@ -0,0 +1,24 @@
+package dayfifteen
+
+import "testing"
+
+var testInput = []string{
+	"Butterscotch: capacity -1, durability -2, flavor 6, texture 3, calories 8",
+	"Cinnamon: capacity 2, durability 3, flavor -2, texture -1, calories 3",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 62842880
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 57600000
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/DayFive/code.go

@@ -0,0 +1,77 @@
+package dayfive
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2015D5", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	count := 0
+	for _, line := range data {
+		vowelCount := strings.Count(line, "a") + strings.Count(line, "e") + strings.Count(line, "i") + strings.Count(line, "o") + strings.Count(line, "u")
+		if vowelCount < 3 {
+			continue
+		}
+
+		hasDoubleLetter := false
+		for i := 1; i < len(line); i++ {
+			if line[i] == line[i-1] {
+				hasDoubleLetter = true
+				break
+			}
+		}
+		if !hasDoubleLetter {
+			continue
+		}
+
+		if strings.Contains(line, "ab") || strings.Contains(line, "cd") || strings.Contains(line, "pq") || strings.Contains(line, "xy") {
+			continue
+		}
+
+		count++
+	}
+	return count
+}
+
+func PartTwo(data []string) int {
+	count := 0
+	for _, line := range data {
+		if len(line) < 4 {
+			continue
+		}
+
+		hasNonOverlappingPair := false
+		for i := 0; i < len(line)-1; i++ {
+			pair := line[i : i+2]
+			if strings.Contains(line[i+2:], pair) {
+				hasNonOverlappingPair = true
+				break
+			}
+		}
+		if !hasNonOverlappingPair {
+			continue
+		}
+
+		hasRepeatingLetterWithGap := false
+		for i := 0; i < len(line)-2; i++ {
+			if line[i] == line[i+2] {
+				hasRepeatingLetterWithGap = true
+				break
+			}
+		}
+		if hasRepeatingLetterWithGap {
+			count++
+		}
+	}
+	return count
+}

internal/2015/DayFive/code_test.go

@@ -0,0 +1,32 @@
+package dayfive
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	input := []string{
+		"ugknbfddgicrmopn",
+		"aaa",
+		"jchzalrnumimnmhp",
+		"haegwjzuvuyypxyu",
+		"dvszwmarrgswjxmb",
+	}
+	expected := 2
+	got := PartOne(input)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	input := []string{
+		"qjhvhtzxzqqjkmpb",
+		"xxyxx",
+		"uurcxstgmygtbstg",
+		"ieodomkazucvgmuy",
+	}
+	expected := 2
+	got := PartTwo(input)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/DayFour/code.go

@@ -0,0 +1,46 @@
+package dayfour
+
+import (
+	"advent-of-code/internal/registry"
+	"bytes"
+	"crypto/md5"
+	"os"
+	"strconv"
+)
+
+func init() {
+	registry.Register("2015D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []byte {
+	content, _ := os.ReadFile(filepath)
+	return bytes.TrimSpace(content)
+}
+
+func findHashWithZeroes(data []byte, zeroes int) int {
+	buffer := make([]byte, len(data), len(data)+10)
+	copy(buffer, data)
+	for idx := 1; ; idx++ {
+		buffer = buffer[:len(data)]
+		buffer = strconv.AppendInt(buffer, int64(idx), 10)
+		hash := md5.Sum(buffer)
+		switch zeroes {
+		case 5:
+			if hash[0] == 0 && hash[1] == 0 && hash[2]&0xF0 == 0 {
+				return idx
+			}
+		case 6:
+			if hash[0] == 0 && hash[1] == 0 && hash[2] == 0 {
+				return idx
+			}
+		}
+	}
+}
+
+func PartOne(data []byte) int {
+	return findHashWithZeroes(data, 5)
+}
+
+func PartTwo(data []byte) int {
+	return findHashWithZeroes(data, 6)
+}

internal/2015/DayFour/code_test.go

@@ -0,0 +1,45 @@
+package dayfour
+
+import (
+	"testing"
+)
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected int
+	}{
+		{"abcdef", []byte("abcdef"), 609043},
+		{"pqrstuv", []byte("pqrstuv"), 1048970},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []byte
+		expected int
+	}{
+		{"abcdef", []byte("abcdef"), 6742839},
+		{"pqrstuv", []byte("pqrstuv"), 5714438},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2015/DayFourteen/code.go

@@ -0,0 +1,108 @@
+package dayfourteen
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var reindeerPattern = regexp.MustCompile(`\w+ can fly (\d+) km/s for (\d+) seconds, but then must rest for (\d+) seconds\.`)
+
+const raceTime = 2503
+
+type Reindeer struct {
+	Speed    int
+	FlyTime  int
+	RestTime int
+	Points   int
+}
+
+func init() {
+	registry.Register("2015D14", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func parseReindeer(line string) Reindeer {
+	matches := reindeerPattern.FindStringSubmatch(line)
+	speed, _ := strconv.Atoi(matches[1])
+	flyTime, _ := strconv.Atoi(matches[2])
+	restTime, _ := strconv.Atoi(matches[3])
+	return Reindeer{Speed: speed, FlyTime: flyTime, RestTime: restTime}
+}
+
+func parseReindeers(data []string) []Reindeer {
+	reindeers := make([]Reindeer, 0, len(data))
+	for _, line := range data {
+		reindeers = append(reindeers, parseReindeer(line))
+	}
+	return reindeers
+}
+
+func (reindeer Reindeer) distanceAtTime(time int) int {
+	cycleTime := reindeer.FlyTime + reindeer.RestTime
+	fullCycles := time / cycleTime
+	distance := fullCycles * reindeer.Speed * reindeer.FlyTime
+	remainingTime := time % cycleTime
+	distance += reindeer.Speed * min(remainingTime, reindeer.FlyTime)
+	return distance
+}
+
+func calculateMaxDistance(data []string, time int) int {
+	reindeers := parseReindeers(data)
+	maxDistance := 0
+
+	for _, reindeer := range reindeers {
+		distance := reindeer.distanceAtTime(time)
+		if distance > maxDistance {
+			maxDistance = distance
+		}
+	}
+
+	return maxDistance
+}
+
+func calculateMaxPoints(data []string, time int) int {
+	reindeers := parseReindeers(data)
+
+	for second := 1; second <= time; second++ {
+		maxDistance := 0
+		distances := make([]int, len(reindeers))
+
+		for idx := range reindeers {
+			distance := reindeers[idx].distanceAtTime(second)
+			distances[idx] = distance
+			if distance > maxDistance {
+				maxDistance = distance
+			}
+		}
+
+		for idx := range reindeers {
+			if distances[idx] == maxDistance {
+				reindeers[idx].Points++
+			}
+		}
+	}
+
+	maxPoints := 0
+	for idx := range reindeers {
+		if reindeers[idx].Points > maxPoints {
+			maxPoints = reindeers[idx].Points
+		}
+	}
+
+	return maxPoints
+}
+
+func PartOne(data []string) int {
+	return calculateMaxDistance(data, raceTime)
+}
+
+func PartTwo(data []string) int {
+	return calculateMaxPoints(data, raceTime)
+}

internal/2015/DayFourteen/code_test.go

@@ -0,0 +1,24 @@
+package dayfourteen
+
+import "testing"
+
+var testInput = []string{
+	"Comet can fly 14 km/s for 10 seconds, but then must rest for 127 seconds.",
+	"Dancer can fly 16 km/s for 11 seconds, but then must rest for 162 seconds.",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 1120
+	got := calculateMaxDistance(testInput, 1000)
+	if got != expected {
+		t.Errorf("calculateMaxDistance(testInput, 1000) = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 689
+	got := calculateMaxPoints(testInput, 1000)
+	if got != expected {
+		t.Errorf("calculateMaxPoints(testInput, 1000) = %d, want %d", got, expected)
+	}
+}

internal/2015/DayNine/code.go

@@ -0,0 +1,106 @@
+package daynine
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D9", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func buildDistanceMap(data []string) map[string]map[string]int {
+	distances := make(map[string]map[string]int)
+
+	for _, line := range data {
+		parts := strings.Split(line, " = ")
+		distance, _ := strconv.Atoi(parts[1])
+		route := strings.Split(parts[0], " to ")
+		from, to := route[0], route[1]
+
+		if distances[from] == nil {
+			distances[from] = make(map[string]int)
+		}
+		if distances[to] == nil {
+			distances[to] = make(map[string]int)
+		}
+
+		distances[from][to] = distance
+		distances[to][from] = distance
+	}
+
+	return distances
+}
+
+func getCities(distances map[string]map[string]int) []string {
+	cities := make([]string, 0, len(distances))
+	for city := range distances {
+		cities = append(cities, city)
+	}
+	return cities
+}
+
+func generatePermutations(cities []string) [][]string {
+	if len(cities) == 0 {
+		return [][]string{{}}
+	}
+	var result [][]string
+	for idx, city := range cities {
+		remaining := make([]string, len(cities)-1)
+		copy(remaining[:idx], cities[:idx])
+		copy(remaining[idx:], cities[idx+1:])
+
+		for _, permutations := range generatePermutations(remaining) {
+			result = append(result, append([]string{city}, permutations...))
+		}
+	}
+	return result
+}
+
+func calculateRouteDistance(route []string, distances map[string]map[string]int) int {
+	total := 0
+	for idx := 0; idx < len(route)-1; idx++ {
+		total += distances[route[idx]][route[idx+1]]
+	}
+	return total
+}
+
+func PartOne(data []string) int {
+	distances := buildDistanceMap(data)
+	cities := getCities(distances)
+	permutations := generatePermutations(cities)
+
+	minimalDistance := int(^uint(0) >> 1)
+	for _, route := range permutations {
+		total := calculateRouteDistance(route, distances)
+		if total < minimalDistance {
+			minimalDistance = total
+		}
+	}
+
+	return minimalDistance
+}
+
+func PartTwo(data []string) int {
+	distances := buildDistanceMap(data)
+	cities := getCities(distances)
+	permutations := generatePermutations(cities)
+
+	maximalDistance := 0
+	for _, route := range permutations {
+		total := calculateRouteDistance(route, distances)
+		if total > maximalDistance {
+			maximalDistance = total
+		}
+	}
+
+	return maximalDistance
+}

internal/2015/DayNine/code_test.go

@@ -0,0 +1,25 @@
+package daynine
+
+import "testing"
+
+var testInput = []string{
+	"London to Dublin = 464",
+	"London to Belfast = 518",
+	"Dublin to Belfast = 141",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 605
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 982
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/DayOne/code.go

@@ -0,0 +1,44 @@
+package dayone
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+)
+
+func init() {
+	registry.Register("2015D1", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func PartOne(data string) int {
+	floor := 0
+	for _, char := range data {
+		switch char {
+		case '(':
+			floor++
+		case ')':
+			floor--
+		}
+	}
+	return floor
+}
+
+func PartTwo(data string) int {
+	floor := 0
+	for idx, char := range data {
+		switch char {
+		case '(':
+			floor++
+		case ')':
+			floor--
+		}
+		if floor == -1 {
+			return idx + 1
+		}
+	}
+	return 0
+}

internal/2015/DayOne/code_test.go

@@ -0,0 +1,50 @@
+package dayone
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"(())", "(())", 0},
+		{"()()", "()()", 0},
+		{"(((", "(((", 3},
+		{"(()(()(", "(()(()(", 3},
+		{"))(((((", "))(((((", 3},
+		{"())", "())", -1},
+		{"))(", "))(", -1},
+		{")))", ")))", -3},
+		{")())())", ")())())", -3},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{")", ")", 1},
+		{"()())", "()())", 5},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2015/DaySeven/code.go

@@ -0,0 +1,77 @@
+package dayseven
+
+import (
+	"maps"
+	"os"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D7", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) map[string]string {
+	content, _ := os.ReadFile(filepath)
+	instructions := make(map[string]string)
+	for line := range strings.SplitSeq(string(content), "\n") {
+		if parts := strings.Split(line, " -> "); len(parts) == 2 {
+			instructions[parts[1]] = parts[0]
+		}
+	}
+	return instructions
+}
+
+func evaluateWire(wire string, instructions map[string]string) uint16 {
+	cache := make(map[string]uint16)
+	var evaluate func(string) uint16
+	evaluate = func(wire string) uint16 {
+		if value, ok := cache[wire]; ok {
+			return value
+		}
+		if num, err := strconv.Atoi(wire); err == nil {
+			return uint16(num)
+		}
+		expression, exists := instructions[wire]
+		if !exists {
+			return 0
+		}
+		parts := strings.Fields(expression)
+		var result uint16
+		switch {
+		case len(parts) == 1:
+			result = evaluate(parts[0])
+		case parts[0] == "NOT":
+			result = ^evaluate(parts[1])
+		default:
+			left, right := evaluate(parts[0]), evaluate(parts[2])
+			switch parts[1] {
+			case "AND":
+				result = left & right
+			case "OR":
+				result = left | right
+			case "LSHIFT":
+				result = left << right
+			case "RSHIFT":
+				result = left >> right
+			}
+		}
+		cache[wire] = result
+		return result
+	}
+	return evaluate(wire)
+}
+
+func PartOne(data map[string]string) int {
+	return int(evaluateWire("a", data))
+}
+
+func PartTwo(data map[string]string) int {
+	signalA := PartOne(data)
+	instructionsCopy := make(map[string]string, len(data))
+	maps.Copy(instructionsCopy, data)
+	instructionsCopy["b"] = strconv.Itoa(signalA)
+	return int(evaluateWire("a", instructionsCopy))
+}

internal/2015/DaySeven/code_test.go

@@ -0,0 +1,50 @@
+package dayseven
+
+import (
+	"testing"
+)
+
+var testInput = map[string]string{
+	"x": "123",
+	"y": "456",
+	"d": "x AND y",
+	"e": "x OR y",
+	"f": "x LSHIFT 2",
+	"g": "y RSHIFT 2",
+	"h": "NOT x",
+	"i": "NOT y",
+	"a": "d",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 72
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	instructions := map[string]string{
+		"x": "10",
+		"y": "20",
+		"z": "x AND y",
+		"b": "z",
+		"w": "b LSHIFT 1",
+		"v": "NOT b",
+		"u": "w OR v",
+		"a": "u",
+	}
+
+	partOneResult := PartOne(instructions)
+	bValue := uint16(partOneResult)
+	w := bValue << 1
+	v := ^bValue
+	u := w | v
+	expected := int(u)
+
+	got := PartTwo(instructions)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d (PartOne result: %d)", got, expected, partOneResult)
+	}
+}

internal/2015/DaySix/code.go

@@ -0,0 +1,119 @@
+package daysix
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type instruction struct {
+	operation string
+	x1, y1    int
+	x2, y2    int
+}
+
+func init() {
+	registry.Register("2015D6", ParseInput, PartOne, PartTwo)
+}
+
+func parseInstruction(line string) (instruction, bool) {
+	var op string
+	var remaining string
+
+	switch {
+	case strings.HasPrefix(line, "turn on "):
+		op = "on"
+		remaining = strings.TrimPrefix(line, "turn on ")
+	case strings.HasPrefix(line, "turn off "):
+		op = "off"
+		remaining = strings.TrimPrefix(line, "turn off ")
+	case strings.HasPrefix(line, "toggle "):
+		op = "toggle"
+		remaining = strings.TrimPrefix(line, "toggle ")
+	default:
+		return instruction{}, false
+	}
+
+	parts := strings.Split(remaining, " through ")
+	firstCoordinates := strings.Split(parts[0], ",")
+	secondCoordinates := strings.Split(parts[1], ",")
+
+	x1, _ := strconv.Atoi(firstCoordinates[0])
+	y1, _ := strconv.Atoi(firstCoordinates[1])
+	x2, _ := strconv.Atoi(secondCoordinates[0])
+	y2, _ := strconv.Atoi(secondCoordinates[1])
+
+	return instruction{operation: op, x1: x1, y1: y1, x2: x2, y2: y2}, true
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(strings.TrimSpace(string(content)), "\n")
+}
+
+func PartOne(data []string) int {
+	grid := make([]bool, 1000*1000)
+
+	for _, line := range data {
+		instruction, ok := parseInstruction(line)
+		if !ok {
+			continue
+		}
+
+		for y := instruction.y1; y <= instruction.y2; y++ {
+			for x := instruction.x1; x <= instruction.x2; x++ {
+				idx := y*1000 + x
+				switch instruction.operation {
+				case "on":
+					grid[idx] = true
+				case "off":
+					grid[idx] = false
+				case "toggle":
+					grid[idx] = !grid[idx]
+				}
+			}
+		}
+	}
+
+	count := 0
+	for _, lit := range grid {
+		if lit {
+			count++
+		}
+	}
+	return count
+}
+
+func PartTwo(data []string) int {
+	grid := make([]int, 1000*1000)
+
+	for _, line := range data {
+		instruction, ok := parseInstruction(line)
+		if !ok {
+			continue
+		}
+
+		for y := instruction.y1; y <= instruction.y2; y++ {
+			for x := instruction.x1; x <= instruction.x2; x++ {
+				idx := y*1000 + x
+				switch instruction.operation {
+				case "on":
+					grid[idx]++
+				case "off":
+					if grid[idx] > 0 {
+						grid[idx]--
+					}
+				case "toggle":
+					grid[idx] += 2
+				}
+			}
+		}
+	}
+
+	total := 0
+	for _, brightness := range grid {
+		total += brightness
+	}
+	return total
+}

internal/2015/DaySix/code_test.go

@@ -0,0 +1,25 @@
+package daysix
+
+import "testing"
+
+var testInput = []string{
+	"turn on 0,0 through 999,999",
+	"toggle 0,0 through 999,0",
+	"turn off 499,499 through 500,500",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 998996
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 1001996
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2015/DayTen/code.go

@@ -0,0 +1,45 @@
+package dayten
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D10", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func applyLookAndSay(data string, iterations int) int {
+	for range iterations {
+		var result strings.Builder
+		idx := 0
+		for idx < len(data) {
+			digit := data[idx]
+			count := 1
+			for idx+count < len(data) && data[idx+count] == digit {
+				count++
+			}
+			result.WriteString(strconv.Itoa(count))
+			result.WriteByte(digit)
+			idx += count
+		}
+		data = result.String()
+	}
+	return len(data)
+}
+
+func PartOne(data string) int {
+	return applyLookAndSay(data, 40)
+}
+
+func PartTwo(data string) int {
+	return applyLookAndSay(data, 50)
+}

internal/2015/DayThirteen/code.go

@@ -0,0 +1,141 @@
+package daythirteen
+
+import (
+	"advent-of-code/internal/registry"
+	"math"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var inputPattern = regexp.MustCompile(`(\w+) would (gain|lose) (\d+) happiness units by sitting next to (\w+)\.?`)
+
+func init() {
+	registry.Register("2015D13", ParseInput, PartOne, PartTwo)
+}
+
+func buildHappinessMap(data []string) map[string]map[string]int {
+	happinessMap := make(map[string]map[string]int)
+
+	for _, line := range data {
+		matches := inputPattern.FindStringSubmatch(line)
+		person := matches[1]
+		operation := matches[2]
+		value, _ := strconv.Atoi(matches[3])
+		neighbor := matches[4]
+
+		if happinessMap[person] == nil {
+			happinessMap[person] = make(map[string]int)
+		}
+
+		if operation == "gain" {
+			happinessMap[person][neighbor] = value
+		} else {
+			happinessMap[person][neighbor] = -value
+		}
+	}
+
+	return happinessMap
+}
+
+func getAllPeople(happinessMap map[string]map[string]int) []string {
+	people := make([]string, 0, len(happinessMap))
+	for person := range happinessMap {
+		people = append(people, person)
+	}
+	return people
+}
+
+func generatePermutations(items []string) [][]string {
+	if len(items) == 0 {
+		return [][]string{{}}
+	}
+
+	var result [][]string
+	for idx, item := range items {
+		remaining := make([]string, len(items)-1)
+		copy(remaining[:idx], items[:idx])
+		copy(remaining[idx:], items[idx+1:])
+
+		for _, permutation := range generatePermutations(remaining) {
+			result = append(result, append([]string{item}, permutation...))
+		}
+	}
+	return result
+}
+
+func calculateTotalHappiness(arrangement []string, happinessMap map[string]map[string]int) int {
+	totalHappiness := 0
+	arrangementLength := len(arrangement)
+
+	for idx := range arrangementLength {
+		currentPerson := arrangement[idx]
+		leftNeighbor := arrangement[(idx-1+arrangementLength)%arrangementLength]
+		rightNeighbor := arrangement[(idx+1)%arrangementLength]
+
+		totalHappiness += happinessMap[currentPerson][leftNeighbor]
+		totalHappiness += happinessMap[currentPerson][rightNeighbor]
+	}
+
+	return totalHappiness
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	happinessMap := buildHappinessMap(data)
+	allPeople := getAllPeople(happinessMap)
+
+	fixedPerson := allPeople[0]
+	remainingPeople := allPeople[1:]
+	permutations := generatePermutations(remainingPeople)
+
+	maxHappiness := math.MinInt
+	arrangement := make([]string, len(allPeople))
+	arrangement[0] = fixedPerson
+
+	for _, perm := range permutations {
+		copy(arrangement[1:], perm)
+		totalHappiness := calculateTotalHappiness(arrangement, happinessMap)
+		if totalHappiness > maxHappiness {
+			maxHappiness = totalHappiness
+		}
+	}
+
+	return maxHappiness
+}
+
+func PartTwo(data []string) int {
+	happinessMap := buildHappinessMap(data)
+	allPeople := getAllPeople(happinessMap)
+
+	me := "Me"
+	happinessMap[me] = make(map[string]int)
+	for _, person := range allPeople {
+		happinessMap[person][me] = 0
+		happinessMap[me][person] = 0
+	}
+
+	allPeople = append(allPeople, me)
+	fixedPerson := allPeople[0]
+	remainingPeople := allPeople[1:]
+	permutations := generatePermutations(remainingPeople)
+
+	maxTotalChange := math.MinInt
+	arrangement := make([]string, len(allPeople))
+	arrangement[0] = fixedPerson
+
+	for _, permutation := range permutations {
+		copy(arrangement[1:], permutation)
+		totalHappiness := calculateTotalHappiness(arrangement, happinessMap)
+		if totalHappiness > maxTotalChange {
+			maxTotalChange = totalHappiness
+		}
+	}
+
+	return maxTotalChange
+}

internal/2015/DayThirteen/code_test.go

@@ -0,0 +1,28 @@
+package daythirteen
+
+import "testing"
+
+var testInput = []string{
+	"Alice would gain 54 happiness units by sitting next to Bob",
+	"Alice would lose 79 happiness units by sitting next to Carol",
+	"Alice would lose 2 happiness units by sitting next to David",
+	"Bob would gain 83 happiness units by sitting next to Alice",
+	"Bob would lose 7 happiness units by sitting next to Carol",
+	"Bob would lose 63 happiness units by sitting next to David",
+	"Carol would lose 62 happiness units by sitting next to Alice",
+	"Carol would gain 60 happiness units by sitting next to Bob",
+	"Carol would gain 55 happiness units by sitting next to David",
+	"David would gain 46 happiness units by sitting next to Alice",
+	"David would lose 7 happiness units by sitting next to Bob",
+	"David would gain 41 happiness units by sitting next to Carol",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 330
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+// no test for part two

internal/2015/DayThree/code.go

@@ -0,0 +1,68 @@
+package daythree
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+)
+
+type coordinates struct {
+	x, y int
+}
+
+func init() {
+	registry.Register("2015D3", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func PartOne(data string) int {
+	houses := make(map[coordinates]int)
+	x, y := 0, 0
+	houses[coordinates{x, y}] = 1
+	for _, direction := range data {
+		switch direction {
+		case '>':
+			x++
+		case '<':
+			x--
+		case '^':
+			y++
+		case 'v':
+			y--
+		}
+		houses[coordinates{x, y}]++
+	}
+	return len(houses)
+}
+
+func PartTwo(data string) int {
+	houses := make(map[coordinates]int)
+	santaX, santaY := 0, 0
+	robotX, robotY := 0, 0
+	houses[coordinates{0, 0}] = 2
+
+	for idx, direction := range data {
+		var x, y *int
+		if idx%2 == 0 {
+			x, y = &santaX, &santaY
+		} else {
+			x, y = &robotX, &robotY
+		}
+
+		switch direction {
+		case '>':
+			*x++
+		case '<':
+			*x--
+		case '^':
+			*y++
+		case 'v':
+			*y--
+		}
+		houses[coordinates{*x, *y}]++
+	}
+	return len(houses)
+}

internal/2015/DayThree/code_test.go

@@ -0,0 +1,45 @@
+package daythree
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{">", ">", 2},
+		{"^>v<", "^>v<", 4},
+		{"^v^v^v^v^v", "^v^v^v^v^v", 2},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"^v", "^v", 3},
+		{"^>v<", "^>v<", 3},
+		{"^v^v^v^v^v", "^v^v^v^v^v", 11},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2015/DayTwelve/code.go

@@ -0,0 +1,68 @@
+package daytwelve
+
+import (
+	"encoding/json"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2015D12", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	re := regexp.MustCompile(`-?\d+`)
+	sum := 0
+	for _, line := range data {
+		matches := re.FindAllString(line, -1)
+		for _, match := range matches {
+			number, _ := strconv.Atoi(match)
+			sum += number
+		}
+	}
+	return sum
+}
+
+func PartTwo(data []string) int {
+	var sumNumbers func(any) int
+	sumNumbers = func(v any) int {
+		switch value := v.(type) {
+		case float64:
+			return int(value)
+		case []any:
+			sum := 0
+			for _, item := range value {
+				sum += sumNumbers(item)
+			}
+			return sum
+		case map[string]any:
+			sum := 0
+			for _, item := range value {
+				if str, ok := item.(string); ok && str == "red" {
+					return 0
+				}
+				sum += sumNumbers(item)
+			}
+			return sum
+		default:
+			return 0
+		}
+	}
+
+	sum := 0
+	for _, line := range data {
+		var value any
+		_ = json.Unmarshal([]byte(line), &value)
+		sum += sumNumbers(value)
+	}
+	return sum
+}

internal/2015/DayTwelve/code_test.go

@@ -0,0 +1,51 @@
+package daytwelve
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"[1,2,3]", "[1,2,3]", 6},
+		{"{\"a\":2,\"b\":4}", "{\"a\":2,\"b\":4}", 6},
+		{"[[[3]]]", "[[[3]]]", 3},
+		{"{\"a\":{\"b\":4},\"c\":-1}", "{\"a\":{\"b\":4},\"c\":-1}", 3},
+		{"{\"a\":[-1,1]}", "{\"a\":[-1,1]}", 0},
+		{"[-1,{\"a\":1}]", "[-1,{\"a\":1}]", 0},
+		{"[]", "[]", 0},
+		{"{}", "{}", 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne([]string{tt.input})
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"[1,2,3]", "[1,2,3]", 6},
+		{"[1,{\"c\":\"red\",\"b\":2},3]", "[1,{\"c\":\"red\",\"b\":2},3]", 4},
+		{"{\"d\":\"red\",\"e\":[1,2,3,4],\"f\":5}", "{\"d\":\"red\",\"e\":[1,2,3,4],\"f\":5}", 0},
+		{"[1,\"red\",5]", "[1,\"red\",5]", 6},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo([]string{tt.input})
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2015/DayTwo/code.go

@@ -0,0 +1,48 @@
+package daytwo
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2015D2", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	total := 0
+	for _, line := range data {
+		parts := strings.Split(line, "x")
+		length, _ := strconv.Atoi(parts[0])
+		width, _ := strconv.Atoi(parts[1])
+		height, _ := strconv.Atoi(parts[2])
+		total += 2*length*width + 2*width*height + 2*height*length + min(length*width, width*height, height*length)
+	}
+	return total
+}
+
+func PartTwo(data []string) int {
+	total := 0
+	for _, line := range data {
+		parts := strings.Split(line, "x")
+		length, _ := strconv.Atoi(parts[0])
+		width, _ := strconv.Atoi(parts[1])
+		height, _ := strconv.Atoi(parts[2])
+
+		smallest := min(length, width, height)
+		middle := length + width + height - smallest - max(length, width, height)
+
+		perimeter := 2 * (smallest + middle)
+		volume := length * width * height
+
+		total += perimeter + volume
+	}
+	return total
+}

internal/2015/DayTwo/code_test.go

@@ -0,0 +1,43 @@
+package daytwo
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"2x3x4", "2x3x4", 58},
+		{"1x1x10", "1x1x10", 43},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne([]string{tt.input})
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected int
+	}{
+		{"2x3x4", "2x3x4", 34},
+		{"1x1x10", "1x1x10", 14},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo([]string{tt.input})
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2015/register.go

@@ -0,0 +1,19 @@
+package year2015
+
+import (
+	_ "advent-of-code/internal/2015/DayEight"
+	_ "advent-of-code/internal/2015/DayEleven"
+	_ "advent-of-code/internal/2015/DayFifteen"
+	_ "advent-of-code/internal/2015/DayFive"
+	_ "advent-of-code/internal/2015/DayFour"
+	_ "advent-of-code/internal/2015/DayFourteen"
+	_ "advent-of-code/internal/2015/DayNine"
+	_ "advent-of-code/internal/2015/DayOne"
+	_ "advent-of-code/internal/2015/DaySeven"
+	_ "advent-of-code/internal/2015/DaySix"
+	_ "advent-of-code/internal/2015/DayTen"
+	_ "advent-of-code/internal/2015/DayThirteen"
+	_ "advent-of-code/internal/2015/DayThree"
+	_ "advent-of-code/internal/2015/DayTwelve"
+	_ "advent-of-code/internal/2015/DayTwo"
+)

internal/2016/DayFive/code.go

@@ -0,0 +1,73 @@
+package dayfive
+
+import (
+	"advent-of-code/internal/registry"
+	"crypto/md5"
+	"fmt"
+	"os"
+	"strconv"
+)
+
+func init() {
+	registry.Register("2016D5", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func PartOne(data string) int {
+	doorIDBytes := []byte(data)
+	doorIDLen := len(doorIDBytes)
+	input := make([]byte, doorIDLen, doorIDLen+20)
+	copy(input, doorIDBytes)
+	password := make([]byte, 0, 8)
+	index := 0
+	hexChars := "0123456789abcdef"
+
+	for len(password) < 8 {
+		indexBytes := strconv.AppendInt(input[:doorIDLen], int64(index), 10)
+		hash := md5.Sum(indexBytes)
+
+		if hash[0] == 0 && hash[1] == 0 && hash[2] < 16 {
+			char := hexChars[hash[2]&0x0F]
+			password = append(password, char)
+		}
+		index++
+	}
+
+	fmt.Println(string(password))
+	return 0
+}
+
+func PartTwo(data string) int {
+	doorIDBytes := []byte(data)
+	doorIDLen := len(doorIDBytes)
+	input := make([]byte, doorIDLen, doorIDLen+20)
+	copy(input, doorIDBytes)
+	password := make([]byte, 8)
+	filled := make([]bool, 8)
+	filledCount := 0
+	index := 0
+	hexChars := "0123456789abcdef"
+
+	for filledCount < 8 {
+		indexBytes := strconv.AppendInt(input[:doorIDLen], int64(index), 10)
+		hash := md5.Sum(indexBytes)
+
+		if hash[0] == 0 && hash[1] == 0 && hash[2] < 16 {
+			position := int(hash[2] & 0x0F)
+			if position < 8 && !filled[position] {
+				char := hexChars[hash[3]>>4]
+				password[position] = char
+				filled[position] = true
+				filledCount++
+			}
+		}
+		index++
+	}
+
+	fmt.Println(string(password))
+	return 0
+}

internal/2016/DayFive/code_test.go

@@ -0,0 +1,58 @@
+package dayfive
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+var testInput = "abc"
+
+func TestPartOne(t *testing.T) {
+	expected := "18f47a30"
+
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("Failed to create pipe: %v", err)
+	}
+	os.Stdout = w
+
+	PartOne(testInput)
+
+	_ = w.Close()
+	os.Stdout = oldStdout
+
+	var buffer bytes.Buffer
+	_, _ = buffer.ReadFrom(r)
+	got := strings.TrimSpace(buffer.String())
+
+	if got != expected {
+		t.Errorf("PartOne() printed %q, want %q", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := "05ace8e3"
+
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("Failed to create pipe: %v", err)
+	}
+	os.Stdout = w
+
+	PartTwo(testInput)
+
+	_ = w.Close()
+	os.Stdout = oldStdout
+
+	var buffer bytes.Buffer
+	_, _ = buffer.ReadFrom(r)
+	got := strings.TrimSpace(buffer.String())
+
+	if got != expected {
+		t.Errorf("PartTwo() printed %q, want %q", got, expected)
+	}
+}

internal/2016/DayFour/code.go

@@ -0,0 +1,119 @@
+package dayfour
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2016D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func isValidRoom(encryptedName string, expectedChecksum string) bool {
+	letterFrequency := [26]int{}
+
+	for _, character := range encryptedName {
+		if character >= 'a' && character <= 'z' {
+			letterFrequency[character-'a']++
+		}
+	}
+
+	type letterFrequencyPair struct {
+		letter rune
+		count  int
+	}
+
+	letterFrequencyPairs := make([]letterFrequencyPair, 0, 26)
+	for index, frequency := range letterFrequency {
+		if frequency > 0 {
+			letterFrequencyPairs = append(letterFrequencyPairs, letterFrequencyPair{
+				letter: rune('a' + index),
+				count:  frequency,
+			})
+		}
+	}
+
+	sort.Slice(letterFrequencyPairs, func(i, j int) bool {
+		if letterFrequencyPairs[i].count != letterFrequencyPairs[j].count {
+			return letterFrequencyPairs[i].count > letterFrequencyPairs[j].count
+		}
+		return letterFrequencyPairs[i].letter < letterFrequencyPairs[j].letter
+	})
+
+	if len(letterFrequencyPairs) < 5 {
+		return false
+	}
+
+	for index := range 5 {
+		if letterFrequencyPairs[index].letter != rune(expectedChecksum[index]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func decryptRoomName(encryptedName string, sectorID int) string {
+	result := strings.Builder{}
+	result.Grow(len(encryptedName))
+	shift := sectorID % 26
+	for _, char := range encryptedName {
+		if char == '-' {
+			result.WriteByte(' ')
+		} else if char >= 'a' && char <= 'z' {
+			shifted := ((int(char-'a') + shift) % 26) + 'a'
+			result.WriteByte(byte(shifted))
+		}
+	}
+	return result.String()
+}
+
+var roomPattern = regexp.MustCompile(`^(.+)-(\d+)(?:\[([a-z]{5})\])?$`)
+
+func PartOne(data []string) int {
+	sum := 0
+	for _, line := range data {
+		if line == "" {
+			continue
+		}
+		matches := roomPattern.FindStringSubmatch(line)
+		if len(matches) < 4 || matches[3] == "" {
+			continue
+		}
+		encryptedName := matches[1]
+		sectorIdentifier, _ := strconv.Atoi(matches[2])
+		actualChecksum := matches[3]
+		if isValidRoom(encryptedName, actualChecksum) {
+			sum += sectorIdentifier
+		}
+	}
+	return sum
+}
+
+func PartTwo(data []string) int {
+	for _, line := range data {
+		matches := roomPattern.FindStringSubmatch(line)
+		encryptedName := matches[1]
+		sectorIdentifier, _ := strconv.Atoi(matches[2])
+		checksum := matches[3]
+
+		if !isValidRoom(encryptedName, checksum) {
+			continue
+		}
+
+		decrypted := decryptRoomName(encryptedName, sectorIdentifier)
+		if strings.Contains(decrypted, "northpole") {
+			return sectorIdentifier
+		}
+	}
+	return 0
+}

internal/2016/DayFour/code_test.go

@@ -0,0 +1,29 @@
+package dayfour
+
+import (
+	"testing"
+)
+
+var testInput = []string{
+	"aaaaa-bbb-z-y-x-123[abxyz]",
+	"a-b-c-d-e-f-g-h-987[abcde]",
+	"not-a-real-room-404[oarel]",
+	"totally-real-room-200[decoy]",
+	"ijmockjgz-storage-5[gjoac]",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 1519
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 5
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2016/DayOne/code.go

@@ -0,0 +1,91 @@
+package dayone
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+func init() {
+	registry.Register("2016D1", ParseInput, PartOne, PartTwo)
+}
+
+type position struct {
+	x, y int
+}
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	parts := strings.Split(string(content), ",")
+	for i, p := range parts {
+		parts[i] = strings.TrimSpace(p)
+	}
+	return parts
+}
+
+func PartOne(data []string) int {
+	x, y := 0, 0
+	directions := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
+	currentDirection := 0
+
+	for _, instruction := range data {
+		turn := instruction[0]
+		distance, _ := strconv.Atoi(instruction[1:])
+
+		switch turn {
+		case 'R':
+			currentDirection = (currentDirection + 1) % 4
+		case 'L':
+			currentDirection = (currentDirection + 3) % 4
+		}
+
+		x += directions[currentDirection][0] * distance
+		y += directions[currentDirection][1] * distance
+	}
+
+	return abs(x) + abs(y)
+}
+
+func PartTwo(data []string) int {
+	x, y := 0, 0
+	directions := [][]int{{0, 1}, {1, 0}, {0, -1}, {-1, 0}}
+	currentDirection := 0
+	visited := make(map[position]bool)
+	visited[position{0, 0}] = true
+
+	for _, instruction := range data {
+		turn := instruction[0]
+		distance, _ := strconv.Atoi(instruction[1:])
+
+		switch turn {
+		case 'R':
+			currentDirection = (currentDirection + 1) % 4
+		case 'L':
+			currentDirection = (currentDirection + 3) % 4
+		}
+
+		directionX := directions[currentDirection][0]
+		directionY := directions[currentDirection][1]
+
+		for range distance {
+			x += directionX
+			y += directionY
+			pos := position{x, y}
+			if visited[pos] {
+				return abs(x) + abs(y)
+			}
+			visited[pos] = true
+		}
+	}
+
+	return 0
+}

internal/2016/DayOne/code_test.go

@@ -0,0 +1,47 @@
+package dayone
+
+import (
+	"testing"
+)
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected int
+	}{
+		{
+			name:     "Example 1",
+			input:    []string{"R2", "L3"},
+			expected: 5,
+		},
+		{
+			name:     "Example 2",
+			input:    []string{"R2", "R2", "R2"},
+			expected: 2,
+		},
+		{
+			name:     "Example 3",
+			input:    []string{"R5", "L5", "R5", "R3"},
+			expected: 12,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	input := []string{"R8", "R4", "R4", "R8"}
+	expected := 4
+	got := PartTwo(input)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, 4)
+	}
+}

internal/2016/DayThree/code.go

@@ -0,0 +1,49 @@
+package daythree
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2016D3", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) [][3]int {
+	content, _ := os.ReadFile(filepath)
+	lines := strings.Split(string(content), "\n")
+	var result [][3]int
+	for _, line := range lines {
+		var a, b, c int
+		fmt.Sscanf(line, "%d %d %d", &a, &b, &c)
+		result = append(result, [3]int{a, b, c})
+
+	}
+	return result
+}
+
+func PartOne(data [][3]int) int {
+	count := 0
+	for _, triangle := range data {
+		a, b, c := triangle[0], triangle[1], triangle[2]
+		if a+b > c && a+c > b && b+c > a {
+			count++
+		}
+	}
+	return count
+}
+
+func PartTwo(data [][3]int) int {
+	count := 0
+	for idx := 0; idx < len(data)-2; idx += 3 {
+		for column := range 3 {
+			a, b, c := data[idx][column], data[idx+1][column], data[idx+2][column]
+			if a+b > c && a+c > b && b+c > a {
+				count++
+			}
+		}
+	}
+	return count
+}

internal/2016/DayThree/code_test.go

@@ -0,0 +1,28 @@
+package daythree
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	input := [][3]int{{5, 10, 25}}
+	expected := 0
+	got := PartOne(input)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	input := [][3]int{
+		{101, 301, 501},
+		{102, 302, 502},
+		{103, 303, 503},
+		{201, 401, 601},
+		{202, 402, 602},
+		{203, 403, 603},
+	}
+	expected := 6
+	got := PartTwo(input)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2016/DayTwo/code.go

@@ -0,0 +1,101 @@
+package daytwo
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2016D2", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(instructions []string) int {
+	row, column := 1, 1
+
+	keypad := [3][3]int{
+		{1, 2, 3},
+		{4, 5, 6},
+		{7, 8, 9},
+	}
+	code := 0
+
+	for _, line := range instructions {
+		for _, move := range line {
+			switch move {
+			case 'U':
+				if row > 0 {
+					row--
+				}
+			case 'D':
+				if row < 2 {
+					row++
+				}
+			case 'L':
+				if column > 0 {
+					column--
+				}
+			case 'R':
+				if column < 2 {
+					column++
+				}
+			}
+		}
+		code = code*10 + keypad[row][column]
+	}
+
+	return code
+}
+
+func PartTwo(instructions []string) int {
+	row, column := 2, 0
+
+	keypad := [5][5]int{
+		{0, 0, 1, 0, 0},
+		{0, 2, 3, 4, 0},
+		{5, 6, 7, 8, 9},
+		{0, 10, 11, 12, 0},
+		{0, 0, 13, 0, 0},
+	}
+
+	isValidPosition := func(r, c int) bool {
+		return r >= 0 && r < 5 && c >= 0 && c < 5 && keypad[r][c] != 0
+	}
+
+	var codeBuilder strings.Builder
+
+	for _, line := range instructions {
+		for _, move := range line {
+			newRow, newColumn := row, column
+			switch move {
+			case 'U':
+				newRow--
+			case 'D':
+				newRow++
+			case 'L':
+				newColumn--
+			case 'R':
+				newColumn++
+			}
+			if isValidPosition(newRow, newColumn) {
+				row, column = newRow, newColumn
+			}
+		}
+		value := keypad[row][column]
+		if value < 10 {
+			codeBuilder.WriteByte(byte('0' + value))
+		} else {
+			codeBuilder.WriteByte(byte('A' + value - 10))
+		}
+	}
+
+	code := codeBuilder.String()
+	fmt.Println(code)
+	return 0
+}

internal/2016/DayTwo/code_test.go

@@ -0,0 +1,42 @@
+package daytwo
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+var testInput = []string{"ULL", "RRDDD", "LURDL", "UUUUD"}
+
+func TestPartOne(t *testing.T) {
+	expected := 1985
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := "5DB3"
+
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("Failed to create pipe: %v", err)
+	}
+	os.Stdout = w
+
+	PartTwo(testInput)
+
+	_ = w.Close()
+	os.Stdout = oldStdout
+
+	var buffer bytes.Buffer
+	_, _ = buffer.ReadFrom(r)
+	got := strings.TrimSpace(buffer.String())
+
+	if got != expected {
+		t.Errorf("PartTwo() printed %q, want %q", got, expected)
+	}
+}

internal/2016/register.go

@@ -0,0 +1,9 @@
+package year2016
+
+import (
+	_ "advent-of-code/internal/2016/DayFive"
+	_ "advent-of-code/internal/2016/DayFour"
+	_ "advent-of-code/internal/2016/DayOne"
+	_ "advent-of-code/internal/2016/DayThree"
+	_ "advent-of-code/internal/2016/DayTwo"
+)

internal/2017/DayFive/code.go

@@ -0,0 +1,60 @@
+package dayfive
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2017D5", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []int {
+	content, _ := os.ReadFile(filepath)
+	var data []int
+	for line := range strings.SplitSeq(string(content), "\n") {
+		num, _ := strconv.Atoi(line)
+		data = append(data, num)
+	}
+	return data
+}
+
+func PartOne(data []int) int {
+	instructions := make([]int, len(data))
+	copy(instructions, data)
+
+	position := 0
+	steps := 0
+
+	for position >= 0 && position < len(instructions) {
+		jump := instructions[position]
+		instructions[position]++
+		position += jump
+		steps++
+	}
+
+	return steps
+}
+
+func PartTwo(data []int) int {
+	instructions := make([]int, len(data))
+	copy(instructions, data)
+
+	position := 0
+	steps := 0
+
+	for position >= 0 && position < len(instructions) {
+		jump := instructions[position]
+		if jump >= 3 {
+			instructions[position]--
+		} else {
+			instructions[position]++
+		}
+		position += jump
+		steps++
+	}
+
+	return steps
+}

internal/2017/DayFive/code_test.go

@@ -0,0 +1,27 @@
+package dayfive
+
+import "testing"
+
+var testInput = []int{
+	0,
+	3,
+	0,
+	1,
+	-3,
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 5
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 10
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2017/DayFour/code.go

@@ -0,0 +1,60 @@
+package dayfour
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"slices"
+	"strings"
+)
+
+func init() {
+	registry.Register("2017D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	validCount := 0
+	for _, passphrase := range data {
+		words := strings.Fields(passphrase)
+		seen := make(map[string]bool, len(words))
+		hasDuplicate := false
+		for _, word := range words {
+			if seen[word] {
+				hasDuplicate = true
+				break
+			}
+			seen[word] = true
+		}
+		if !hasDuplicate {
+			validCount++
+		}
+	}
+	return validCount
+}
+
+func PartTwo(data []string) int {
+	validCount := 0
+	for _, passphrase := range data {
+		words := strings.Fields(passphrase)
+		seen := make(map[string]bool, len(words))
+		hasAnagram := false
+		for _, word := range words {
+			runes := []rune(word)
+			slices.Sort(runes)
+			normalized := string(runes)
+			if seen[normalized] {
+				hasAnagram = true
+				break
+			}
+			seen[normalized] = true
+		}
+		if !hasAnagram {
+			validCount++
+		}
+	}
+	return validCount
+}

internal/2017/DayFour/code_test.go

@@ -0,0 +1,89 @@
+package dayfour
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected int
+	}{
+		{
+			name:     "aa bb cc dd ee is valid",
+			input:    []string{"aa bb cc dd ee"},
+			expected: 1,
+		},
+		{
+			name:     "aa bb cc dd aa is not valid",
+			input:    []string{"aa bb cc dd aa"},
+			expected: 0,
+		},
+		{
+			name:     "aa bb cc dd aaa is valid",
+			input:    []string{"aa bb cc dd aaa"},
+			expected: 1,
+		},
+		{
+			name:     "multiple passphrases",
+			input:    []string{"aa bb cc dd ee", "aa bb cc dd aa", "aa bb cc dd aaa"},
+			expected: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		expected int
+	}{
+		{
+			name:     "abcde fghij is valid",
+			input:    []string{"abcde fghij"},
+			expected: 1,
+		},
+		{
+			name:     "abcde xyz ecdab is not valid",
+			input:    []string{"abcde xyz ecdab"},
+			expected: 0,
+		},
+		{
+			name:     "a ab abc abd abf abj is valid",
+			input:    []string{"a ab abc abd abf abj"},
+			expected: 1,
+		},
+		{
+			name:     "iiii oiii ooii oooi oooo is valid",
+			input:    []string{"iiii oiii ooii oooi oooo"},
+			expected: 1,
+		},
+		{
+			name:     "oiii ioii iioi iiio is not valid",
+			input:    []string{"oiii ioii iioi iiio"},
+			expected: 0,
+		},
+		{
+			name:     "multiple passphrases",
+			input:    []string{"abcde fghij", "abcde xyz ecdab", "a ab abc abd abf abj", "oiii ioii iioi iiio"},
+			expected: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2017/DayOne/code.go

@@ -0,0 +1,45 @@
+package dayone
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+)
+
+func init() {
+	registry.Register("2017D1", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []int {
+	content, _ := os.ReadFile(filepath)
+	digits := string(content)
+	result := make([]int, 0, len(digits))
+	for _, char := range digits {
+		digit, _ := strconv.Atoi(string(char))
+		result = append(result, digit)
+	}
+	return result
+}
+
+func PartOne(data []int) int {
+	sum := 0
+	for idx := range data {
+		nextIndex := (idx + 1) % len(data)
+		if data[idx] == data[nextIndex] {
+			sum += data[idx]
+		}
+	}
+	return sum
+}
+
+func PartTwo(data []int) int {
+	sum := 0
+	halfway := len(data) / 2
+	for idx := range data {
+		halfwayIndex := (idx + halfway) % len(data)
+		if data[idx] == data[halfwayIndex] {
+			sum += data[idx]
+		}
+	}
+	return sum
+}

internal/2017/DayOne/code_test.go

@@ -0,0 +1,84 @@
+package dayone
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{
+			name:     "1122 produces 3",
+			input:    []int{1, 1, 2, 2},
+			expected: 3,
+		},
+		{
+			name:     "1111 produces 4",
+			input:    []int{1, 1, 1, 1},
+			expected: 4,
+		},
+		{
+			name:     "1234 produces 0",
+			input:    []int{1, 2, 3, 4},
+			expected: 0,
+		},
+		{
+			name:     "91212129 produces 9",
+			input:    []int{9, 1, 2, 1, 2, 1, 2, 9},
+			expected: 9,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{
+			name:     "1212 produces 6",
+			input:    []int{1, 2, 1, 2},
+			expected: 6,
+		},
+		{
+			name:     "1221 produces 0",
+			input:    []int{1, 2, 2, 1},
+			expected: 0,
+		},
+		{
+			name:     "123425 produces 4",
+			input:    []int{1, 2, 3, 4, 2, 5},
+			expected: 4,
+		},
+		{
+			name:     "123123 produces 12",
+			input:    []int{1, 2, 3, 1, 2, 3},
+			expected: 12,
+		},
+		{
+			name:     "12131415 produces 4",
+			input:    []int{1, 2, 1, 3, 1, 4, 1, 5},
+			expected: 4,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2017/DayThree/code.go

@@ -0,0 +1,81 @@
+package daythree
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+)
+
+func init() {
+	registry.Register("2017D3", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) int {
+	content, _ := os.ReadFile(filepath)
+	data, _ := strconv.Atoi(string(content))
+	return data
+}
+
+func abs(n int) int {
+	if n < 0 {
+		return -n
+	}
+	return n
+}
+
+func PartOne(data int) int {
+	layer := 1
+
+	for (2*layer+1)*(2*layer+1) < data {
+		layer++
+	}
+
+	sideLength := 2*layer + 1
+	offset := sideLength*sideLength - data
+	side := offset / (sideLength - 1)
+	position := offset % (sideLength - 1)
+
+	coordinates := [4][2]int{
+		{layer, layer - position},
+		{layer - position, -layer},
+		{-layer, -layer + position},
+		{-layer + position, layer},
+	}
+
+	return abs(coordinates[side][0]) + abs(coordinates[side][1])
+}
+
+func PartTwo(data int) int {
+	grid := make(map[[2]int]int)
+	grid[[2]int{0, 0}] = 1
+
+	directions := [4][2]int{{1, 0}, {0, 1}, {-1, 0}, {0, -1}}
+	x, y := 1, 0
+	directionIdx := 0
+	sideLength := 1
+	stepsInSide := 1
+
+	for {
+		sum := grid[[2]int{x - 1, y - 1}] + grid[[2]int{x - 1, y}] + grid[[2]int{x - 1, y + 1}] +
+			grid[[2]int{x, y - 1}] + grid[[2]int{x, y + 1}] +
+			grid[[2]int{x + 1, y - 1}] + grid[[2]int{x + 1, y}] + grid[[2]int{x + 1, y + 1}]
+
+		if sum > data {
+			return sum
+		}
+
+		grid[[2]int{x, y}] = sum
+
+		if stepsInSide == sideLength {
+			stepsInSide = 0
+			if directionIdx%2 == 1 {
+				sideLength++
+			}
+			directionIdx = (directionIdx + 1) % 4
+		}
+
+		x += directions[directionIdx][0]
+		y += directions[directionIdx][1]
+		stepsInSide++
+	}
+}

internal/2017/DayThree/code_test.go

@@ -0,0 +1,84 @@
+package daythree
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    int
+		expected int
+	}{
+		{
+			name:     "square 1 is 0 steps",
+			input:    1,
+			expected: 0,
+		},
+		{
+			name:     "square 12 is 3 steps",
+			input:    12,
+			expected: 3,
+		},
+		{
+			name:     "square 23 is 2 steps",
+			input:    23,
+			expected: 2,
+		},
+		{
+			name:     "square 1024 is 31 steps",
+			input:    1024,
+			expected: 31,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartOne(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartOne() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    int
+		expected int
+	}{
+		{
+			name:     "input 1 returns first value larger than 1",
+			input:    1,
+			expected: 2,
+		},
+		{
+			name:     "input 2 returns first value larger than 2",
+			input:    2,
+			expected: 4,
+		},
+		{
+			name:     "input 4 returns first value larger than 4",
+			input:    4,
+			expected: 5,
+		},
+		{
+			name:     "input 5 returns first value larger than 5",
+			input:    5,
+			expected: 10,
+		},
+		{
+			name:     "input 747 returns first value larger than 747",
+			input:    747,
+			expected: 806,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := PartTwo(tt.input)
+			if got != tt.expected {
+				t.Errorf("PartTwo() = %d, want %d", got, tt.expected)
+			}
+		})
+	}
+}

internal/2017/DayTwo/code.go

@@ -0,0 +1,71 @@
+package daytwo
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2017D2", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) [][]int {
+	content, _ := os.ReadFile(filepath)
+	lines := strings.Split(string(content), "\n")
+	result := make([][]int, 0, len(lines))
+
+	for _, line := range lines {
+		fields := strings.Fields(line)
+		row := make([]int, 0, len(fields))
+		for _, field := range fields {
+			num, _ := strconv.Atoi(field)
+			row = append(row, num)
+		}
+		result = append(result, row)
+	}
+
+	return result
+}
+
+func PartOne(data [][]int) int {
+	sum := 0
+	for _, row := range data {
+		min, max := row[0], row[0]
+		for _, value := range row[1:] {
+			if value < min {
+				min = value
+			}
+			if value > max {
+				max = value
+			}
+		}
+		sum += max - min
+	}
+	return sum
+}
+
+func PartTwo(data [][]int) int {
+	sum := 0
+	for _, row := range data {
+		found := false
+		for idx, first := range row {
+			for _, second := range row[idx+1:] {
+				max, min := first, second
+				if first < second {
+					max, min = second, first
+				}
+				if min != 0 && max%min == 0 {
+					sum += max / min
+					found = true
+					break
+				}
+			}
+			if found {
+				break
+			}
+		}
+	}
+	return sum
+}

internal/2017/DayTwo/code_test.go

@@ -0,0 +1,29 @@
+package daytwo
+
+import "testing"
+
+func TestPartOne(t *testing.T) {
+	input := [][]int{
+		{5, 1, 9, 5},
+		{7, 5, 3},
+		{2, 4, 6, 8},
+	}
+	got := PartOne(input)
+	expected := 18
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	input := [][]int{
+		{5, 9, 2, 8},
+		{9, 4, 7, 3},
+		{3, 8, 6, 5},
+	}
+	got := PartTwo(input)
+	expected := 9
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2017/register.go

@@ -0,0 +1,9 @@
+package year2017
+
+import (
+	_ "advent-of-code/internal/2017/DayFive"
+	_ "advent-of-code/internal/2017/DayFour"
+	_ "advent-of-code/internal/2017/DayOne"
+	_ "advent-of-code/internal/2017/DayThree"
+	_ "advent-of-code/internal/2017/DayTwo"
+)

internal/2018/DayFive/code.go

@@ -0,0 +1,64 @@
+package dayfive
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"unicode"
+)
+
+func init() {
+	registry.Register("2018D5", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) string {
+	content, _ := os.ReadFile(filepath)
+	return string(content)
+}
+
+func reactPolymer(data string) int {
+	stack := []rune{}
+
+	for _, char := range data {
+		if len(stack) == 0 {
+			stack = append(stack, char)
+			continue
+		}
+
+		top := stack[len(stack)-1]
+
+		if unicode.ToLower(top) == unicode.ToLower(char) && top != char {
+			stack = stack[:len(stack)-1]
+		} else {
+			stack = append(stack, char)
+		}
+	}
+
+	return len(stack)
+}
+
+func PartOne(data string) int {
+	return reactPolymer(data)
+}
+
+func PartTwo(data string) int {
+	unitTypes := make(map[rune]bool)
+	for _, char := range data {
+		unitTypes[unicode.ToLower(char)] = true
+	}
+
+	shortestPolymerLength := len(data)
+	for unitType := range unitTypes {
+		filtered := make([]rune, 0, len(data))
+		for _, char := range data {
+			if unicode.ToLower(char) != unitType {
+				filtered = append(filtered, char)
+			}
+		}
+		length := reactPolymer(string(filtered))
+		if length < shortestPolymerLength {
+			shortestPolymerLength = length
+		}
+	}
+
+	return shortestPolymerLength
+}

internal/2018/DayFive/code_test.go

@@ -0,0 +1,21 @@
+package dayfive
+
+import "testing"
+
+var testInput = "dabAcCaCBAcCcaDA"
+
+func TestPartOne(t *testing.T) {
+	expected := 10
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 4
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2018/DayFour/code.go

@@ -0,0 +1,133 @@
+package dayfour
+
+import (
+	"os"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"advent-of-code/internal/registry"
+)
+
+var (
+	guardRegex = regexp.MustCompile(`Guard #(\d+) begins shift`)
+	timeLayout = "2006-01-02 15:04"
+)
+
+func init() {
+	registry.Register("2018D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+type record struct {
+	timestamp time.Time
+	action    string
+	guardID   int
+}
+
+func PartOne(data []string) int {
+	records := make([]record, 0, len(data))
+
+	for _, line := range data {
+		timeStr, action, _ := strings.Cut(line[1:], "] ")
+		timestamp, _ := time.Parse(timeLayout, timeStr)
+		guardID := -1
+		if matches := guardRegex.FindStringSubmatch(action); matches != nil {
+			guardID, _ = strconv.Atoi(matches[1])
+		}
+		records = append(records, record{timestamp, action, guardID})
+	}
+
+	slices.SortFunc(records, func(a, b record) int {
+		return a.timestamp.Compare(b.timestamp)
+	})
+
+	guardSleepMinutes := make(map[int]int)
+	guardMinuteCount := make(map[int]map[int]int)
+	currentGuard := -1
+
+	for i := range records {
+		if records[i].guardID != -1 {
+			currentGuard = records[i].guardID
+			if guardMinuteCount[currentGuard] == nil {
+				guardMinuteCount[currentGuard] = make(map[int]int)
+			}
+		}
+		if records[i].action == "falls asleep" && i+1 < len(records) {
+			start, end := records[i].timestamp.Minute(), records[i+1].timestamp.Minute()
+			guardSleepMinutes[currentGuard] += end - start
+			for m := start; m < end; m++ {
+				guardMinuteCount[currentGuard][m]++
+			}
+		}
+	}
+
+	maxGuard, maxMinutes := -1, 0
+	for id, minutes := range guardSleepMinutes {
+		if minutes > maxMinutes {
+			maxGuard, maxMinutes = id, minutes
+		}
+	}
+
+	maxMinute, maxCount := -1, 0
+	for m, count := range guardMinuteCount[maxGuard] {
+		if count > maxCount {
+			maxMinute, maxCount = m, count
+		}
+	}
+
+	return maxGuard * maxMinute
+}
+
+func PartTwo(data []string) int {
+	records := make([]record, 0, len(data))
+
+	for _, line := range data {
+		timeStr, action, _ := strings.Cut(line[1:], "] ")
+		timestamp, _ := time.Parse(timeLayout, timeStr)
+		guardID := -1
+		if matches := guardRegex.FindStringSubmatch(action); matches != nil {
+			guardID, _ = strconv.Atoi(matches[1])
+		}
+		records = append(records, record{timestamp, action, guardID})
+	}
+
+	slices.SortFunc(records, func(a, b record) int {
+		return a.timestamp.Compare(b.timestamp)
+	})
+
+	guardMinuteCount := make(map[int]map[int]int)
+	currentGuard := -1
+
+	for idx := range records {
+		if records[idx].guardID != -1 {
+			currentGuard = records[idx].guardID
+			if guardMinuteCount[currentGuard] == nil {
+				guardMinuteCount[currentGuard] = make(map[int]int)
+			}
+		}
+		if records[idx].action == "falls asleep" && idx+1 < len(records) {
+			start, end := records[idx].timestamp.Minute(), records[idx+1].timestamp.Minute()
+			for m := start; m < end; m++ {
+				guardMinuteCount[currentGuard][m]++
+			}
+		}
+	}
+
+	maxGuard, maxMinute, maxCount := -1, -1, 0
+	for guardID, minuteCounts := range guardMinuteCount {
+		for minute, count := range minuteCounts {
+			if count > maxCount {
+				maxGuard, maxMinute, maxCount = guardID, minute, count
+			}
+		}
+	}
+
+	return maxGuard * maxMinute
+}

internal/2018/DayFour/code_test.go

@@ -0,0 +1,39 @@
+package dayfour
+
+import "testing"
+
+var testInput = []string{
+	"[1518-11-01 00:00] Guard #10 begins shift",
+	"[1518-11-01 00:05] falls asleep",
+	"[1518-11-01 00:25] wakes up",
+	"[1518-11-01 00:30] falls asleep",
+	"[1518-11-01 00:55] wakes up",
+	"[1518-11-01 23:58] Guard #99 begins shift",
+	"[1518-11-02 00:40] falls asleep",
+	"[1518-11-02 00:50] wakes up",
+	"[1518-11-03 00:05] Guard #10 begins shift",
+	"[1518-11-03 00:24] falls asleep",
+	"[1518-11-03 00:29] wakes up",
+	"[1518-11-04 00:02] Guard #99 begins shift",
+	"[1518-11-04 00:36] falls asleep",
+	"[1518-11-04 00:46] wakes up",
+	"[1518-11-05 00:03] Guard #99 begins shift",
+	"[1518-11-05 00:45] falls asleep",
+	"[1518-11-05 00:55] wakes up",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 240
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 4455
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2018/DayOne/code.go

@@ -0,0 +1,45 @@
+package dayone
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2018D1", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []int {
+	content, _ := os.ReadFile(filepath)
+	var data []int
+	for line := range strings.SplitSeq(string(content), "\n") {
+		num, _ := strconv.Atoi(line)
+		data = append(data, num)
+	}
+	return data
+}
+
+func PartOne(data []int) int {
+	sum := 0
+	for _, num := range data {
+		sum += num
+	}
+	return sum
+}
+
+func PartTwo(data []int) int {
+	seen := make(map[int]bool)
+	sum := 0
+	seen[0] = true
+	for {
+		for _, num := range data {
+			sum += num
+			if seen[sum] {
+				return sum
+			}
+			seen[sum] = true
+		}
+	}
+}

internal/2018/DayOne/code_test.go

@@ -0,0 +1,26 @@
+package dayone
+
+import "testing"
+
+var testInput = []int{
+	+1,
+	-2,
+	3,
+	1,
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 3
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 2
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2018/DayThree/code.go

@@ -0,0 +1,101 @@
+package daythree
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2018D3", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	coverage := make(map[string]int)
+	re := regexp.MustCompile(`#\d+ @ (\d+),(\d+): (\d+)x(\d+)`)
+
+	for _, line := range data {
+		matches := re.FindStringSubmatch(line)
+
+		left, _ := strconv.Atoi(matches[1])
+		top, _ := strconv.Atoi(matches[2])
+		width, _ := strconv.Atoi(matches[3])
+		height, _ := strconv.Atoi(matches[4])
+
+		for x := left; x < left+width; x++ {
+			for y := top; y < top+height; y++ {
+				key := fmt.Sprintf("%d,%d", x, y)
+				coverage[key]++
+			}
+		}
+	}
+
+	overlapCount := 0
+	for _, count := range coverage {
+		if count >= 2 {
+			overlapCount++
+		}
+	}
+
+	return overlapCount
+}
+
+func PartTwo(data []string) int {
+	coverage := make(map[string]int)
+	re := regexp.MustCompile(`#\d+ @ (\d+),(\d+): (\d+)x(\d+)`)
+
+	for _, line := range data {
+		matches := re.FindStringSubmatch(line)
+
+		left, _ := strconv.Atoi(matches[1])
+		top, _ := strconv.Atoi(matches[2])
+		width, _ := strconv.Atoi(matches[3])
+		height, _ := strconv.Atoi(matches[4])
+
+		for x := left; x < left+width; x++ {
+			for y := top; y < top+height; y++ {
+				key := fmt.Sprintf("%d,%d", x, y)
+				coverage[key]++
+			}
+		}
+	}
+
+	reWithID := regexp.MustCompile(`#(\d+) @ (\d+),(\d+): (\d+)x(\d+)`)
+	for _, line := range data {
+		matches := reWithID.FindStringSubmatch(line)
+		if len(matches) != 6 {
+			continue
+		}
+
+		id, _ := strconv.Atoi(matches[1])
+		left, _ := strconv.Atoi(matches[2])
+		top, _ := strconv.Atoi(matches[3])
+		width, _ := strconv.Atoi(matches[4])
+		height, _ := strconv.Atoi(matches[5])
+
+		overlaps := false
+		for x := left; x < left+width && !overlaps; x++ {
+			for y := top; y < top+height; y++ {
+				key := fmt.Sprintf("%d,%d", x, y)
+				if coverage[key] > 1 {
+					overlaps = true
+					break
+				}
+			}
+		}
+
+		if !overlaps {
+			return id
+		}
+	}
+
+	return 0
+}

internal/2018/DayThree/code_test.go

@@ -0,0 +1,25 @@
+package daythree
+
+import "testing"
+
+var testInput = []string{
+	"#1 @ 1,3: 4x4",
+	"#2 @ 3,1: 4x4",
+	"#3 @ 5,5: 2x2",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 4
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 3
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2018/DayTwo/code.go

@@ -0,0 +1,81 @@
+package daytwo
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2018D2", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	countWithTwo := 0
+	countWithThree := 0
+
+	for _, boxID := range data {
+		charCounts := make(map[rune]int)
+		for _, char := range boxID {
+			charCounts[char]++
+		}
+
+		hasExactlyTwo := false
+		hasExactlyThree := false
+
+		for _, count := range charCounts {
+			switch count {
+			case 2:
+				hasExactlyTwo = true
+			case 3:
+				hasExactlyThree = true
+			}
+		}
+
+		if hasExactlyTwo {
+			countWithTwo++
+		}
+		if hasExactlyThree {
+			countWithThree++
+		}
+	}
+
+	return countWithTwo * countWithThree
+}
+
+func PartTwo(data []string) int {
+	for idx := range data {
+		for otherIdx := idx + 1; otherIdx < len(data); otherIdx++ {
+			if data[idx] == "" || data[otherIdx] == "" {
+				continue
+			}
+
+			differenceCount := 0
+			differingPosition := -1
+
+			if len(data[idx]) != len(data[otherIdx]) {
+				continue
+			}
+
+			for position := 0; position < len(data[idx]); position++ {
+				if data[idx][position] != data[otherIdx][position] {
+					differenceCount++
+					differingPosition = position
+				}
+			}
+
+			if differenceCount == 1 {
+				common := data[idx][:differingPosition] + data[idx][differingPosition+1:]
+				fmt.Println(common)
+				return 0
+			}
+		}
+	}
+	return 0
+}

internal/2018/DayTwo/code_test.go

@@ -0,0 +1,58 @@
+package daytwo
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestPartOne(t *testing.T) {
+	input := []string{
+		"abcdef",
+		"bababc",
+		"abbcde",
+		"abcccd",
+		"aabcdd",
+		"abcdee",
+		"ababab",
+	}
+	expected := 12
+	got := PartOne(input)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	input := []string{
+		"abcde",
+		"fghij",
+		"klmno",
+		"pqrst",
+		"fguij",
+		"axcye",
+		"wvxyz",
+	}
+	expected := "fgij"
+
+	oldStdout := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("Failed to create pipe: %v", err)
+	}
+	os.Stdout = w
+
+	PartTwo(input)
+
+	_ = w.Close()
+	os.Stdout = oldStdout
+
+	var buffer bytes.Buffer
+	_, _ = buffer.ReadFrom(r)
+	got := strings.TrimSpace(buffer.String())
+
+	if got != expected {
+		t.Errorf("PartTwo() printed %q, want %q", got, expected)
+	}
+}

internal/2018/register.go

@@ -0,0 +1,9 @@
+package year2018
+
+import (
+	_ "advent-of-code/internal/2018/DayFive"
+	_ "advent-of-code/internal/2018/DayFour"
+	_ "advent-of-code/internal/2018/DayOne"
+	_ "advent-of-code/internal/2018/DayThree"
+	_ "advent-of-code/internal/2018/DayTwo"
+)

internal/2020/DayEight/code.go

@@ -0,0 +1,94 @@
+package dayeight
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strconv"
+	"strings"
+)
+
+type instruction struct {
+	operation string
+	argument  int
+}
+
+func init() {
+	registry.Register("2020D8", ParseInput, PartOne, PartTwo)
+}
+
+func parseInstructions(data []string) []instruction {
+	instructions := make([]instruction, 0, len(data))
+	for _, line := range data {
+		line = strings.TrimSpace(line)
+		parts := strings.Fields(line)
+		if len(parts) != 2 {
+			continue
+		}
+		arg, _ := strconv.Atoi(parts[1])
+		instructions = append(instructions, instruction{operation: parts[0], argument: arg})
+	}
+	return instructions
+}
+
+func execute(instructions []instruction) (accumulator int, terminatedNormally bool) {
+	visited := make(map[int]bool)
+	accumulator = 0
+	pc := 0
+
+	for pc < len(instructions) {
+		if visited[pc] {
+			return accumulator, false
+		}
+		visited[pc] = true
+
+		instruction := instructions[pc]
+		switch instruction.operation {
+		case "acc":
+			accumulator += instruction.argument
+			pc++
+		case "jmp":
+			pc += instruction.argument
+		case "nop":
+			pc++
+		}
+	}
+
+	return accumulator, true
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	instructions := parseInstructions(data)
+	accumulator, _ := execute(instructions)
+	return accumulator
+}
+
+func PartTwo(data []string) int {
+	instructions := parseInstructions(data)
+
+	for idx := range instructions {
+		if instructions[idx].operation != "jmp" && instructions[idx].operation != "nop" {
+			continue
+		}
+
+		originalOperation := instructions[idx].operation
+		if originalOperation == "jmp" {
+			instructions[idx].operation = "nop"
+		} else {
+			instructions[idx].operation = "jmp"
+		}
+
+		accumulator, terminatedNormally := execute(instructions)
+		instructions[idx].operation = originalOperation
+
+		if terminatedNormally {
+			return accumulator
+		}
+	}
+
+	return 0
+}

internal/2020/DayEight/code_test.go

@@ -0,0 +1,31 @@
+package dayeight
+
+import "testing"
+
+var testInput = []string{
+	"nop +0",
+	"acc +1",
+	"jmp +4",
+	"acc +3",
+	"jmp -3",
+	"acc -99",
+	"acc +1",
+	"jmp -4",
+	"acc +6",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 5
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 8
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}

internal/2020/DayFive/code.go

@@ -39,9 +39,9 @@ func ParseInput(filepath string) []string {
 	return strings.Split(string(content), "\n")
 }
 
-func PartOne(input []string) int {
+func PartOne(data []string) int {
 	maxSeatID := 0
-	for _, pass := range input {
+	for _, pass := range data {
 		seatID := calculateSeatID(pass)
 		if seatID > maxSeatID {
 			maxSeatID = seatID
@@ -50,12 +50,12 @@ func PartOne(input []string) int {
 	return maxSeatID
 }
 
-func PartTwo(input []string) int {
+func PartTwo(data []string) int {
 	seatIDs := make(map[int]bool)
 	minSeatID := 1000
 	maxSeatID := 0
 
-	for _, pass := range input {
+	for _, pass := range data {
 		if len(pass) < 10 {
 			continue
 		}

internal/2020/DayFive/code_test.go

@@ -32,4 +32,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/DayFour/code.go

@@ -91,7 +91,7 @@ func PartTwo(data []string) int {
 			return false
 		}
 		for _, c := range value[1:] {
-			if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f')) {
+			if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
 				return false
 			}
 		}
@@ -151,4 +151,3 @@ func PartTwo(data []string) int {
 	}
 	return count
 }
-

internal/2020/DayFour/code_test.go

@@ -24,4 +24,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/DayOne/code.go

@@ -47,4 +47,3 @@ func PartTwo(data []int) int {
 	}
 	return 0
 }
-

internal/2020/DayOne/code_test.go

@@ -19,4 +19,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/DaySeven/code.go

@@ -0,0 +1,105 @@
+package dayseven
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	rulePattern      = regexp.MustCompile(`^(\w+ \w+) bags contain (.+)\.$`)
+	containedPattern = regexp.MustCompile(`(\d+) (\w+ \w+) bags?`)
+)
+
+type bagCount struct {
+	count int
+	bag   string
+}
+
+func init() {
+	registry.Register("2020D7", ParseInput, PartOne, PartTwo)
+}
+
+func buildForwardGraph(data []string) map[string][]bagCount {
+	forwardGraph := make(map[string][]bagCount)
+
+	for _, line := range data {
+		matches := rulePattern.FindStringSubmatch(line)
+		if len(matches) != 3 {
+			continue
+		}
+
+		containerBag := matches[1]
+		containedString := matches[2]
+
+		if containedString == "no other bags" {
+			forwardGraph[containerBag] = []bagCount{}
+			continue
+		}
+
+		containedMatches := containedPattern.FindAllStringSubmatch(containedString, -1)
+		for _, match := range containedMatches {
+			if len(match) >= 3 {
+				count, _ := strconv.Atoi(match[1])
+				containedBag := match[2]
+				forwardGraph[containerBag] = append(forwardGraph[containerBag], bagCount{count: count, bag: containedBag})
+			}
+		}
+	}
+
+	return forwardGraph
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	forwardGraph := buildForwardGraph(data)
+	reverseGraph := make(map[string][]string)
+
+	for container, contained := range forwardGraph {
+		for _, child := range contained {
+			reverseGraph[child.bag] = append(reverseGraph[child.bag], container)
+		}
+	}
+
+	visited := make(map[string]bool)
+	queue := reverseGraph["shiny gold"]
+
+	for len(queue) > 0 {
+		current := queue[0]
+		queue = queue[1:]
+
+		if visited[current] {
+			continue
+		}
+		visited[current] = true
+
+		for _, parent := range reverseGraph[current] {
+			if !visited[parent] {
+				queue = append(queue, parent)
+			}
+		}
+	}
+
+	return len(visited)
+}
+
+func PartTwo(data []string) int {
+	forwardGraph := buildForwardGraph(data)
+	var countIndividualBags func(string) int
+
+	countIndividualBags = func(bag string) int {
+		total := 0
+		for _, child := range forwardGraph[bag] {
+			total += child.count + child.count*countIndividualBags(child.bag)
+		}
+		return total
+	}
+
+	return countIndividualBags("shiny gold")
+}

internal/2020/DaySeven/code_test.go

@@ -0,0 +1,51 @@
+package dayseven
+
+import "testing"
+
+var testInput = []string{
+	"light red bags contain 1 bright white bag, 2 muted yellow bags.",
+	"dark orange bags contain 3 bright white bags, 4 muted yellow bags.",
+	"bright white bags contain 1 shiny gold bag.",
+	"muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.",
+	"shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.",
+	"dark olive bags contain 3 faded blue bags, 4 dotted black bags.",
+	"vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.",
+	"faded blue bags contain no other bags.",
+	"dotted black bags contain no other bags.",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 4
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	secondTestInput := []string{
+		"shiny gold bags contain 2 dark red bags.",
+		"dark red bags contain 2 dark orange bags.",
+		"dark orange bags contain 2 dark yellow bags.",
+		"dark yellow bags contain 2 dark green bags.",
+		"dark green bags contain 2 dark blue bags.",
+		"dark blue bags contain 2 dark violet bags.",
+		"dark violet bags contain no other bags.",
+	}
+
+	t.Run("First Example", func(t *testing.T) {
+		expected := 32
+		got := PartTwo(testInput)
+		if got != expected {
+			t.Errorf("PartTwo() = %d, want %d", got, expected)
+		}
+	})
+
+	t.Run("Second Example", func(t *testing.T) {
+		expected := 126
+		got := PartTwo(secondTestInput)
+		if got != expected {
+			t.Errorf("PartTwo() = %d, want %d", got, expected)
+		}
+	})
+}

internal/2020/DaySix/code.go

@@ -15,11 +15,11 @@ func ParseInput(filepath string) []string {
 	return strings.Split(strings.TrimSpace(string(content)), "\n")
 }
 
-func PartOne(input []string) int {
+func PartOne(data []string) int {
 	total := 0
 	groupAnswers := make(map[rune]bool)
 
-	for idx, line := range input {
+	for idx, line := range data {
 		if line != "" {
 			for _, char := range line {
 				if char >= 'a' && char <= 'z' {
@@ -28,7 +28,7 @@ func PartOne(input []string) int {
 			}
 		}
 
-		if line == "" || idx == len(input)-1 {
+		if line == "" || idx == len(data)-1 {
 			total += len(groupAnswers)
 			groupAnswers = make(map[rune]bool)
 		}
@@ -39,12 +39,12 @@ func PartOne(input []string) int {
 	return total
 }
 
-func PartTwo(input []string) int {
+func PartTwo(data []string) int {
 	total := 0
 	groupAnswers := make(map[rune]int)
 	groupSize := 0
 
-	for idx, line := range input {
+	for idx, line := range data {
 		if line != "" {
 			groupSize++
 			for _, char := range line {
@@ -54,7 +54,7 @@ func PartTwo(input []string) int {
 			}
 		}
 
-		if line == "" || idx == len(input)-1 {
+		if line == "" || idx == len(data)-1 {
 			for _, count := range groupAnswers {
 				if count == groupSize {
 					total++
@@ -67,4 +67,3 @@ func PartTwo(input []string) int {
 
 	return total
 }
-

internal/2020/DaySix/code_test.go

@@ -35,4 +35,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/DayThree/code.go

@@ -15,14 +15,14 @@ func ParseInput(filepath string) []string {
 	return strings.Split(string(content), "\n")
 }
 
-func PartOne(input []string) int {
+func PartOne(data []string) int {
 	trees := 0
 	column := 0
-	for row := range input {
-		if len(input[row]) == 0 {
+	for row := range data {
+		if len(data[row]) == 0 {
 			continue
 		}
-		if input[row][column%len(input[row])] == '#' {
+		if data[row][column%len(data[row])] == '#' {
 			trees++
 		}
 		column += 3
@@ -30,17 +30,17 @@ func PartOne(input []string) int {
 	return trees
 }
 
-func PartTwo(input []string) int {
+func PartTwo(data []string) int {
 	result := 1
 	slopes := [][]int{{1, 1}, {3, 1}, {5, 1}, {7, 1}, {1, 2}}
 	for _, slope := range slopes {
 		trees := 0
 		column := 0
-		for row := 0; row < len(input); row += slope[1] {
-			if len(input[row]) == 0 {
+		for row := 0; row < len(data); row += slope[1] {
+			if len(data[row]) == 0 {
 				continue
 			}
-			if input[row][column%len(input[row])] == '#' {
+			if data[row][column%len(data[row])] == '#' {
 				trees++
 			}
 			column += slope[0]
@@ -49,4 +49,3 @@ func PartTwo(input []string) int {
 	}
 	return result
 }
-

internal/2020/DayThree/code_test.go

@@ -31,4 +31,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/DayTwo/code.go

@@ -14,11 +14,8 @@ func init() {
 func ParseInput(filepath string) []string {
 	content, _ := os.ReadFile(filepath)
 	lines := strings.Split(string(content), "\n")
-	var data []string
-	for _, line := range lines {
-		data = append(data, line)
-	}
-	return data
+	data := make([]string, 0, len(lines))
+	return append(data, lines...)
 }
 
 func PartOne(data []string) int {
@@ -74,4 +71,3 @@ func PartTwo(data []string) int {
 	}
 	return valid
 }
-

internal/2020/DayTwo/code_test.go

@@ -23,4 +23,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2020/register.go

@@ -0,0 +1,12 @@
+package year2020
+
+import (
+	_ "advent-of-code/internal/2020/DayEight"
+	_ "advent-of-code/internal/2020/DayFive"
+	_ "advent-of-code/internal/2020/DayFour"
+	_ "advent-of-code/internal/2020/DayOne"
+	_ "advent-of-code/internal/2020/DaySeven"
+	_ "advent-of-code/internal/2020/DaySix"
+	_ "advent-of-code/internal/2020/DayThree"
+	_ "advent-of-code/internal/2020/DayTwo"
+)

internal/2021/DayFour/code.go

@@ -0,0 +1,155 @@
+package dayfour
+
+import (
+	"os"
+	"strconv"
+	"strings"
+
+	"advent-of-code/internal/registry"
+)
+
+const boardSize = 5
+
+func init() {
+	registry.Register("2021D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(strings.TrimSpace(string(content)), "\n")
+}
+
+type board struct {
+	numbers      [boardSize][boardSize]int
+	positionMap  map[int][2]int
+	rowCounts    [boardSize]int
+	columnCounts [boardSize]int
+	marked       map[int]bool
+	won          bool
+}
+
+func newBoard() board {
+	return board{
+		positionMap: make(map[int][2]int, boardSize*boardSize),
+		marked:      make(map[int]bool),
+	}
+}
+
+func parseBoards(lines []string) []board {
+	var boards []board
+	current := newBoard()
+	row := 0
+
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			if row == boardSize {
+				boards = append(boards, current)
+				current = newBoard()
+				row = 0
+			}
+			continue
+		}
+
+		fields := strings.Fields(line)
+		for column, field := range fields {
+			number, _ := strconv.Atoi(field)
+			current.numbers[row][column] = number
+			current.positionMap[number] = [2]int{row, column}
+		}
+		row++
+	}
+
+	if row == boardSize {
+		boards = append(boards, current)
+	}
+
+	return boards
+}
+
+func (b *board) mark(number int) bool {
+	if b.won {
+		return false
+	}
+
+	position, exists := b.positionMap[number]
+	if !exists {
+		return false
+	}
+
+	b.marked[number] = true
+	row, column := position[0], position[1]
+	b.rowCounts[row]++
+	b.columnCounts[column]++
+
+	if b.rowCounts[row] == boardSize || b.columnCounts[column] == boardSize {
+		b.won = true
+		return true
+	}
+
+	return false
+}
+
+func (b *board) sumUnmarked() int {
+	sum := 0
+	for row := range boardSize {
+		for column := range boardSize {
+			number := b.numbers[row][column]
+			if !b.marked[number] {
+				sum += number
+			}
+		}
+	}
+	return sum
+}
+
+func parseNumbers(line string) []int {
+	numbersStr := strings.Split(line, ",")
+	numbers := make([]int, 0, len(numbersStr))
+	for _, numStr := range numbersStr {
+		num, _ := strconv.Atoi(numStr)
+		numbers = append(numbers, num)
+	}
+	return numbers
+}
+
+func PartOne(data []string) int {
+	numbers := parseNumbers(data[0])
+	boards := parseBoards(data[1:])
+
+	for _, number := range numbers {
+		for idx := range boards {
+			if boards[idx].mark(number) {
+				return boards[idx].sumUnmarked() * number
+			}
+		}
+	}
+
+	return 0
+}
+
+func PartTwo(data []string) int {
+	numbers := parseNumbers(data[0])
+	boards := parseBoards(data[1:])
+
+	wonCount := 0
+	totalBoards := len(boards)
+	var lastWinner *board
+	var lastNumber int
+
+	for _, number := range numbers {
+		for idx := range boards {
+			if boards[idx].mark(number) {
+				wonCount++
+				lastWinner = &boards[idx]
+				lastNumber = number
+
+				if wonCount == totalBoards {
+					return lastWinner.sumUnmarked() * lastNumber
+				}
+			}
+		}
+	}
+
+	return 0
+}

internal/2021/DayFour/code_test.go

@@ -0,0 +1,41 @@
+package dayfour
+
+import "testing"
+
+var testInput = []string{
+	"7,4,9,5,11,17,23,2,0,14,21,24,10,16,13,6,15,25,12,22,18,20,8,19,3,26,1",
+	"",
+	"22 13 17 11  0",
+	" 8  2 23  4 24",
+	"21  9 14 16  7",
+	" 6 10  3 18  5",
+	" 1 12 20 15 19",
+	"",
+	" 3 15  0  2 22",
+	" 9 18 13 17  5",
+	"19  8  7 25 23",
+	"20 11 10 24  4",
+	"14 21 16 12  6",
+	"",
+	"14 21 17 24  4",
+	"10 16 15  9 19",
+	"18  8 23 26 20",
+	"22 11 13  6  5",
+	" 2  0 12  3  7",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 4512
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 1924
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2021/DayOne/code.go

@@ -40,4 +40,3 @@ func PartTwo(data []int) int {
 	}
 	return count
 }
-

internal/2021/DayOne/code_test.go

@@ -19,4 +19,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2021/DayThree/code.go

@@ -114,4 +114,3 @@ func PartTwo(data []string) int {
 
 	return oxygenRating * co2Rating
 }
-

internal/2021/DayThree/code_test.go

@@ -32,4 +32,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2021/DayTwo/code.go

@@ -57,4 +57,3 @@ func PartTwo(data []string) int {
 	}
 	return horizontal * depth
 }
-

internal/2021/DayTwo/code_test.go

@@ -26,4 +26,3 @@ func TestPartTwo(t *testing.T) {
 		t.Errorf("PartTwo() = %d, want %d", got, expected)
 	}
 }
-

internal/2021/register.go

@@ -0,0 +1,8 @@
+package year2021
+
+import (
+	_ "advent-of-code/internal/2021/DayFour"
+	_ "advent-of-code/internal/2021/DayOne"
+	_ "advent-of-code/internal/2021/DayThree"
+	_ "advent-of-code/internal/2021/DayTwo"
+)

internal/2022/DayFour/code.go

@@ -0,0 +1,54 @@
+package dayfour
+
+import (
+	"advent-of-code/internal/registry"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2022D4", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	count := 0
+	for _, line := range data {
+		parts := strings.Split(line, ",")
+
+		var firstRangeStart, firstRangeEnd, secondRangeStart, secondRangeEnd int
+		fmt.Sscanf(parts[0], "%d-%d", &firstRangeStart, &firstRangeEnd)
+		fmt.Sscanf(parts[1], "%d-%d", &secondRangeStart, &secondRangeEnd)
+
+		minStart := min(firstRangeStart, secondRangeStart)
+		maxEnd := max(firstRangeEnd, secondRangeEnd)
+
+		if (minStart == firstRangeStart && maxEnd == firstRangeEnd) || (minStart == secondRangeStart && maxEnd == secondRangeEnd) {
+			count++
+		}
+	}
+
+	return count
+}
+
+func PartTwo(data []string) int {
+	count := 0
+	for _, line := range data {
+		parts := strings.Split(line, ",")
+
+		var firstRangeStart, firstRangeEnd, secondRangeStart, secondRangeEnd int
+		fmt.Sscanf(parts[0], "%d-%d", &firstRangeStart, &firstRangeEnd)
+		fmt.Sscanf(parts[1], "%d-%d", &secondRangeStart, &secondRangeEnd)
+
+		if firstRangeStart <= secondRangeEnd && secondRangeStart <= firstRangeEnd {
+			count++
+		}
+	}
+
+	return count
+}

internal/2022/DayFour/code_test.go

@@ -0,0 +1,28 @@
+package dayfour
+
+import "testing"
+
+var testInput = []string{
+	"2-4,6-8",
+	"2-3,4-5",
+	"5-7,7-9",
+	"2-8,3-7",
+	"6-6,4-6",
+	"2-6,4-8",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 2
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 4
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2022/DayOne/code.go

@@ -0,0 +1,60 @@
+package dayone
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+func init() {
+	registry.Register("2022D1", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	maxCalories, currentElf := 0, 0
+
+	for _, line := range data {
+		if line == "" {
+			maxCalories = max(maxCalories, currentElf)
+			currentElf = 0
+			continue
+		}
+		val, _ := strconv.Atoi(line)
+		currentElf += val
+	}
+
+	return max(maxCalories, currentElf)
+}
+
+func PartTwo(data []string) int {
+	var totals []int
+	currentElf := 0
+
+	for _, line := range data {
+		if line == "" {
+			totals = append(totals, currentElf)
+			currentElf = 0
+			continue
+		}
+
+		val, _ := strconv.Atoi(line)
+		currentElf += val
+	}
+	totals = append(totals, currentElf)
+
+	slices.Sort(totals)
+	slices.Reverse(totals)
+
+	sum := 0
+	for _, val := range totals[:min(3, len(totals))] {
+		sum += val
+	}
+	return sum
+}

internal/2022/DayOne/code_test.go

@@ -0,0 +1,36 @@
+package dayone
+
+import "testing"
+
+var testInput = []string{
+	"1000",
+	"2000",
+	"3000",
+	"",
+	"4000",
+	"",
+	"5000",
+	"6000",
+	"",
+	"7000",
+	"8000",
+	"9000",
+	"",
+	"10000",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 24000
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 45000
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2022/DayThree/code.go

@@ -0,0 +1,87 @@
+package daythree
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2022D3", ParseInput, PartOne, PartTwo)
+}
+
+func buildItemSet(items string) map[rune]bool {
+	itemSet := make(map[rune]bool)
+	for _, item := range items {
+		itemSet[item] = true
+	}
+	return itemSet
+}
+
+func findCommonItem(itemSet map[rune]bool, items string) rune {
+	for _, item := range items {
+		if itemSet[item] {
+			return item
+		}
+	}
+	return 0
+}
+
+func findIntersection(itemSet map[rune]bool, items string) map[rune]bool {
+	intersection := make(map[rune]bool)
+	for _, item := range items {
+		if itemSet[item] {
+			intersection[item] = true
+		}
+	}
+	return intersection
+}
+
+func getItemPriority(item rune) int {
+	if item >= 'a' && item <= 'z' {
+		return int(item - 'a' + 1)
+	}
+	if item >= 'A' && item <= 'Z' {
+		return int(item - 'A' + 27)
+	}
+	return 0
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(string(content), "\n")
+}
+
+func PartOne(data []string) int {
+	totalPriority := 0
+	for _, rucksack := range data {
+		compartmentSize := len(rucksack) / 2
+		firstCompartment := rucksack[:compartmentSize]
+		secondCompartment := rucksack[compartmentSize:]
+
+		firstCompartmentItems := buildItemSet(firstCompartment)
+		commonItem := findCommonItem(firstCompartmentItems, secondCompartment)
+		totalPriority += getItemPriority(commonItem)
+	}
+
+	return totalPriority
+}
+
+func PartTwo(data []string) int {
+	totalPriority := 0
+	for i := 0; i < len(data); i += 3 {
+		if i+2 >= len(data) {
+			break
+		}
+		firstRucksack := data[i]
+		secondRucksack := data[i+1]
+		thirdRucksack := data[i+2]
+
+		firstRucksackItems := buildItemSet(firstRucksack)
+		commonInFirstTwo := findIntersection(firstRucksackItems, secondRucksack)
+		badge := findCommonItem(commonInFirstTwo, thirdRucksack)
+		totalPriority += getItemPriority(badge)
+	}
+
+	return totalPriority
+}

internal/2022/DayThree/code_test.go

@@ -0,0 +1,28 @@
+package daythree
+
+import "testing"
+
+var testInput = []string{
+	"vJrwpWtwJgWrhcsFMMfFFhFp",
+	"jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
+	"PmmdzqPrVvPwwTWBwg",
+	"wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
+	"ttgJtRGJQctTZtZT",
+	"CrZsJsPPZsGzwwsLwLmpwMDw",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 157
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 70
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}

internal/2022/DayTwo/code.go

@@ -0,0 +1,62 @@
+package daytwo
+
+import (
+	"advent-of-code/internal/registry"
+	"os"
+	"strings"
+)
+
+func init() {
+	registry.Register("2022D2", ParseInput, PartOne, PartTwo)
+}
+
+func ParseInput(filepath string) []string {
+	content, _ := os.ReadFile(filepath)
+	return strings.Split(strings.Trim(string(content), "\n"), "\n")
+}
+
+func PartOne(data []string) int {
+	totalScore := 0
+	for _, line := range data {
+		opponent := line[0]
+		me := line[2]
+
+		shapeScore := int(me - 'X' + 1)
+
+		var outcomeScore int
+		if (opponent == 'A' && me == 'Y') || (opponent == 'B' && me == 'Z') || (opponent == 'C' && me == 'X') {
+			outcomeScore = 6
+		} else if (opponent == 'A' && me == 'X') || (opponent == 'B' && me == 'Y') || (opponent == 'C' && me == 'Z') {
+			outcomeScore = 3
+		} else {
+			outcomeScore = 0
+		}
+
+		totalScore += shapeScore + outcomeScore
+	}
+	return totalScore
+}
+
+func PartTwo(data []string) int {
+	totalScore := 0
+	for _, line := range data {
+		opponent := line[0]
+		outcome := line[2]
+
+		var me byte
+		switch outcome {
+		case 'Y':
+			me = 'X' + (opponent - 'A')
+		case 'Z':
+			me = 'X' + ((opponent-'A')+1)%3
+		default:
+			me = 'X' + ((opponent-'A')+2)%3
+		}
+
+		shapeScore := int(me - 'X' + 1)
+		outcomeScore := int(outcome-'X') * 3
+
+		totalScore += shapeScore + outcomeScore
+	}
+	return totalScore
+}

internal/2022/DayTwo/code_test.go

@@ -0,0 +1,25 @@
+package daytwo
+
+import "testing"
+
+var testInput = []string{
+	"A Y",
+	"B X",
+	"C Z",
+}
+
+func TestPartOne(t *testing.T) {
+	expected := 15
+	got := PartOne(testInput)
+	if got != expected {
+		t.Errorf("PartOne() = %d, want %d", got, expected)
+	}
+}
+
+func TestPartTwo(t *testing.T) {
+	expected := 12
+	got := PartTwo(testInput)
+	if got != expected {
+		t.Errorf("PartTwo() = %d, want %d", got, expected)
+	}
+}