Make VM users responsible for its I/O channels.

02/main.go

 
 	pool := &sync.Pool{
 		New: func() interface{} {
-			return intcode.NewVirtualMachine(make([]int, len(input)), false)
+			return intcode.NewVirtualMachine(make([]int, len(input)))
 		},
 	}
 

05/main.go

 	memory := make([]int, len(input))
 	copy(memory, input)
 
-	vm := intcode.NewVirtualMachine(memory, true)
+	vm := intcode.NewVirtualMachine(memory)
+	vm.Input = make(chan int, 1)
+	vm.Output = make(chan int, 1)
 	vm.Input <- 1
 	go vm.Run()
 	fmt.Println(last(vm.Output))
 
 	vm.Reset(input)
+	vm.Output = make(chan int, 1)
 	vm.Input <- 5
 	go vm.Run()
 	fmt.Println(last(vm.Output))

07/main.go

 	for i := 0; i < len(ps); i++ {
 		memory := memoryBanks[i*len(program) : (i+1)*len(program)]
 		copy(memory, program)
-		vms[i] = intcode.NewVirtualMachine(memory, true)
+		vms[i] = intcode.NewVirtualMachine(memory)
+		vms[i].Output = make(chan int, 2)
 	}
 
 	// Link all the inputs and outputs
 			vm.Input = vms[i-1].Output
 		} else if feedback {
 			vm.Input = vms[len(vms)-1].Output
+		} else {
+			vm.Input = make(chan int, 2)
 		}
 	}
 

intcode/vm.go

 	Output chan int
 }
 
-// NewVirtualMachine creates a new IntCode virtual machine, initialised
-// to the given slice of memory.
-func NewVirtualMachine(memory []int, hasIO bool) *VirtualMachine {
+// NewVirtualMachine creates a new IntCode virtual machine, initialised to the given slice of memory.
+// The caller is responsible for initialising the VM's I/O channels if required.
+func NewVirtualMachine(memory []int) *VirtualMachine {
 	vm := &VirtualMachine{
 		ip:     0,
 		Memory: memory,
 		Halted: false,
 	}
 
-	if hasIO {
-		vm.Input = make(chan int, 1)
-		vm.Output = make(chan int, 1)
-	}
-
 	return vm
 }
 
+// arg Returns the value of the given argument for the current instruction.
 func (vm *VirtualMachine) arg(pos int) int {
 	mask := uint8(1) << uint8(pos)
 	if vm.modes&mask == mask {
 	copy(vm.Memory, memory)
 	vm.ip = 0
 	vm.Halted = false
-	if vm.Input != nil {
-		vm.Input = make(chan int, 1)
-		vm.Output = make(chan int, 1)
-	}
 }

intcode/vm_test.go

 	}
 
 	for _, table := range tables {
-		vm := NewVirtualMachine(table.given, false)
+		vm := NewVirtualMachine(table.given)
 		vm.Run()
 		if !reflect.DeepEqual(table.expected, vm.Memory) {
 			t.Errorf("Evaluation of %v was incorrect, got: %v, want: %v.", table.given, vm.Memory, table.expected)
 	}
 
 	for _, table := range tables {
-		vm := NewVirtualMachine(table.given, true)
+		vm := NewVirtualMachine(table.given)
+		vm.Input = make(chan int, 1)
+		vm.Output = make(chan int, 1)
 
 		for _, v := range table.input {
 			vm.Input <- v