2022 day 11

Author: pvainio

2022/go/day11/day11.go

@@ -0,0 +1,113 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func main() {
+	fmt.Printf("part1 : %d\n", monkeyBusiness(20))
+	fmt.Printf("part2 : %d\n", monkeyBusiness(10000))
+}
+
+func monkeyBusiness(rounds int) int {
+	input, _ := os.ReadFile("../../input/day11.txt")
+	monkeys := parseMonkeys(string(input))
+
+	for i := 0; i < rounds; i++ {
+		doRound(monkeys, rounds <= 20)
+	}
+
+	inspects := []int{}
+	for _, m := range monkeys {
+		inspects = append(inspects, m.inspectCount)
+	}
+	sort.Sort(sort.Reverse(sort.IntSlice(inspects)))
+	return inspects[0] * inspects[1]
+}
+
+func doRound(monkeys []*monkey, manageWorry bool) {
+	commonMultiplier := 1
+	for _, m := range monkeys {
+		commonMultiplier *= m.divisible
+	}
+
+	for _, m := range monkeys {
+		for _, i := range m.items {
+			m.inspectCount++
+			newLevel := op(i, m.oper)
+			if manageWorry {
+				newLevel = newLevel / 3
+			}
+			newLevel = newLevel % commonMultiplier
+
+			if newLevel%m.divisible == 0 {
+				monkeys[m.trueTo].items = append(monkeys[m.trueTo].items, newLevel)
+			} else {
+				monkeys[m.falseTo].items = append(monkeys[m.falseTo].items, newLevel)
+			}
+		}
+		m.items = []int{}
+	}
+}
+
+func op(val int, op operation) int {
+	var v2 int
+	if op.val == "old" {
+		v2 = val
+	} else {
+		fmt.Sscanf(op.val, "%d", &v2)
+	}
+
+	switch op.op {
+	case '*':
+		return val * v2
+	case '+':
+		return val + v2
+	}
+	panic("error")
+}
+
+func parseMonkeys(input string) (monkeys []*monkey) {
+	monkey := strings.Split(input, "\n\n")
+	for _, m := range monkey {
+		monkeys = append(monkeys, parseMonkey(m))
+	}
+	return monkeys
+}
+
+func parseMonkey(input string) *monkey {
+	var m monkey
+	lines := strings.Split(input, "\n")
+	m.items = parseItems(strings.Split(lines[1], ":")[1])
+	fmt.Sscanf(lines[2], " Operation: new = old %c %s", &m.oper.op, &m.oper.val)
+	fmt.Sscanf(lines[3], " Test: divisible by %d", &m.divisible)
+	fmt.Sscanf(lines[4], " If true: throw to monkey %d", &m.trueTo)
+	fmt.Sscanf(lines[5], " If false: throw to monkey %d", &m.falseTo)
+	return &m
+}
+
+func parseItems(input string) (items []int) {
+	parts := strings.Split(input, ", ")
+	for _, p := range parts {
+		i, _ := strconv.Atoi(strings.TrimSpace(p))
+		items = append(items, i)
+	}
+	return items
+}
+
+type operation struct {
+	op  byte
+	val string
+}
+
+type monkey struct {
+	items           []int
+	oper            operation
+	divisible       int
+	trueTo, falseTo int
+	inspectCount    int
+}

2022/input/day11.txt

