2020 folder setup

2020/README.md

@@ -4,3 +4,14 @@ To run days for 2020, I'm planning on using `go test -run RegExpToMatchFunctionN
 `go run main.go -part <1 or 2>` will be usable to run the actual inputs for that day
 
 Scripts have been added to the outer folder to setup files for a particular day more easily
+```zsh
+for ((i=1; i<26; i++)); do
+go run ../scripts/template/template.go -day $i -year 2020
+done
+```
+
+and to fetch input prompts
+```go
+// optional -day and -year flags with sensible defaults (today)
+go run ../scripts/fetchers/cmd-inputs.go
+```

2020/day01/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day01/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day02/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day02/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day03/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day03/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day04/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day04/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day05/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day05/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day06/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day06/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day07/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day07/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day08/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day08/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day09/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day09/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day10/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day10/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day11/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day11/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day12/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day12/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day13/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day13/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day14/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day14/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day15/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day15/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day16/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day16/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day17/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day17/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day18/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day18/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day19/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day19/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day20/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day20/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day21/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day21/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day22/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day22/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day23/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day23/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day24/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day24/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

2020/day25/main.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func main() {
+	var part int
+	flag.IntVar(&part, "part", 1, "part 1 or 2")
+	fmt.Println("Running part", part)
+
+	if part == 1 {
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	} else {
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
+	}
+}
+
+func part1(input string) int {
+	return 0
+}
+
+func part2(input string) int {
+	return 0
+}

2020/day25/main_test.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"testing"
+	
+	"github.com/alexchao26/advent-of-code-go/util"
+)
+
+func TestPart1(t *testing.T) {
+	// Examples
+	
+	// Run actual problem input
+	// part1(util.ReadFile("input.txt"))
+}
+
+func TestPart2(t *testing.T) {
+	// Examples
+
+	// Run actual problem input
+	// part2(util.ReadFile("input.txt"))
+}

scripts/fetchers/fetchers.go

@@ -16,8 +16,10 @@ func panicWrap(err error, str string) {
 }
 
 func ParseFlags() (day, year int, cookie string) {
-	flag.IntVar(&day, "day", time.Now().Day(), "day number to fetch, 1-25")
-	flag.IntVar(&year, "year", 2020, "AOC year")
+	today := time.Now()
+	flag.IntVar(&day, "day", today.Day(), "day number to fetch, 1-25")
+	flag.IntVar(&year, "year", today.Year(), "AOC year")
+	// env variable set via .bash_profile/.zshenv/etc
 	flag.StringVar(&cookie, "cookie", os.Getenv("AOC_SESSION_COOKIE"), "AOC session cookie")
 	flag.Parse()
 

scripts/template/template.go

@@ -53,9 +53,11 @@ func main() {
 	fmt.Println("Running part", part)
 
 	if part == 1 {
-		part1(util.ReadFile("./input.txt"))
+		ans := part1(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
 	} else {
-		part2(util.ReadFile("./input.txt"))
+		ans := part2(util.ReadFile("./input.txt"))
+		fmt.Println("Output:", ans)
 	}
 }