adventofcode/2016/day25/main.go

506 lines
11 KiB
Go
Raw Normal View History

2016-12-28 14:48:23 +00:00
package main
import (
"fmt"
"os"
"strconv"
"strings"
"time"
"github.com/fatih/color"
termbox "github.com/nsf/termbox-go"
2023-12-17 16:52:08 +00:00
h "git.bullercodeworks.com/brian/adventofcode/helpers"
2016-12-28 14:48:23 +00:00
)
var regs = map[string]int{
"a": 0,
"b": 0,
"c": 0,
"d": 0,
}
var instructions, lastInst []string
var curr, cursor int
var done, debug, pause, step, skip bool
var breakpoints []int
var eventChan chan termbox.Event
var outBuff string
// Available arguments:
// -d Debug Mode
// -p Pause on start
// -25 Run day 25 simulation
func main() {
var inpFn string
2023-12-17 16:52:08 +00:00
if inpFn = h.GetArgNumber(1); inpFn == "" {
2016-12-28 14:48:23 +00:00
done = true
}
if inpFn != "" {
2023-12-17 16:52:08 +00:00
instructions = h.FileToStringSlice(inpFn)
2016-12-28 14:48:23 +00:00
}
2023-12-17 16:52:08 +00:00
if h.ArgIsSet("-d") {
2016-12-28 14:48:23 +00:00
debug = true
}
2023-12-17 16:52:08 +00:00
if h.ArgIsSet("-p") {
2016-12-28 14:48:23 +00:00
pause = true
}
2023-12-17 16:52:08 +00:00
if h.ArgIsSet("-25") {
2016-12-28 14:48:23 +00:00
// If running the day 25 simulation, ignore debug and pause flags
fmt.Println("Running Day 25 simulation, disabling debug & pause")
debug = false
pause = false
}
if debug {
err := termbox.Init()
//tWidth, tHeight := termbox.Size()
if err != nil {
fmt.Println("Error initializing termbox")
os.Exit(1)
}
defer termbox.Close()
eventChan = make(chan termbox.Event)
go readUserInput(eventChan)
go sendNoneEvent(eventChan)
}
2023-12-17 16:52:08 +00:00
if h.ArgIsSet("-25") {
2016-12-28 14:48:23 +00:00
var day25Solved bool
regAStart := regs["a"]
regBStart := regs["b"]
regCStart := regs["c"]
regDStart := regs["d"]
for !day25Solved {
regs["a"] = regAStart
regs["b"] = regBStart
regs["c"] = regCStart
regs["d"] = regDStart
ProcInstructions()
day25Solved = true
fmt.Println(regAStart, ":", outBuff)
if outBuff != "0101010101" {
day25Solved = false
regAStart++
}
}
} else {
ProcInstructions()
PrintState()
}
//fmt.Println("Press any key to exit")
//termbox.PollEvent()
}
func ProcInstructions() {
locRegs := make(map[string]int)
for k, v := range regs {
locRegs[k] = v
}
curr = 0
outBuff = ""
var ins []string
for curr < len(instructions) || done {
isBreak := isBreakpoint(curr)
if debug {
lastInst = ins
}
ins = strings.Fields(instructions[curr])
if len(ins) == 0 {
break
}
if isMultOp(curr) {
curr = doMultOp(curr)
skip = true
}
if debug {
if isBreak {
pause = true
step = false
}
for pause && !step && !done {
// print state and wait for user to step
PrintState()
PrintInstructionState()
PrintDebugHelp()
ev := <-eventChan
if ev.Type == termbox.EventKey {
switch {
case ev.Key == termbox.KeySpace:
pause = !pause
case ev.Ch == 'q':
done = true
case ev.Ch == 'b':
toggleBreakpoint(cursor)
case ev.Ch == 's':
step = true
case ev.Ch == 'u':
updateRegister()
case ev.Key == termbox.KeyArrowUp:
if cursor > 0 {
cursor--
}
case ev.Key == termbox.KeyArrowDown:
if cursor < len(instructions)-1 {
cursor++
}
}
}
}
step = false
}
if done {
// User hit 'q'
break
}
if skip {
skip = false
continue
}
curr++
switch ins[0] {
case "out":
v, ok := regs[ins[1]]
if !ok {
outBuff += ins[1]
} else {
2023-12-17 16:52:08 +00:00
outBuff += h.Itoa(v)
2016-12-28 14:48:23 +00:00
}
2023-12-17 16:52:08 +00:00
if h.ArgIsSet("-25") && len(outBuff) == 10 {
2016-12-28 14:48:23 +00:00
// This should be long enough for our day 25 answer
return
}
// If we're not debugging, just print it and reset the buffer
2023-12-17 16:52:08 +00:00
if !debug && !h.ArgIsSet("-25") {
2016-12-28 14:48:23 +00:00
fmt.Print(outBuff)
outBuff = ""
}
case "jnz":
// If we have a jnz c -2 it could be moving all of c into another register
v, ok := regs[ins[1]]
if !ok {
2023-12-17 16:52:08 +00:00
v = h.Atoi(ins[1])
2016-12-28 14:48:23 +00:00
}
var p int
if p, ok = regs[ins[2]]; !ok {
2023-12-17 16:52:08 +00:00
p = h.Atoi(ins[2])
2016-12-28 14:48:23 +00:00
}
if v != 0 {
// Subtract 1 from the jump because we incremented already
curr += p - 1
}
case "mlt":
// a three arg instruction: mlt a b c
// take a * b, store in c
var ok bool
src1 := ins[1]
src2 := ins[2]
dst := ins[3]
if _, ok := regs[dst]; !ok {
// invalid destination
continue
}
var src1I, src2I int
if src1I, ok = regs[src1]; !ok {
2023-12-17 16:52:08 +00:00
src1I = h.Atoi(src1)
2016-12-28 14:48:23 +00:00
}
if src2I, ok = regs[src2]; !ok {
2023-12-17 16:52:08 +00:00
src2I = h.Atoi(src2)
2016-12-28 14:48:23 +00:00
}
regs[dst] = src1I * src2I
case "cpy":
src := ins[1]
dst := ins[2]
// check if dst is a register
if _, ok := regs[dst]; !ok {
// Nope, move along
continue
}
// check if the src is a register
if v, ok := regs[src]; ok {
regs[dst] = v
} else {
// It's not, must be an int
2023-12-17 16:52:08 +00:00
regs[dst] = h.Atoi(src)
2016-12-28 14:48:23 +00:00
}
case "inc":
if _, ok := regs[ins[1]]; !ok {
continue
}
regs[ins[1]] = regs[ins[1]] + 1
case "dec":
if _, ok := regs[ins[1]]; !ok {
continue
}
regs[ins[1]] = regs[ins[1]] - 1
case "tgl": // tgl alters an instruction
src := ins[1]
var srcI int
if v, ok := regs[src]; ok {
srcI = v
} else {
2023-12-17 16:52:08 +00:00
srcI = h.Atoi(src)
2016-12-28 14:48:23 +00:00
}
srcI = curr + srcI
if srcI < 0 || srcI > len(instructions)-1 {
// Invalid instruction
continue
}
altPts := strings.Fields(instructions[srcI-1])
if len(altPts) == 2 { // one argument
if altPts[0] == "inc" {
altPts[0] = "dec"
} else {
altPts[0] = "inc"
}
} else { // two arguments
if altPts[0] == "jnz" {
altPts[0] = "cpy"
} else {
altPts[0] = "jnz"
}
}
instructions[srcI-1] = strings.Join(altPts, " ")
}
if debug {
PrintState()
}
}
}
// Fancy State Printing
func PrintState() {
2023-12-17 16:52:08 +00:00
fmt.Println(h.ClearScreen)
2016-12-28 14:48:23 +00:00
PrintRegs()
}
func PrintRegs() {
datLine := fmt.Sprint("\u2502 a:", regs["a"], " b:", regs["b"], " c:", regs["c"], " d:", regs["d"], " \u2502")
fmt.Println("\u250C" + strings.Repeat("\u2500", len(datLine)-6) + "\u2510")
fmt.Println(datLine)
fmt.Println("\u2514" + strings.Repeat("\u2500", len(datLine)-6) + "\u2518")
}
func PrintInstructionState() {
optim := color.New(color.FgGreen)
for pi := range instructions {
if pi == curr {
fmt.Print(">")
} else {
fmt.Print(" ")
}
if isBreakpoint(pi) {
fmt.Print("B")
} else {
fmt.Print(" ")
}
if cursor == pi {
cursor := color.New(color.FgBlack).Add(color.BgWhite)
if isMultOp(pi) {
cursor.Println("+ " + instructions[pi] + " == optimized")
} else if mo, _ := isInMultOp(pi); mo {
cursor.Println("| " + instructions[pi])
} else {
cursor.Println(instructions[pi])
}
} else {
if isMultOp(pi) {
optim.Println("+ " + instructions[pi] + " == optimized")
} else if mo, _ := isInMultOp(pi); mo {
optim.Println("| " + instructions[pi])
} else {
fmt.Println(instructions[pi])
}
}
}
}
func PrintDebugHelp() {
fmt.Println("(s): step | (space): pause/unpause | (b): toggle breakpoint")
fmt.Println("(u): update register to value | (q): quit")
}
func readUserInput(e chan termbox.Event) {
for {
e <- termbox.PollEvent()
}
}
func sendNoneEvent(e chan termbox.Event) {
for {
time.Sleep(time.Second / 32)
if !pause {
e <- termbox.Event{Type: termbox.EventNone}
}
}
}
// isInMultOp returns true and the pc for the
// start of the multiplication operation if pos is
// located within it
func isInMultOp(pos int) (bool, int) {
// We need to check instructions[pos +- 5] to see if any
// are a multiplication op and return the pos for the (first) one
// that is
if isMultOp(pos) {
return true, pos
}
for i := 1; i < 6; i++ {
if isMultOp(pos - i) {
return true, (pos - i)
}
}
return false, pos
}
// isMultOpStart return whether pos is the start of
// what can be optimized as multiplication
/*
> cpy b c
inc a
dec c
jnz c -2
dec d
jnz d -5
== add (b * d) to a
set c & d to 0
curr += 5
*/
func isMultOp(pos int) bool {
if pos < 0 || pos > len(instructions)-1 {
return false
}
ins := strings.Fields(instructions[pos])
if len(ins) < 3 {
return false
}
if ins[0] == "cpy" {
if len(instructions) >= pos+6 {
ins1 := strings.Fields(instructions[pos+1])
ins2 := strings.Fields(instructions[pos+2])
ins3 := strings.Fields(instructions[pos+3])
ins4 := strings.Fields(instructions[pos+4])
ins5 := strings.Fields(instructions[pos+5])
if ins1[0] == "inc" && ins2[0] == "dec" && ins3[0] == "jnz" && ins4[0] == "dec" && ins5[0] == "jnz" {
allGood := true
if allGood {
// Do the multiplication
// ins[1] * ins4[1]
// add that value to ins1[1]
// set ins[2] to 0
// set ins4[1] to 0
// Then add 5 to the pc
src1 := ins[1]
src2 := ins4[1]
dst := ins1[1]
if _, ok := regs[dst]; !ok {
// Invalid destination register
allGood = false
}
if _, ok := regs[src1]; !ok {
// Invalid source register
allGood = false
}
if _, ok := regs[src2]; !ok {
allGood = false
}
return allGood
}
}
}
}
return false
}
// doMultOp performs a multiplcation operation and returns the new pc
func doMultOp(pos int) int {
isOp, pos := isInMultOp(pos)
if !isOp {
// No optimization to do
return pos
}
ins := strings.Fields(instructions[pos])
ins1 := strings.Fields(instructions[pos+1])
ins4 := strings.Fields(instructions[pos+4])
// Do the multiplication
// ins[1] * ins4[1]
// add that value to ins1[1]
// set ins[2] to 0
// set ins4[1] to 0
// Then add 5 to the pc
src1 := ins[1]
src2 := ins4[1]
dst := ins1[1]
regs[dst] += (regs[src1] * regs[src2])
regs[ins[2]] = 0
regs[ins4[1]] = 0
pos += 6
return pos
}
func toggleBreakpoint(pos int) {
_, pos = isInMultOp(pos)
for i := 0; i < len(breakpoints); i++ {
if breakpoints[i] == pos {
breakpoints = append(breakpoints[:i], breakpoints[i+1:]...)
return
}
}
breakpoints = append(breakpoints, pos)
}
func isBreakpoint(pos int) bool {
_, pos = isInMultOp(pos)
for i := 0; i < len(breakpoints); i++ {
if breakpoints[i] == pos {
return true
}
}
return false
}
func updateRegister() {
var updReg string
fmt.Println("Update which register? (a,b,c,d)")
ev := <-eventChan
if ev.Type == termbox.EventKey {
switch {
case ev.Ch == 'a':
updReg = "a"
case ev.Ch == 'b':
updReg = "b"
case ev.Ch == 'c':
updReg = "c"
case ev.Ch == 'd':
updReg = "d"
default:
fmt.Println("Invalid register (" + string(ev.Ch) + ")")
fmt.Println("Press any key to continue")
ev = <-eventChan
return
}
}
fmt.Println("Enter new value (must be integer, end with enter)")
var newVal string
for ev.Key != termbox.KeyEnter {
ev = <-eventChan
if ev.Ch >= '0' && ev.Ch <= '9' {
newVal += string(ev.Ch)
fmt.Print(string(ev.Ch))
}
}
fmt.Println("Setting Register (" + updReg + ") to " + newVal)
var v int
var e error
if v, e = strconv.Atoi(newVal); e != nil {
fmt.Println()
fmt.Println("Error parsing integer")
fmt.Println(e)
fmt.Println("Press any key to continue")
ev = <-eventChan
return
}
regs[updReg] = v
}