4,5

cmd/five/main.go

···
+package main
+
+import (
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type IDRange struct {
+	first int
+	last  int
+}
+
+type DayFive struct {
+	freshIds []IDRange
+	tocheck  []int
+}
+
+func (d *DayFive) ParseInput(input string) error {
+	for line := range strings.SplitSeq(strings.TrimSpace(input), "\n") {
+		line = strings.TrimSpace(line)
+		if strings.Contains(line, "-") {
+			splits := strings.Split(line, "-")
+			first, _ := strconv.Atoi(splits[0])
+			last, _ := strconv.Atoi(splits[1])
+			d.freshIds = append(d.freshIds, IDRange{first, last})
+		} else if line == "" {
+			continue
+		} else {
+			ingredient, _ := strconv.Atoi(line)
+			d.tocheck = append(d.tocheck, ingredient)
+		}
+	}
+	return nil
+}
+
+func (d *DayFive) Part1() (int, error) {
+	count := 0
+	for _, i := range d.tocheck {
+		for _, idrange := range d.freshIds {
+			if i >= idrange.first && i <= idrange.last {
+				count++
+				break
+			}
+		}
+	}
+	return count, nil
+}
+
+func (d *DayFive) Part2() (int, error) {
+	count := 0
+
+	slices.SortFunc(d.freshIds, func(a, b IDRange) int {
+		return a.first - b.first
+	})
+	var combinedFreshIds []IDRange
+	last := d.freshIds[0]
+	for _, current := range d.freshIds {
+		if current.first <= last.last {
+			last.last = max(last.last, current.last)
+		} else {
+			combinedFreshIds = append(combinedFreshIds, last)
+			last = current
+		}
+	}
+	// combine one last time
+	combinedFreshIds = append(combinedFreshIds, last)
+
+	for _, idrange := range combinedFreshIds {
+		numInRange := idrange.last - idrange.first + 1
+		fmt.Println(numInRange)
+		count += numInRange
+	}
+	return count, nil
+}
+
+func main() {
+	puzzle.Run(5, &DayFive{})
+}

cmd/five/main_test.go

···
+package main
+
+import (
+	"testing"
+)
+
+const testInput = `3-5
+10-14
+16-20
+12-18
+
+1
+5
+8
+11
+17
+32
+`
+
+func TestPart1(t *testing.T) {
+	d := &DayFive{}
+	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 := 3
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	d := &DayFive{}
+	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 := 14
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}

cmd/four/main.go

···
+package main
+
+import (
+	"strings"
+
+	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
+)
+
+type PaperRoll struct {
+	row       int
+	column    int
+	left      int
+	right     int
+	up        int
+	upLeft    int
+	upRight   int
+	down      int
+	downLeft  int
+	downRight int
+}
+
+func (p *PaperRoll) CanAccess() bool {
+	return p.left+p.right+p.up+p.down+p.upLeft+p.upRight+p.downLeft+p.downRight < 4
+}
+
+type DayFour struct {
+	grid  []string
+	rolls []PaperRoll
+}
+
+const rollchar byte = '@'
+
+func getCell(grid []string, i, j int) int {
+	if i < 0 || i >= len(grid) || j < 0 || j >= len(grid[i]) {
+		return 0
+	}
+	if grid[i][j] == rollchar {
+		return 1
+	}
+	return 0
+}
+
+func (d *DayFour) ParseInputArr(input []string) {
+	for i, line := range d.grid {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		for j, ch := range line {
+			if ch == rune(rollchar) {
+				p := PaperRoll{
+					row:       i,
+					column:    j,
+					left:      getCell(d.grid, i, j-1),
+					right:     getCell(d.grid, i, j+1),
+					up:        getCell(d.grid, i-1, j),
+					upLeft:    getCell(d.grid, i-1, j-1),
+					upRight:   getCell(d.grid, i-1, j+1),
+					down:      getCell(d.grid, i+1, j),
+					downLeft:  getCell(d.grid, i+1, j-1),
+					downRight: getCell(d.grid, i+1, j+1),
+				}
+				d.rolls = append(d.rolls, p)
+			}
+		}
+	}
+}
+
+func (d *DayFour) ParseInput(input string) error {
+	d.grid = strings.Split(strings.TrimSpace(input), "\n")
+	d.ParseInputArr(d.grid)
+	return nil
+}
+
+func (d *DayFour) Part1() (int, error) {
+	count := 0
+	for _, roll := range d.rolls {
+		if roll.CanAccess() {
+			count++
+		}
+	}
+	return count, nil
+}
+
+func (d *DayFour) Part2() (int, error) {
+	count := 0
+	changed := true
+
+	for changed {
+		changed = false
+		d.rolls = nil
+		d.ParseInputArr(d.grid)
+
+		for _, roll := range d.rolls {
+			if roll.CanAccess() {
+				d.grid[roll.row] = d.grid[roll.row][:roll.column] + "." + d.grid[roll.row][roll.column+1:]
+				count++
+				changed = true
+			}
+		}
+	}
+	return count, nil
+}
+
+func main() {
+	puzzle.Run(4, &DayFour{})
+}

cmd/four/main_test.go

···
+package main
+
+import (
+	"testing"
+)
+
+const testInput = `..@@.@@@@.
+@@@.@.@.@@
+@@@@@.@.@@
+@.@@@@..@.
+@@.@@@@.@@
+.@@@@@@@.@
+.@.@.@.@@@
+@.@@@.@@@@
+.@@@@@@@@.
+@.@.@@@.@.
+`
+
+func TestPart1(t *testing.T) {
+	d := &DayFour{}
+	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 := 13
+	if got != want {
+		t.Errorf("Part1() = %d, want %d", got, want)
+	}
+}
+
+func TestPart2(t *testing.T) {
+	d := &DayFour{}
+	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 := 43
+	if got != want {
+		t.Errorf("Part2() = %d, want %d", got, want)
+	}
+}

newday.sh

···
 package main
 
 import (
+	"strings"
+
 	"tangled.org/evan.jarrett.net/aoc2025/internal/puzzle"
 )
 
···
 }
 
 func (d *Day${DAY_WORD_CAP}) ParseInput(input string) error {
-	// TODO: parse input
+	for line := range strings.SplitSeq(strings.TrimSpace(input), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		// TODO: parse line
+	}
 	return nil
 }