Runner & generator infra in Go, use it for 2022 day 20

Author: flwyd

2022/day20/day20.go

@@ -10,51 +10,24 @@
 day20 in Go since I could not figure out what was wrong with my Elixir
 solution so I figured I'd reimplement it in a different language to see if I
 had a hard-to-spot bug.  Turns out it was an unclear specification.
+XXX This program implements the incorrect interpretation of the problem
+(tea party guests move but chairs stay put); day20.exs implements the correct
+interpretation (tea party guests carry their chair around the table).
+https://www.reddit.com/r/adventofcode/comments/zrggym/2022_day_20_alice_in_wonderland_explains_the_two/
 */
 package main
 
 import (
-	"bufio"
-	"fmt"
 	"log"
-	"os"
-	"time"
+	"strconv"
 )
 
 func main() {
-	for _, arg := range os.Args[1:] {
-		fmt.Printf("Reading %s\n", arg)
-		f, err := os.Open(arg)
-		if err != nil {
-			log.Fatalf("Could not open %s: %v", arg, err)
-		}
-		defer f.Close()
-		ints := make([]int, 0, 5000)
-		s := bufio.NewScanner(f)
-		for s.Scan() {
-			var i int
-			if _, err := fmt.Sscanf(s.Text(), "%d", &i); err != nil {
-				log.Fatalf("Could not parse int %s: %v", s.Text(), err)
-			}
-			ints = append(ints, i)
-		}
-
-		fmt.Printf("Running part1 on %s (%d lines)\n", arg, len(ints))
-		start := time.Now()
-		res := part1(ints)
-		dur := time.Since(start)
-		fmt.Printf("part1: %d\n", res)
-		fmt.Printf("Finished part1 in %s on %s\n", dur, arg)
-
-		fmt.Printf("Running part2 on %s (%d lines)\n", arg, len(ints))
-		start = time.Now()
-		res = part2(ints)
-		dur = time.Since(start)
-		fmt.Printf("part2: %d\n", res)
-		fmt.Printf("Finished part2 in %s on %s\n", dur, arg)
-	}
+	runMain(part1, part2)
 }
 
