Blergh

Author: DWethmar

day11/main.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"math"
 	"os"
 	"sort"
 	"strings"
@@ -20,13 +19,28 @@ func main() {
 		panic(err)
 	}
 
-	monkeys, err := CreateMonkeys(io.NopCloser(bytes.NewBuffer(rawBody)))
+	monkeys, _, err := CreateMonkeys(io.NopCloser(bytes.NewBuffer(rawBody)))
 	if err != nil {
 		log.Fatal(err)
 	}
 
+	part1(monkeys)
+
+	monkeys, lcm, err := CreateMonkeys(io.NopCloser(bytes.NewBuffer(rawBody)))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	part2(monkeys, lcm)
+}
+
+func part1(monkeys []*Monkey) {
+	relieve := func(w int) int {
+		return w / 3
+	}
+
 	for i := 0; i < 20; i++ {
-		PlayKeepAway(i+1, monkeys)
+		PlayKeepAway(monkeys, relieve)
 	}
 
 	fmt.Println()
@@ -45,11 +59,43 @@ func main() {
 	fmt.Printf("Part 1: %s(%d) * %s(%d) = %d\n", monkeys[0].Name, monkeys[0].Inspected(), monkeys[1].Name, monkeys[1].Inspected(), answer)
 }
 
-func CreateMonkeys(input io.Reader) ([]*Monkey, error) {
+func part2(monkeys []*Monkey, lcm int) {
+	relieve := func(worryLvl int) int {
+		return worryLvl % lcm
+	}
+
+	for i := 0; i < 10000; i++ {
+		PlayKeepAway(monkeys, relieve)
+
+		if i == 0 {
+			fmt.Printf("After %d rounds:\n", i)
+			for _, monkey := range monkeys {
+				fmt.Printf("%s inspected items %d times.\n", monkey.Name, monkey.Inspected())
+			}
+			fmt.Println()
+		}
+	}
+
+	for _, monkey := range monkeys {
+		fmt.Printf("%s inspected items %d times.\n", monkey.Name, monkey.Inspected())
+	}
+
+	// sort monkeys based on Inspected()
+	sort.Slice(monkeys, func(i, j int) bool {
+		return monkeys[i].Inspected() > monkeys[j].Inspected()
+	})
+
+	answer := monkeys[0].Inspected() * monkeys[1].Inspected()
+
+	fmt.Printf("Part 2: %s(%d) * %s(%d) = %d\n", monkeys[0].Name, monkeys[0].Inspected(), monkeys[1].Name, monkeys[1].Inspected(), answer)
+}
+
+func CreateMonkeys(input io.Reader) ([]*Monkey, int, error) {
 	var monkeys []*Monkey
 
 	currentMonkey := &Monkey{}
 	i := 0
+	lcm := 1
 
 	err := iterate.Lines(input, func(instruction string) iterate.Step {
 		if instruction == "" {
@@ -65,15 +111,16 @@ func CreateMonkeys(input io.Reader) ([]*Monkey, error) {
 
 			currentMonkey.Name = strings.Trim(v[0], " ")
 		case 1:
-			currentMonkey.StartingItems = number.GetAllIntsFromString(v[1])
+			currentMonkey.Items = number.GetAllIntsFromString(v[1])
 		case 2:
 			currentMonkey.Operation = strings.Trim(v[1], " ")
 		case 3:
-			currentMonkey.Test = strings.Trim(v[1], " ")
+			currentMonkey.Test = number.GetAllIntsFromString(instruction)[0]
+			lcm *= currentMonkey.Test
 		case 4:
-			currentMonkey.TestTrue = strings.Trim(v[1], " ")
+			currentMonkey.TestTrue = number.GetAllIntsFromString(instruction)[0]
 		case 5:
-			currentMonkey.TestFalse = strings.Trim(v[1], " ")
+			currentMonkey.TestFalse = number.GetAllIntsFromString(instruction)[0]
 		}
 
 		if i == 5 {
@@ -85,7 +132,7 @@ func CreateMonkeys(input io.Reader) ([]*Monkey, error) {
 		return iterate.Continue
 	})
 
-	return monkeys, err
+	return monkeys, lcm, err
 }
 
 /**
@@ -101,39 +148,18 @@ Monkey 0:
     Current worry level is not divisible by 23.
     Item with worry level 620 is thrown to monkey 3.
 **/
-func PlayKeepAway(round int, monkeys []*Monkey) {
-
+func PlayKeepAway(monkeys []*Monkey, relieve func(w int) int) {
 	for _, monkey := range monkeys {
-		fmt.Print(monkey.Name, ":\n")
+		for i, _ := range monkey.Items {
+			w := relieve(monkey.DoOperation(i))
+			t := monkey.DoTest(w)
 
-		for i, item := range monkey.StartingItems {
-			fmt.Printf("\tMonkey inspects an item with a worry level of %d.\n", item)
-
-			d, newWorryLevel := monkey.DoOperation(i)
-			fmt.Printf("\t\t%s\n", d)
-
-			newWorryLevel = int(math.Floor(float64(newWorryLevel) / 3))
-			fmt.Printf("\t\tMonkey gets bored with item. Worry level is divided by 3 to %d.\n", newWorryLevel)
-
-			t, throwToMonkeyIndex := monkey.DoTest(newWorryLevel)
-			fmt.Printf("\t\t%s\n", t)
-
-			fmt.Printf("\t\tItem with worry level %d is thrown to monkey %d.\n", newWorryLevel, throwToMonkeyIndex)
-			receivingMonkey := monkeys[throwToMonkeyIndex]
-			receivingMonkey.StartingItems = append(receivingMonkey.StartingItems, newWorryLevel)
+			receivingMonkey := monkeys[t]
+			receivingMonkey.Items = append(receivingMonkey.Items, w)
 
 			monkey.Inspect()
 		}
 
-		monkey.StartingItems = []int{}
+		monkey.Items = nil
 	}
-
-	fmt.Println("")
-
-	fmt.Printf("After round %d, the monkeys are holding items with these worry levels:\n", round)
-	for _, monkey := range monkeys {
-		fmt.Printf("%s: %d\n", monkey.Name, monkey.StartingItems)
-	}
-
-	return
 }

day11/main_test.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"io"
+	"math"
 	"os"
 	"reflect"
 	"testing"
@@ -10,35 +11,35 @@ import (
 var testMonkeys = []*Monkey{
 	{
 		Name:          "Monkey 0",
-		StartingItems: []int{79, 98},
+		Items: []int{79, 98},
 		Operation:     "new = old * 19",
-		Test:          "divisible by 23",
-		TestTrue:      "throw to monkey 2",
-		TestFalse:     "throw to monkey 3",
+		Test:          23,
+		TestTrue:      2,
+		TestFalse:     3,
 	},
 	{
 		Name:          "Monkey 1",
-		StartingItems: []int{54, 65, 75, 74},
+		Items: []int{54, 65, 75, 74},
 		Operation:     "new = old + 6",
-		Test:          "divisible by 19",
-		TestTrue:      "throw to monkey 2",
-		TestFalse:     "throw to monkey 0",
+		Test:          19,
+		TestTrue:      2,
+		TestFalse:     0,
 	},
 	{
 		Name:          "Monkey 2",
-		StartingItems: []int{79, 60, 97},
+		Items: []int{79, 60, 97},
 		Operation:     "new = old * old",
-		Test:          "divisible by 13",
-		TestTrue:      "throw to monkey 1",
-		TestFalse:     "throw to monkey 3",
+		Test:          12,
+		TestTrue:      1,
+		TestFalse:     3,
 	},
 	{
 		Name:          "Monkey 3",
-		StartingItems: []int{74},
+		Items: []int{74},
 		Operation:     "new = old + 3",
-		Test:          "divisible by 17",
-		TestTrue:      "throw to monkey 0",
-		TestFalse:     "throw to monkey 1",
+		Test:          17,
+		TestTrue:      0,
+		TestFalse:     1,
 	},
 }
 
@@ -83,7 +84,7 @@ func TestCreateMonkeys(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := CreateMonkeys(tt.args.input)
+			got, _, err := CreateMonkeys(tt.args.input)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("CreateMonkeys() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -116,7 +117,48 @@ func TestPlayKeepAway(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			PlayKeepAway(1, tt.args.monkeys)
+			PlayKeepAway(tt.args.monkeys, func(worryLvl int) int {
+				return int(math.Floor(float64(worryLvl) / 3))
+			})
+		})
+	}
+}
+
+func Test_part1(t *testing.T) {
+	type args struct {
+		monkeys []*Monkey
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			part1(tt.args.monkeys)
+		})
+	}
+}
+
+func Test_part2(t *testing.T) {
+	type args struct {
+		monkeys []*Monkey
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "example",
+			args: args{
+				monkeys: testMonkeys,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			part2(tt.args.monkeys, 10)
 		})
 	}
 }

day11/monkey.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/dwethmar/adventofcode2022/pkg/number"
@@ -10,18 +9,17 @@ import (
 type Monkey struct {
 	// Name of the monkey
 	Name string
-	// StartingItems lists your worry level for each item the monkey is
+	// Items lists your worry level for each item the monkey is
 	// currently holding in the order they will be inspected.
-	StartingItems []int
+	Items []int
 
 	// Operation
-	// example: new = old * 7
 	Operation string
 
 	// test
-	Test      string
-	TestTrue  string
-	TestFalse string
+	Test      int
+	TestTrue  int
+	TestFalse int
 
 	// Inspected total number of times each monkey inspects items
 	inspected int
@@ -30,8 +28,8 @@ type Monkey struct {
 // hows how your worry level changes as that monkey inspects an item.
 // (An operation like new = old * 5 means that your worry level after
 // the monkey inspected the item is five times whatever your worry level was before inspection.)
-func (m *Monkey) DoOperation(index int) (string, int) {
-	item := m.StartingItems[index]
+func (m *Monkey) DoOperation(index int) int {
+	item := m.Items[index]
 
 	p := strings.Split(m.Operation, " ")
 
@@ -53,50 +51,26 @@ func (m *Monkey) DoOperation(index int) (string, int) {
 	}
 
 	result := 0
-	operatorStr := ""
-	valueBStr := fmt.Sprint(valueB)
-	if valueBStr == fmt.Sprint(item) {
-		valueBStr = "itself"
-	}
 
 	switch op {
 	case "+":
 		result = valueA + valueB
-		operatorStr = "increases"
 	case "*":
 		result = valueA * valueB
-		operatorStr = "is multiplied"
 	}
 
-	return fmt.Sprintf("Worry level %s by %s to %d.", operatorStr, valueBStr, result), result
+	return result
 }
 
 // Test shows how the monkey uses your worry level to decide where
 // to throw an item next.
 // If true shows what happens with an item if the Test was true.
 // If false shows what happens with an item if the Test was false.
-func (m *Monkey) DoTest(worryLevel int) (string, int) {
-	v := float64(number.GetAllIntsFromString(m.Test)[0])
-	p := float64(worryLevel)
-
-	// check if p is divisible by v
-	isDivisible := p/v == float64(int(p/v))
-
-	test := ""
-	if isDivisible {
-		test = m.TestTrue
-	} else {
-		test = m.TestFalse
+func (m *Monkey) DoTest(w int) int {
+	if w%m.Test == 0 {
+		return m.TestTrue
 	}
-
-	successStr := ""
-	if isDivisible {
-		successStr = "is"
-	} else {
-		successStr = "is not"
-	}
-
-	return fmt.Sprintf("Current worry level %s divisible by %d.", successStr, int(v)), number.GetAllIntsFromString(test)[0]
+	return m.TestFalse
 }
 
 func (m *Monkey) Inspect() {

go.mod

@@ -1,11 +1,3 @@
 module github.com/dwethmar/adventofcode2022
 
 go 1.19
-
-require github.com/stretchr/testify v1.8.1
-
-require (
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)