advent2022

main.go (4903B)

---

 package main
 
 import (
 	"bufio"
 	"fmt"
 	"log"
 	"os"
 	"sort"
 	"strconv"
 	"strings"
 )
 
 type Monkey struct {
 	items           []uint64
 	orig            []uint64
 	operation       func(val uint64) uint64
 	test            uint64 // divisible by
 	ifTrue, ifFalse int    // pass to monkeys
 	count           uint64 // how many times monkey inspected items
 }
 
 func (m *Monkey) Reset() {
 	m.items = nil
 	m.items = append(m.items, m.orig...)
 	m.count = 0
 }
 func (m *Monkey) parseItems(in string) {
 	items := strings.Split(in, ",")
 	for _, i := range items {
 		item, err := strconv.Atoi(strings.TrimSpace(i))
 		if err != nil {
 			log.Fatal(err)
 		}
 		m.items = append(m.items, uint64(item))
 		m.orig = append(m.orig, uint64(item))
 	}
 }
 func (m *Monkey) parseOperation(in string) {
 	var v, op string
 	_, err := fmt.Sscanf(in, "new = old %s %s", &op, &v)
 	if err != nil {
 		log.Fatal(err)
 	}
 	m.operation = func(val uint64) uint64 {
 		if op == "*" {
 			if v == "old" {
 				return val * val
 			} else {
 				num, err := strconv.Atoi(v)
 				if err != nil {
 					log.Fatal(err)
 				}
 				return val * uint64(num)
 			}
 		} else if op == "+" {
 			if v == "old" {
 				return val + val
 			} else {
 				num, err := strconv.Atoi(v)
 				if err != nil {
 					log.Fatal(err)
 				}
 				return val + uint64(num)
 			}
 		} else {
 			log.Fatal("invalid operation", op)
 		}
 		return val
 	}
 }
 func (m *Monkey) parseTest(in string) {
 	_, err := fmt.Sscanf(in, "divisible by %d", &m.test)
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func (m *Monkey) parseIfTrue(in string) {
 	_, err := fmt.Sscanf(in, "throw to monkey %d", &m.ifTrue)
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func (m *Monkey) parseIfFalse(in string) {
 	_, err := fmt.Sscanf(in, "throw to monkey %d", &m.ifFalse)
 	if err != nil {
 		log.Fatal(err)
 	}
 }
 func (m *Monkey) processItem1(i int) int {
 	if i >= len(m.items) {
 		log.Fatal("invalid item id")
 	}
 	m.items[i] = m.operation(m.items[i])
 	m.items[i] /= 3
 	m.count++
 	if m.items[i]%m.test == 0 {
 		return m.ifTrue
 	} else {
 		return m.ifFalse
 	}
 }
 func (m *Monkey) processItem2(i int) int {
 	if i >= len(m.items) {
 		log.Fatal("invalid item id")
 	}
 	m.items[i] = m.operation(m.items[i])
 	m.count++
 	if m.items[i]%m.test == 0 {
 		return m.ifTrue
 	} else {
 		return m.ifFalse
 	}
 }
 
 type Monkeys []*Monkey
 
 func (m *Monkeys) Reset() {
 	for _, monkey := range *m {
 		monkey.Reset()
 	}
 }
 func (m Monkeys) Len() int { return len(m) }
 func (m Monkeys) Swap(i, j int) {
 	m[i], m[j] = m[j], m[i]
 }
 func (m Monkeys) Less(i, j int) bool {
 	return m[i].count > m[j].count
 }
 func (monkeys Monkeys) GetCommon() uint64 {
 	var common uint64 = 1
 	for _, m := range monkeys {
 		common *= m.test
 	}
 	return common
 }
 func (monkeys Monkeys) DoTurn1() {
 	for _, m := range monkeys {
 		for n, _ := range m.items {
 			t := m.processItem1(n)
 			target := monkeys[t]
 			target.items = append(target.items, m.items[n])
 		}
 		m.items = nil
 	}
 }
 func (monkeys Monkeys) DoTurn2(common uint64) {
 	for _, m := range monkeys {
 		for n, _ := range m.items {
 			m.items[n] %= common
 			t := m.processItem2(n)
 			target := monkeys[t]
 			target.items = append(target.items, m.items[n])
 		}
 		m.items = nil
 	}
 }
 func (monkeys Monkeys) GetCounts() []uint64 {
 	var counts []uint64
 	for _, m := range monkeys {
 		counts = append(counts, m.count)
 	}
 	return counts
 }
 
 func main() {
 	if len(os.Args) > 1 {
 		day11(os.Args[1])
 	} else if len(os.Args) == 1 {
 		fmt.Printf("usage: %s inputfile.txt\n", os.Args[0])
 	} else {
 		fmt.Println("No input data")
 	}
 }
 
 func day11(input_file string) {
 	fmt.Printf("day 11 input filename: %s\n", input_file)
 	input, err := os.Open(input_file)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer input.Close()
 	scanner := bufio.NewScanner(input)
 	var monkeys Monkeys
 	current := -1
 	for scanner.Scan() {
 		in := scanner.Text()
 		if in == "" {
 			continue
 		}
 		field, val, _ := strings.Cut(in, ":")
 		field = strings.TrimSpace(field)
 		val = strings.TrimSpace(val)
 		switch field {
 		case "Starting items":
 			monkeys[current].parseItems(val)
 		case "Operation":
 			monkeys[current].parseOperation(val)
 		case "Test":
 			monkeys[current].parseTest(val)
 		case "If true":
 			monkeys[current].parseIfTrue(val)
 		case "If false":
 			monkeys[current].parseIfFalse(val)
 		default:
 			if n, err := fmt.Sscanf(in, "Monkey %d", &current); n != 1 || err != nil {
 				log.Fatal("Invalid input", in, err)
 			} else {
 				// new monkey
 				monkeys = append(monkeys, &Monkey{})
 			}
 		}
 	}
 	if err = scanner.Err(); err != nil {
 		log.Fatal(err)
 	}
 
 	var monkeys2 Monkeys
 	monkeys2 = append(monkeys2, monkeys...)
 	for i := 0; i < 20; i++ {
 		monkeys.DoTurn1()
 	}
 	sort.Sort(monkeys)
 	fmt.Println("Monkey business 1:", monkeys[0].count*monkeys[1].count)
 
 	monkeys2.Reset()
 	common := monkeys2.GetCommon()
 	for i := 0; i < 10000; i++ {
 		monkeys2.DoTurn2(common)
 	}
 	sort.Sort(monkeys2)
 	fmt.Println("Monkey business 2:", monkeys2[0].count*monkeys2[1].count)
 }