day 2, day 3

cmd/one/main.go

···
 
 import (
 	"fmt"
+	"log/slog"
 	"strconv"
 	"strings"
 
···
 func (d *DayOne) Part1() (int, error) {
 	position := 50
 	zeroCount := 0
-	fmt.Printf("The dial starts by pointing at %d.\n", position)
+	slog.Debug("The dial starts by pointing at", "position", position)
 
 	for _, rot := range d.rotations {
 		newPosition, _, err := Rotate(position, rot)
 		if err != nil {
 			return 0, err
 		}
-		fmt.Printf("The dial is rotated %d to point at %d.\n", rot, newPosition)
+		slog.Debug("The dial is rotated", "rotation", rot, "newPosition", newPosition)
 		position = newPosition
 		if position == 0 {
 			zeroCount++
 		}
 	}
 
-	fmt.Printf("Final position: %d\n", position)
+	slog.Debug("Final position", "position", position)
 	return zeroCount, nil
 }
 
 func (d *DayOne) Part2() (int, error) {
 	position := 50
 	zeroCount := 0
-	fmt.Printf("The dial starts by pointing at %d.\n", position)
+	slog.Debug("The dial starts by pointing at", "position", position)
 
 	for _, rot := range d.rotations {
 		newPosition, passes, err := Rotate(position, rot)
 		if err != nil {
 			return 0, err
 		}
-		fmt.Printf("The dial is rotated %d to point at %d.", rot, newPosition)
+		slog.Debug("The dial is rotated", "rotation", rot, "newPosition", newPosition, "passes", passes)
 		if passes > 0 {
-			if newPosition != 0 || passes > 2 {
-				fmt.Printf(" during this rotation, it points at 0 %d times.", passes)
-			}
 			zeroCount += passes
 		}
-		fmt.Println()
-		fmt.Printf("count is now: %d\n", zeroCount)
+		slog.Debug("count updated", "zeroCount", zeroCount)
 		position = newPosition
 	}
 
-	fmt.Printf("Final position: %d\n", position)
+	slog.Debug("Final position", "position", position)
 	return zeroCount, nil
 }
 

cmd/one/main_test.go

···
 package main
 
 import (
+	"os"
 	"testing"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal"
 )
 
 const testInput = `L68
···
 		input string
 		want  int
 	}{
-		{"R555", 6}, 
+		{"R555", 6},
 		{"L432", 4},
 		{"L555", 6},
 	}
···
 		position  int
 		amount    int
 		wantPos   int
-		wantCount int 
+		wantCount int
 	}{
 		// Starting at 0, no crossing
 		{"from 0, R50", 0, 50, 50, 0},
···
 		})
 	}
 }
+
+// getRealInput loads the real puzzle input, caching it to a file to avoid
+// repeated network calls during benchmarks.
+func getRealInput(b *testing.B) string {
+	b.Helper()
+	const cacheFile = "testdata/input.txt"
+
+	// Try to read from cache first
+	if data, err := os.ReadFile(cacheFile); err == nil {
+		return string(data)
+	}
+
+	// Fetch from AOC and cache it
+	input, err := internal.GetInput(1)
+	if err != nil {
+		b.Skipf("Could not fetch real input: %v", err)
+	}
+
+	// Cache for future runs
+	_ = os.MkdirAll("testdata", 0755)
+	_ = os.WriteFile(cacheFile, []byte(input), 0644)
+
+	return input
+}
+
+func BenchmarkPart1(b *testing.B) {
+	input := getRealInput(b)
+
+	d := &DayOne{}
+	if err := d.ParseInput(input); err != nil {
+		b.Fatalf("ParseInput failed: %v", err)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		d.Part1()
+	}
+}
+
+func BenchmarkPart2(b *testing.B) {
+	input := getRealInput(b)
+
+	d := &DayOne{}
+	if err := d.ParseInput(input); err != nil {
+		b.Fatalf("ParseInput failed: %v", err)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		d.Part2()
+	}
+}

cmd/three/main.go

···
+package main
+
+import (
+	"log/slog"
+	"strings"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type DayThree struct {
+	batteries []string
+}
+
+func (d *DayThree) ParseInput(input string) error {
+	for line := range strings.SplitSeq(strings.TrimSpace(input), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		d.batteries = append(d.batteries, line)
+	}
+	return nil
+}
+
+// exactly 2
+func (d *DayThree) Part1() (int, error) {
+	sum := 0
+	for _, battery := range d.batteries {
+		first := 0
+		second := 0
+		for i, ch := range battery {
+			digit := int(ch - '0')
+			if digit > first && i < len(battery)-1 {
+				first = digit
+				second = 0 // reset our second digit since it needs to come after the first
+			} else if digit > second {
+				second = digit
+			}
+		}
+		combined := first*10 + second
+		slog.Debug("joltage", "largest", combined, "first", first, "second", second)
+		sum += combined
+	}
+	return sum, nil
+}
+
+// exactly 12
+func (d *DayThree) Part2() (int, error) {
+	max := 12
+	sum := 0
+	for _, battery := range d.batteries {
+		arr := make([]int, max)
+		for i, ch := range battery {
+			digit := int(ch - '0')
+			for j := range max {
+				if digit > arr[j] && i < len(battery)-(max-1-j) {
+					arr[j] = digit
+					clear(arr[j+1:])
+					break
+				}
+			}
+		}
+		combined := 0
+		for _, digit := range arr {
+			combined = combined*10 + digit
+		}
+		slog.Debug("joltage", "largest", combined)
+		sum += combined
+	}
+	return sum, nil
+}
+
+func main() {
+	puzzle.Run(3, &DayThree{})
+}

cmd/three/main_test.go

···
+package main
+
+import (
+	"testing"
+)
+
+const testInput = `987654321111111
[phone]
[phone]
[phone]
+`
+
+func TestPart1(t *testing.T) {
+	// slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+	// 	Level: slog.LevelDebug,
+	// })))
+	d := &DayThree{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part1()
+	if err != nil {
+		t.Fatalf("Part1 failed: %v", err)
+	}
+
+	want := 357
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	// slog.SetDefault(slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+	// 	Level: slog.LevelDebug,
+	// })))
+	d := &DayThree{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part2()
+	if err != nil {
+		t.Fatalf("Part2 failed: %v", err)
+	}
+
+	want := 3121910778619 // TODO: set expected value
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}

cmd/two/main.go

···
+package main
+
+import (
+	"log/slog"
+	"strconv"
+	"strings"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type ProductId struct {
+	firstId int
+	lastId  int
+}
+
+type DayTwo struct {
+	productIds []ProductId
+}
+
+func (d *DayTwo) ParseInput(input string) error {
+	for productId := range strings.SplitSeq(strings.TrimSpace(input), ",") {
+		productId = strings.TrimSpace(productId)
+		if productId == "" {
+			continue
+		}
+		parts := strings.Split(productId, "-")
+		first, _ := strconv.Atoi(parts[0])
+		last, _ := strconv.Atoi(parts[1])
+
+		product := ProductId{
+			firstId: first,
+			lastId:  last,
+		}
+
+		d.productIds = append(d.productIds, product)
+	}
+	return nil
+}
+
+func findPattern(productId int, j int) int {
+	s := strconv.Itoa(productId)
+	n := len(s)
+	if n%j == 0 {
+		piece := s[:n/j]
+		if strings.Repeat(piece, j) == s {
+			slog.Debug("found invalid ID", "id", s)
+			return productId
+		}
+	}
+	return 0
+}
+
+// find ids that have a repeating pattern. 55 = 5 twice, 6464 = 64 twice.
+func (d *DayTwo) Part1() (int, error) {
+	sum := 0
+	for _, product := range d.productIds {
+		for i := product.firstId; i <= product.lastId; i++ {
+			sum += findPattern(i, 2)
+		}
+	}
+
+	return sum, nil
+}
+
+func (d *DayTwo) Part2() (int, error) {
+	sum := 0
+	for _, product := range d.productIds {
+		for i := product.firstId; i <= product.lastId; i++ {
+			s := strconv.Itoa(i)
+			n := len(s)
+			for j := 2; j <= n; j++ {
+				if result := findPattern(i, j); result > 0 {
+					sum += result
+					break
+				}
+			}
+		}
+	}
+
+	return sum, nil
+}
+
+func main() {
+	puzzle.Run(2, &DayTwo{})
+}

cmd/two/main_test.go

···
+package main
+
+import (
+	"os"
+	"testing"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal"
+)
+
+const testInput = `11-22,95-115,998-1012,1188511880-1188511890,222220-222224,1698522-1698528,446443-446449,38593856-38593862,565653-565659,824824821-824824827,2121212118-2121212124`
+
+func TestPart1(t *testing.T) {
+	d := &DayTwo{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part1()
+	if err != nil {
+		t.Fatalf("Part1 failed: %v", err)
+	}
+
+	want := 1227775554
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	d := &DayTwo{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part2()
+	if err != nil {
+		t.Fatalf("Part2 failed: %v", err)
+	}
+
+	want := 4174379265
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}
+
+// getRealInput loads the real puzzle input, caching it to a file to avoid
+// repeated network calls during benchmarks.
+func getRealInput(b *testing.B) string {
+	b.Helper()
+	const cacheFile = "testdata/input.txt"
+
+	// Try to read from cache first
+	if data, err := os.ReadFile(cacheFile); err == nil {
+		return string(data)
+	}
+
+	// Fetch from AOC and cache it
+	input, err := internal.GetInput(2)
+	if err != nil {
+		b.Skipf("Could not fetch real input: %v", err)
+	}
+
+	// Cache for future runs
+	_ = os.MkdirAll("testdata", 0755)
+	_ = os.WriteFile(cacheFile, []byte(input), 0644)
+
+	return input
+}
+
+func BenchmarkPart1(b *testing.B) {
+	input := getRealInput(b)
+
+	d := &DayTwo{}
+	if err := d.ParseInput(input); err != nil {
+		b.Fatalf("ParseInput failed: %v", err)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		d.Part1()
+	}
+}
+
+func BenchmarkPart2(b *testing.B) {
+	input := getRealInput(b)
+
+	d := &DayTwo{}
+	if err := d.ParseInput(input); err != nil {
+		b.Fatalf("ParseInput failed: %v", err)
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		d.Part2()
+	}
+}

newday.sh

···
 
 set -e
 
-if [ -z "$1" ]; then
-    echo "Usage: $0 <day>"
-    echo "Example: $0 5"
+# Determine current day based on EST timezone (puzzles unlock at midnight EST)
+EST_DAY=$(TZ="America/New_York" date +%-d)
+EST_MONTH=$(TZ="America/New_York" date +%-m)
+
+if [ "$EST_MONTH" -ne 12 ]; then
+    echo "Error: Advent of Code runs in December"
     exit 1
 fi
 
-DAY=$1
-
-if ! [[ "$DAY" =~ ^[0-9]+$ ]] || [ "$DAY" -lt 1 ] || [ "$DAY" -gt 12 ]; then
-    echo "Error: Day must be a number between 1 and 12"
+if [ "$EST_DAY" -gt 12 ]; then
+    echo "Error: This event only has 12 days (current EST day: $EST_DAY)"
     exit 1
 fi
 
-# Check if the puzzle is available (unlocks at midnight EST / 11pm CST)
-EST_DAY=$(TZ="America/New_York" date +%-d)
-EST_MONTH=$(TZ="America/New_York" date +%-m)
-EST_YEAR=$(TZ="America/New_York" date +%Y)
-
-if [ "$EST_YEAR" -eq 2025 ] && [ "$EST_MONTH" -eq 12 ]; then
-    if [ "$DAY" -gt "$EST_DAY" ]; then
-        echo "Error: Day $DAY puzzle not yet available."
-        echo "Puzzles unlock at midnight EST (11pm CST)."
-        echo "Current EST date: December $EST_DAY, 2025"
-        exit 1
-    fi
-fi
+DAY=$EST_DAY
 
 declare -a WORDS=("" "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten"
                   "eleven" "twelve")
···
 	puzzle.Run($DAY, &Day${DAY_WORD_CAP}{})
 }
 EOF
+    cat > "$CMD_DIR/main_test.go" << EOF
+package main
+
+import (
+	"testing"
+)
+
+const testInput = \`\`
+
+func TestPart1(t *testing.T) {
+	d := &Day${DAY_WORD_CAP}{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part1()
+	if err != nil {
+		t.Fatalf("Part1 failed: %v", err)
+	}
+
+	want := 0 // TODO: set expected value
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	d := &Day${DAY_WORD_CAP}{}
+	if err := d.ParseInput(testInput); err != nil {
+		t.Fatalf("ParseInput failed: %v", err)
+	}
+
+	got, err := d.Part2()
+	if err != nil {
+		t.Fatalf("Part2 failed: %v", err)
+	}
+
+	want := 0 // TODO: set expected value
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}
+EOF
     echo "Created $CMD_DIR/main.go"
+    echo "Created $CMD_DIR/main_test.go"
 fi