2021 day21, caught up! what a great problem today, so simple but fun to solve

2021/day21/main.go

@@ -0,0 +1,160 @@
+package main
+
+import (
+	_ "embed"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+//go:embed input.txt
+var input string
+
+func init() {
+	// do this in init (not main) so test file has same input
+	input = strings.TrimRight(input, "\n")
+	if len(input) == 0 {
+		panic("empty input.txt file")
+	}
+}
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	flag.Parse()
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(input)
+		util.CopyToClipboard(fmt.Sprintf("%v", ans))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(input)
+		util.CopyToClipboard(fmt.Sprintf("%v", ans))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	positions := parseInput(input)
+
+	// die, two pawns, circular track w/ 10 spaces (1-10)
+
+	// players take turns
+	// roll die 3 times, take sum
+	// move forward that number of spaces
+	// increase score by space they stop on
+	// game ends when someone has 1000 points
+
+	// deterministic die, 100 sided, rolls 1, then 2, 3, 4, 5, 6, etc
+	die := 0 // starts at zero, first time it rolls will produce a 1
+	isPlayer1sTurn := true
+	var scores [2]int
+	var rolls int
+	for scores[0] < 1000 && scores[1] < 1000 {
+		var threeRolls int
+		for i := 0; i < 3; i++ {
+			rolls++
+			die++
+			if die == 101 {
+				die = 1
+			}
+			threeRolls += die
+		}
+
+		if isPlayer1sTurn {
+			positions[0] += threeRolls
+			for positions[0] > 10 {
+				positions[0] -= 10
+			}
+			scores[0] += positions[0]
+		} else {
+			positions[1] += threeRolls
+			for positions[1] > 10 {
+				positions[1] -= 10
+			}
+			scores[1] += positions[1]
+		}
+		// switch turns
+		isPlayer1sTurn = !isPlayer1sTurn
+	}
+
+	loser := scores[0]
+	if scores[1] < 1000 {
+		loser = scores[1]
+	}
+
+	// final answer is the losing player's score TIMES number of times the die was rolled
+	return loser * rolls
+}
+
+func part2(input string) int64 {
+	// who wins in more universes
+	// dirac die, 3 sided, splits into 3 copies, one for each result, on EVERY roll
+	positions := parseInput(input)
+	w1, w2 := play([2]int{positions[0], positions[1]}, [2]int{}, 3, true, map[string][2]int64{})
+
+	if w1 > w2 {
+		return w1
+	}
+	return w2
+}
+
+func play(positions, scores [2]int, rollsLeftInTurn int, isPlayer1sTurn bool, memo map[string][2]int64) (wins1, wins2 int64) {
+	key := fmt.Sprint(positions, scores, rollsLeftInTurn, isPlayer1sTurn)
+	if res, ok := memo[key]; ok {
+		return res[0], res[1]
+	}
+
+	// NOTE 0-indexed array, so player 2 is at index 1...
+	playerIndex := 1
+	if isPlayer1sTurn {
+		playerIndex = 0
+	}
+
+	scoresCopy := [2]int{scores[0], scores[1]}
+	if rollsLeftInTurn == 0 {
+		scoresCopy[playerIndex] += positions[playerIndex]
+		// TERMINATION CASE
+		if scoresCopy[playerIndex] >= 21 {
+			if playerIndex == 0 {
+				return 1, 0
+			}
+			return 0, 1
+		}
+
+		isPlayer1sTurn = !isPlayer1sTurn
+		rollsLeftInTurn = 3
+		// update playerIndex because they're switching now! (not getting that hour of my life back...)
+		playerIndex++
+		playerIndex %= 2
+	}
+
+	for roll := 1; roll <= 3; roll++ {
+		// recurse with a given roll
+		// copy positions so each recurse gets its own copy
+		positionsCopy := [2]int{positions[0], positions[1]}
+		positionsCopy[playerIndex] += roll
+		if positionsCopy[playerIndex] > 10 {
+			positionsCopy[playerIndex] -= 10
+		}
+		r1, r2 := play(positionsCopy, scoresCopy, rollsLeftInTurn-1, isPlayer1sTurn, memo)
+		wins1 += r1
+		wins2 += r2
+	}
+
+	memo[key] = [2]int64{wins1, wins2}
+	return wins1, wins2
+}
+
+func parseInput(input string) (ans []int) {
+	for _, line := range strings.Split(input, "\n") {
+		// Player 1 starting position: 5
+		var player, startingPosition int
+		fmt.Sscanf(line, "Player %d starting position: %d", &player, &startingPosition)
+		ans = append(ans, startingPosition)
+	}
+	return ans
+}

2021/day21/main_test.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"testing"
+)
+
+var example = `Player 1 starting position: 4
+Player 2 starting position: 8`
+
+func Test_part1(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  int
+	}{
+		{
+			name:  "example",
+			input: example,
+			want:  739785,
+		},
+		{
+			name:  "actual",
+			input: input,
+			want:  1067724,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := part1(tt.input); got != tt.want {
+				t.Errorf("part1() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_part2(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  int64
+	}{
+		{
+			name:  "example",
+			input: example,
+			want:  444356092776315,
+		},
+		{
+			name:  "actual",
+			input: input,
+			want:  630947104784464,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := part2(tt.input); got != tt.want {
+				t.Errorf("part2() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}