@@ -0,0 +1,55 @@
+Monkey 0:
+  Starting items: 84, 72, 58, 51
+  Operation: new = old * 3
+  Test: divisible by 13
+    If true: throw to monkey 1
+    If false: throw to monkey 7
+
+Monkey 1:
+  Starting items: 88, 58, 58
+  Operation: new = old + 8
+  Test: divisible by 2
+    If true: throw to monkey 7
+    If false: throw to monkey 5
+
+Monkey 2:
+  Starting items: 93, 82, 71, 77, 83, 53, 71, 89
+  Operation: new = old * old
+  Test: divisible by 7
+    If true: throw to monkey 3
+    If false: throw to monkey 4
+
+Monkey 3:
+  Starting items: 81, 68, 65, 81, 73, 77, 96
+  Operation: new = old + 2
+  Test: divisible by 17
+    If true: throw to monkey 4
+    If false: throw to monkey 6
+
+Monkey 4:
+  Starting items: 75, 80, 50, 73, 88
+  Operation: new = old + 3
+  Test: divisible by 5
+    If true: throw to monkey 6
+    If false: throw to monkey 0
+
+Monkey 5:
+  Starting items: 59, 72, 99, 87, 91, 81
+  Operation: new = old * 17
+  Test: divisible by 11
+    If true: throw to monkey 2
+    If false: throw to monkey 3
+
+Monkey 6:
+  Starting items: 86, 69
+  Operation: new = old + 6
+  Test: divisible by 3
+    If true: throw to monkey 1
+    If false: throw to monkey 0
+
+Monkey 7:
+  Starting items: 91
+  Operation: new = old + 1
+  Test: divisible by 19
+    If true: throw to monkey 2
+    If false: throw to monkey 5

2022/java/Day11.java

@@ -0,0 +1,62 @@
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+class Day11 {
+
+    public static void main(String ... args) throws Exception {
+        System.out.printf("part1: %d\n", monkeyBusiness(20, true));
+        System.out.printf("part2: %d\n", monkeyBusiness(10_000, false));
+    }
+
+    static long monkeyBusiness(int rounds, boolean manageLevel) throws Exception {
+        var monkeys = readMonkeys(Files.readString(Path.of("../input/day11.txt")));
+        var commonMultiplier = monkeys.stream().mapToInt(m -> m.divisible).reduce(1, (a,b) -> a*b);
+        long[] inspects = new long[monkeys.size()];
+
+        for (int j = 0; j < rounds; j++) {
+            for (int mi = 0; mi < monkeys.size(); mi++) {
+                var m = monkeys.get(mi);
+                for (var i : m.items) {
+                    inspects[mi]++;
+                    var level = m.worryLevel(i) / (manageLevel ? 3 : 1) % commonMultiplier;
+                    var target = level % m.divisible == 0 ? m.trueTo : m.falseTo;
+                    monkeys.get(target).items.add(level);
+                }
+                m.items.clear();
+            }    
+        }
+        return Arrays.stream(inspects).mapToObj(i -> (Long)i).sorted((a,b) -> b.compareTo(a))
+            .limit(2).reduce(1l, (a,b) -> a*b);
+    }
+ 
+    static List<Monkey> readMonkeys(String input) {
+        return Arrays.stream(input.split("\n\n"))
+            .map(Monkey::parse).collect(Collectors.toCollection(() -> new ArrayList<>()));
+    }
+
+    record Monkey (List<Long> items, String[] oper, int divisible, int trueTo, int falseTo) {
+        static Monkey parse(String input) {
+            var lines = input.split("\n");
+            var items = Arrays.stream(lines[1].split(":")[1].split(","))
+                .map(i -> Long.parseLong(i.trim())).collect(Collectors.toCollection(ArrayList::new));
+            var operation = lines[2].split("= old ")[1].split(" ");
+            var divisible = Integer.parseInt(lines[3].split("by ")[1]);
+            var trueTo = Integer.parseInt(lines[4].split("monkey ")[1]);          
+            var falseTo = Integer.parseInt(lines[5].split("monkey ")[1]); 
+            return new Monkey(items, operation, divisible, trueTo, falseTo);         
+        }
+
+        long worryLevel(long level) {
+            var val = oper[1].equals("old") ? level : Integer.parseInt(oper[1]);
+            return switch (oper[0]) {
+                case "*" -> level * val;
+                case "+" -> level + val;
+                default -> throw new IllegalArgumentException();
+            };
+        }
+    }
+}