Day 2

01/main.go

@@ -3,25 +3,19 @@ package main
 import (
 	"fmt"
 	"github.com/csmith/aoc-2019/common"
-	"strconv"
 )
 
 func fuel(mass int) int {
 	return (mass / 3) - 2
 }
 
-func fuelRequirements(input []string) (int, int) {
+func fuelRequirements(input []int) (int, int) {
 	var (
 		simpleTotal = 0
 		recursiveTotal = 0
 	)
 
-	for _, line := range input {
-		mass, err := strconv.Atoi(line)
-		if err != nil {
-			panic(err)
-		}
-
+	for _, mass := range input {
 		required := fuel(mass)
 		simpleTotal += required
 		for required > 0 {
@@ -33,7 +27,7 @@ func fuelRequirements(input []string) (int, int) {
 }
 
 func main() {
-	input := common.ReadLines("01/input.txt")
+	input := common.Atoi(common.ReadLines("01/input.txt"))
 	part1, part2 := fuelRequirements(input)
 	fmt.Println(part1)
 	fmt.Println(part2)

02/answers.txt

@@ -0,0 +1,2 @@
+3101844
+8478

02/input.txt

@@ -0,0 +1 @@
+1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,6,1,19,1,5,19,23,2,9,23,27,1,6,27,31,1,31,9,35,2,35,10,39,1,5,39,43,2,43,9,47,1,5,47,51,1,51,5,55,1,55,9,59,2,59,13,63,1,63,9,67,1,9,67,71,2,71,10,75,1,75,6,79,2,10,79,83,1,5,83,87,2,87,10,91,1,91,5,95,1,6,95,99,2,99,13,103,1,103,6,107,1,107,5,111,2,6,111,115,1,115,13,119,1,119,2,123,1,5,123,0,99,2,0,14,0

02/main.go

@@ -0,0 +1,57 @@
+package main
+
+import (
+	"fmt"
+	"github.com/csmith/aoc-2019/common"
+	"sync"
+)
+
+func run(pool sync.Pool, input []int, noun, verb int) int {
+	state := pool.Get().([]int)
+	defer pool.Put(state)
+	copy(state, input)
+	state[1] = noun
+	state[2] = verb
+
+	var ip = 0
+	for {
+		var instr = state[ip]
+		if instr == 1 {
+			state[state[ip+3]] = state[state[ip+1]] + state[state[ip+2]]
+		} else if instr == 2 {
+			state[state[ip+3]] = state[state[ip+1]] * state[state[ip+2]]
+		} else if instr == 99 {
+			return state[0]
+		}
+		ip += 4
+	}
+}
+
+func findOutput(pool sync.Pool, input []int, target int) int {
+	res := make(chan int)
+
+	for n := 0; n < 100; n++ {
+		go func(n int) {
+			for v := 0; v < 100; v++ {
+				if run(pool, input, n, v) == target {
+					res <- 100*n + v
+				}
+			}
+		}(n)
+	}
+
+	return <-res
+}
+
+func main() {
+	input := common.Atoi(common.ReadCommas("02/input.txt"))
+
+	pool := sync.Pool{
+		New: func() interface{} {
+			return make([]int, len(input))
+		},
+	}
+
+	fmt.Println(run(pool, input, 12, 2))
+	fmt.Println(findOutput(pool, input, 19690720))
+}

common/io.go

@@ -3,11 +3,24 @@ package common
 import (
 	"bufio"
 	"os"
+	"unicode"
+	"unicode/utf8"
 )
 
 // ReadLines reads all lines from the given path and returns them in a slice of strings.
 // If an error occurs, the function will panic.
 func ReadLines(path string) []string {
+	return readWithScanner(path, bufio.ScanLines)
+}
+
+// ReadCommas reads all data from the given path and returns a string slice
+// containing comma-delimited parts. If a
+// If an error occurs, the function will panic.
+func ReadCommas(path string) []string {
+	return readWithScanner(path, scanByCommas)
+}
+
+func readWithScanner(path string, splitFunc bufio.SplitFunc) []string {
 	file, err := os.Open(path)
 	if err != nil {
 		panic(err)
@@ -16,15 +29,46 @@ func ReadLines(path string) []string {
 		_ = file.Close()
 	}()
 
-	var lines []string
+	var parts []string
 	scanner := bufio.NewScanner(file)
+	scanner.Split(splitFunc)
 	for scanner.Scan() {
-		lines = append(lines, scanner.Text())
+		parts = append(parts, scanner.Text())
 	}
 
 	if scanner.Err() != nil {
 		panic(scanner.Err())
 	}
 
-	return lines
+	return parts
+}
+
+// scanByCommas is a split function for a Scanner that returns each
+// comma-separated section of text, with surrounding spaces deleted.
+// The definition of space is set by unicode.IsSpace.
+func scanByCommas(data []byte, atEOF bool) (advance int, token []byte, err error) {
+	// Skip leading spaces.
+	start := 0
+	for width := 0; start < len(data); start += width {
+		var r rune
+		r, width = utf8.DecodeRune(data[start:])
+		if !unicode.IsSpace(r) {
+			break
+		}
+	}
+
+	// Scan until comma, marking end of word.
+	for width, i := 0, start; i < len(data); i += width {
+		var r rune
+		r, width = utf8.DecodeRune(data[i:])
+		if r == ',' || unicode.IsSpace(r) {
+			return i + width, data[start:i], nil
+		}
+	}
+	// If we're at EOF, we have a final, non-empty, non-terminated word. Return it.
+	if atEOF && len(data) > start {
+		return len(data), data[start:], nil
+	}
+	// Request more data.
+	return start, nil, nil
 }

common/strings.go

@@ -0,0 +1,24 @@
+package common
+
+import (
+	"strconv"
+)
+
+// MustAtoi converts the input string to an integer and panics on failure.
+func MustAtoi(input string) int {
+	res, err := strconv.Atoi(input)
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+// Atoi converts a slice of strings to a slice of integers.
+// It panics if any element couldn't be converted.
+func Atoi(input []string) []int {
+	var result []int
+	for _, element := range input {
+		result = append(result, MustAtoi(element))
+	}
+	return result
+}

run.sh

@@ -6,7 +6,7 @@ docker image inspect $IMAGE >/dev/null 2>&1
 if [ $? -ne 0 ]
 then
     echo "One time setup: building docker image..."
-    cd docker
+    cd .docker
     docker build . -t $IMAGE
     cd ..
 fi