Advent of Code (Go): solve 2019/13 using a synchronous mode; use Options pattern to build IntCode

Author: IsaacG

advent_of_code.go/y2019/02.go

@@ -9,7 +9,7 @@ type Day02 struct {
 }
 
 func (q *Day02) run(data string, a, b int) int {
-	ic := NewIntCode(data, false, nil, nil)
+	ic := NewIntCode(data)
 	ic.mem[1] = a
 	ic.mem[2] = b
 	ic.run()

advent_of_code.go/y2019/05.go

@@ -11,26 +11,26 @@ type Day05 struct {
 
 // Solve returns the solution for one part.
 func (q *Day05) Solve(data string, part int) string {
-	input, output := make(chan int, 1), make(chan int, 1)
-	ic := NewIntCode(data, false, input, output)
+	i, o:= make(chan int, 1), make(chan int, 1)
+	ic := NewIntCode(data, IO(i, o))
 	go ic.run()
 	if part == 1 {
-		input <- 1
+		i <- 1
 	} else {
-		input <- 5
+		i <- 5
 	}
-	var i int
+	var output int
 	for {
 		select {
-		case v := <-output:
-			i = v
+		case v := <-o:
+			output = v
 		case <-time.After(100 * time.Millisecond):
 			if ic.state == StateHalt {
-				return helpers.Itoa(i)
+				return helpers.Itoa(output)
 			}
 		}
 	}
-	return helpers.Itoa(i)
+	return helpers.Itoa(output)
 }
 
 func init() {

advent_of_code.go/y2019/07.go

@@ -26,7 +26,7 @@ func (q *Day07) Solve(data string, part int) string {
 		var ics []*IntCode
 		var wg sync.WaitGroup
 		for i := 0; i < 5; i++ {
-			ics = append(ics, NewIntCode(data, false, channels[i], channels[(i+1)%5]))
+			ics = append(ics, NewIntCode(data, IO(channels[i], channels[(i+1)%5])))
 		}
 		for i, v := range gen.Permutation(nil) {
 			channels[i] <- v + offset

advent_of_code.go/y2019/09.go

@@ -12,7 +12,7 @@ type Day09 struct {
 func (q *Day09) Solve(data string, part int) string {
 	i, o := make(chan int, 1), make(chan int)
 	i <- part
-	ic := NewIntCode(data, false, i, o)
+	ic := NewIntCode(data, IO(i, o))
 	go ic.run()
 	return helpers.Itoa(<-o)
 }

advent_of_code.go/y2019/13.go

@@ -2,61 +2,62 @@ package y2019
 
 import (
 	"isaacgood.com/aoc/helpers"
-	"time"
 )
 
 // Day 13 solves 2019/13.
-type Day13 struct {
+type Day13 struct {}
+
+func (q *Day13) read(ic *IntCode, o <-chan int) int {
+	v := <- o
+	ic.run()
+	return v
 }
 
 // Solve returns the solution for one part.
 func (q *Day13) Solve(data string, part int) string {
-	blocks := make(map[[2]int]int)
 
-	i, o := make(chan int), make(chan int)
-	ic := NewIntCode(data, false, i, o)
+	i, o := make(chan int, 1), make(chan int, 1)
+	ic := NewIntCode(data, IO(i, o), Synchronous())
 	if part == 2 {
 		ic.mem[0] = 2
 	}
-	go ic.run()
 
 	var ball, paddle, score = 0, 0, 0
+	blocks := make(map[[2]int]int)
 	for ic.state != StateHalt {
-		for ic.state != StateHalt {
-			x, ok := read(o, 2*time.Millisecond)
-			if !ok {
-				break
-			}
-			y, tileType := <-o, <-o
-			if part == 1 && tileType == 2 {  // block
+		ic.run()
+		for ic.state != StateBlockInput && ic.state != StateHalt {
+			x := q.read(ic, o)
+			y := q.read(ic, o)
+			tileType := q.read(ic, o)
+			if tileType == 2 {
 				blocks[[2]int{x, y}] = 1
-			} else if tileType == 3 {
-				paddle = x
-			} else if tileType == 4 {
-				ball = x
 			} else if x == -1 && y == 0 {
 				score = tileType
+			} else {
+				if tileType == 3 {
+					paddle = x
+				} else if tileType == 4 {
+					ball = x
+				}
+				delete(blocks, [2]int{x, y})
 			}
-
 		}
 		if part == 1 {
 			return helpers.Itoa(len(blocks))
 		}
+		if len(blocks) == 0 {
+			return helpers.Itoa(score)
+		}
 		if paddle == ball {
-			if ok := write(i, 0, 10*time.Millisecond); !ok {
-				break
-			}
+			i <- 0
 		} else if paddle > ball {
-			if ok := write(i, -1, 10*time.Millisecond); !ok {
-				break
-			}
+			i <- -1
 		} else {
-			if ok := write(i, 1, 10*time.Millisecond); !ok {
-				break
-			}
+			i <- 1
 		}
 	}
-	return helpers.Itoa(score)
+	return ""
 }
 
 func init() {

advent_of_code.go/y2019/intcode.go

@@ -10,7 +10,8 @@ import (
 const (
 	StateReady = iota
 	StateRun
-	StateIOBlock
+	StateBlockInput
+	StateBlockOutput
 	StateHalt
 
 	ParamModePosition  = 0
@@ -63,6 +64,7 @@ type IntCode struct {
 	debug        bool
 	state        int
 	relativeBase int
+	synchronous  bool
 }
 
 func read(c <-chan int, wait time.Duration) (int, bool) {
@@ -142,10 +144,31 @@ func (ic *IntCode) run() {
 		case OpMult:
 			ic.mem[params[2]] = params[0] * params[1]
 		case OpInput:
-			v := <-ic.input
-			ic.mem[params[0]] = v
+			if ic.synchronous {
+				select {
+				case v := <-ic.input:
+					ic.mem[params[0]] = v
+				default:
+					ic.pc -= 2
+					ic.state = StateBlockInput
+					return
+				}
+			} else {
+				v := <-ic.input
+				ic.mem[params[0]] = v
+			}
 		case OpOutput:
-			ic.output <- params[0]
+			if ic.synchronous {
+				select {
+				case ic.output <- params[0]:
+				default:
+					ic.pc -= 2
+					ic.state = StateBlockOutput
+					return
+				}
+			} else {
+				ic.output <- params[0]
+			}
 		case OpJumpT:
 			if params[0] != 0 {
 				ic.pc = params[1]
@@ -175,12 +198,38 @@ func (ic *IntCode) run() {
 			panic(fmt.Sprintf("Unhandled op %d", op))
 		}
 	}
+	panic("Not good")
+}
+
+type Option func(*IntCode)
+
+func Synchronous() Option {
+	return func(i *IntCode) {
+		i.synchronous = true
+	}
 }
 
-func NewIntCode(program string, debug bool, input <-chan int, output chan<- int) *IntCode {
+func IO(input <-chan int, output chan<- int) Option {
+	return func(i *IntCode) {
+		i.input = input
+		i.output = output
+	}
+}
+
+func Debug() Option {
+	return func(i *IntCode) {
+		i.debug = true
+	}
+}
+
+func NewIntCode(program string, opts ...Option) *IntCode {
 	mem := make(map[int]int)
 	for i, v := range strings.Split(program, ",") {
 		mem[i] = helpers.Atoi(v)
 	}
-	return &IntCode{mem: mem, input: input, output: output, debug: debug, state: StateReady}
+	i := &IntCode{mem: mem}
+	for _, opt := range opts {
+		opt(i)
+	}
+	return i
 }