+const dayName = "day20"
+
 type Node struct {
 	value      int
 	prev, next *Node
@@ -115,18 +88,32 @@ func (n *Node) toSlice() []int {
 	return ints
 }
 
-func part1(ints []int) int {
+func stringsToInts(strs []string) []int {
+	res := make([]int, len(strs))
+	for i, s := range strs {
+		x, err := strconv.Atoi(s)
+		if err != nil {
+			log.Fatalf("Invalid int %q at line %d: %v", s, i+1, err)
+		}
+		res[i] = x
+	}
+	return res
+}
+
+func part1(lines []string) string {
+	ints := stringsToInts(lines)
 	size := len(ints)
 	nodes := buildList(ints, 1)
 	for _, n := range nodes {
 		n.move(n.value % (size - 1))
 	}
-	return score(nodes)
+	return strconv.Itoa(score(nodes))
 }
 
 const part2Multiplier = 811589153
 
-func part2(ints []int) int {
+func part2(lines []string) string {
+	ints := stringsToInts(lines)
 	size := len(ints)
 	nodes := buildList(ints, part2Multiplier)
 	for i := 0; i < 10; i++ {
@@ -135,7 +122,7 @@ func part2(ints []int) int {
 			n.move(steps)
 		}
 	}
-	return score(nodes)
+	return strconv.Itoa(score(nodes))
 }
 
 func buildList(ints []int, multiplier int) []*Node {

2022/day20/runner.go

@@ -0,0 +1 @@
+../../lang/go/runner.go

README.md

@@ -31,23 +31,30 @@ think could be done better.
 
 ## Directory Structure
 
-Each year has one directory for each day’s solution, named `day1` through `day25`.
+Each year’s solutions are in a directory named after the year.  Within that dir
+is one directory for each day’s solution, named `day1` through `day25`.
 Each day directory has the solution code in one or more languages, a file named
 `input.example.txt` with an example taken from the problem description and
 `input.example.expected` with two lines (prefixed `part1: ` and `part2: `) with
 the expected output when the solution code is run `input.example.txt`.  If the
 problem description has multiple examples, they’ll be in `input.example2.txt`
-and `input.example2.expected`, etc.  The `input.actual.txt` and
-`input.actual.expected` files are symlinks into a non-public directory with
-input specific to my AoC account.  If you’d like to test my code against your
-personal input, provide the path to your input as a command line argument:
-`day1/day1.exs -v path/to/my/input.txt`.  If you’d like to run a whole suite of
-solutions against your input, make sure they’re in a directory with numbered
-subdirectories, e.g. `1/input.actual.txt` and replace my `input` directory with
-a symlink to yours, e.g. `rm 2023/input; ln -s path/to/my/2023 2023/input` which
-will cause `runday` and `testday` scripts to use yours.  Alternatively,
-substitute the `input` submodule at the base of the repository, as in the next
-section.
+and `input.example2.expected`, etc.
+
+The `input.actual.txt` and `input.actual.expected` files are symlinks into a
+non-public directory with input specific to my AoC account.  If you’d like to
+test my code against your personal input, provide the path to your input as a
+command line argument: `day1/day1.exs -v path/to/my/input.txt`.  If you’d like
+to run a whole suite of solutions against your input, make sure they’re in a
+directory with numbered subdirectories, e.g. `1/input.actual.txt` and replace
+my `input` directory with a symlink to yours, e.g. `rm 2023/input; ln -s
+path/to/my/2023 2023/input` which will cause `runday` and `testday` scripts to
+use yours.  Alternatively, substitute the `input` submodule at the base of the
+repository, as in the next section.
+
+There is also a `lang` directory for runner and generator infrastructure for
+programming languages which aren’t “the main language” for any year, but which I
+sometimes use for fun or because I got stuck on a problem with the main new
+language for a year.
 
 ## Hiding Private Advent of Code Input with Git Submodules
 

lang/go/generate.go

@@ -0,0 +1,93 @@
+// Copyright 2023 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+// generate creates a skeletal go program to solve a day's Advent of Code
+// problem, using runner.go to read input and log results.
+package main
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+)
+
+const shebang = "///usr/bin/true; exec /usr/bin/env go run \"$0\" \"`dirname $0`/runner.go\" \"$@\""
+const dayCode = `// Copyright 2023 Google LLC
+//
+// Use of this source code is governed by an MIT-style
+// license that can be found in the LICENSE file or at
+// https://opensource.org/licenses/MIT.
+
+package main
+
+func part1(lines []string) string {
+	return "TODO"
+}
+
+func part2(lines []string) string {
+	return "TODO"
+}
+
+func main() {
+	runMain(part1, part2)
+}
+`
+
+func main() {
+	if len(os.Args) != 2 {
+		log.Fatalf("Usage: %s path/to/dayX", os.Args[0])
+	}
+	outdir := os.Args[1]
+	if err := os.MkdirAll(outdir, 0755); err != nil {
+		log.Fatalf("Could not create %s: %v", outdir, err)
+	}
+	dayname := filepath.Base(outdir)
+	dayvar := fmt.Sprintf("const dayName = %q", dayname)
+	code := shebang + "\n" + dayCode + "\n" + dayvar + "\n"
+	gofile := filepath.Join(outdir, dayname+".go")
+	if fileExists(gofile) {
+		log.Fatalf("%s already exists, exiting", gofile)
+	}
+	if err := os.WriteFile(gofile, []byte(code), 0755); err != nil {
+		log.Fatalf("Error writing to %s: %v", gofile, err)
+	}
+	// create a symlink to runner.go, which is adjacent to generate.go
+	runnerlink := filepath.Join(outdir, "runner.go")
+	if !fileExists(runnerlink) {
+		_, prog, _, ok := runtime.Caller(0)
+		if !ok {
+			log.Fatalf("Could not determine executable path, make sure to symlink runner.go")
+		}
+		runner := filepath.Join(filepath.Dir(prog), "runner.go")
+		abs, err := filepath.Abs(outdir)
+		if err != nil {
+			log.Fatalf("Can't determine absolute path of %s: %v", outdir, err)
+		}
+		rel, err := filepath.Rel(abs, runner)
+		if err != nil {
+			log.Fatalf("Can't determine relative path of %s from %s: %v", runner, abs, err)
+		}
+		if err = os.Symlink(rel, runnerlink); err != nil {
+			log.Fatalf("Error creating symlink to %s as %s: %v", rel, runnerlink, err)
+		}
+	}
+	// doesn't create input.example.txt, input.example.expected, etc. because the
+	// year's main generator has typically already made them
+}
+
+func fileExists(fname string) bool {
+	_, err := os.Stat(fname)
+	if errors.Is(err, os.ErrNotExist) {
+		return false
+	}
+	if err != nil {
+		log.Printf("Error checking %s: %v", fname, err)
+	}
+	return true
+}