2023 day 10

2023/10/part1/cmd/main.go

@@ -0,0 +1,16 @@
+
+package main
+
+import (
+	"bufio"
+	"os"
+	"git.tristans.cloud/tristan/aoc/2023/10/part1/lib"
+)
+
+func main() {
+	scanner := bufio.NewScanner(os.Stdin);
+	pipeMap := part1.ReadMap(scanner)
+	size := part1.LoopSize(pipeMap)
+	println(size / 2)
+}
+

2023/10/part1/lib/lib.go

@@ -0,0 +1,89 @@
+
+package part1
+
+import (
+	"bufio"
+	"strings"
+)
+
+var Tiles = map[byte][2][2]int{
+	'|': {{0,-1}, {0,1}},
+	'-': {{-1,0}, {1,0}},
+	'L': {{0,-1}, {1,0}},
+	'J': {{0,-1}, {-1,0}},
+	'7': {{0,1}, {-1,0}},
+	'F': {{0,1}, {1,0}},
+}
+
+func ReadMap(scanner *bufio.Scanner) (res []string) {
+	for scanner.Scan() {
+		res = append(res, scanner.Text())
+	}
+	return
+}
+
+func FindStart(pipeMap []string) (x,y int) {
+	for y = range pipeMap {
+		if x = strings.IndexRune(pipeMap[y], 'S'); x > -1 {
+			return
+		}
+	}
+	return -1, -1
+}
+
+func FindFirst(pipeMap []string, sx,sy int) (int, int, int) {
+	for y := sy-1; y <= sy+1;y++ {
+		if y < 0 || y >= len(pipeMap) {
+			continue
+		}
+		for x := sx-1; x <= sx+1 ;x++ {
+			if x < 0 || x >= len(pipeMap[y]) {
+				continue
+			}
+			side, ok := GetSide(pipeMap, sx,sy, x,y)
+			if ok {
+				return side,x,y
+			}
+		}
+	}
+	return -1, -1, -1
+}
+
+func GetSide(pipeMap []string, px,py, x,y int) ( int, bool ) {
+	tile := pipeMap[y][x]
+	dirs, ok := Tiles[tile]
+	if !ok {
+		return -1, false
+	}
+	for i,dir := range dirs {
+		if x + dir[0] == px && y + dir[1] == py {
+			return i, true
+		}
+	}
+	return -1, false
+}
+
+
+func FindNext(pipeMap []string, side, x,y int) (int,int,int) {
+	tile := pipeMap[y][x]
+
+	dir := Tiles[tile][1-side]
+
+	nx,ny := x+dir[0], y+dir[1]
+
+	nside, _ := GetSide(pipeMap, x,y, nx,ny)
+	return nside,nx,ny
+}
+
+func LoopSize(pipeMap []string) int {
+	x,y := FindStart(pipeMap)
+	side,x,y := FindFirst(pipeMap, x,y)
+	count := 1
+	for pipeMap[y][x] != 'S' {
+		count++
+		side,x,y = FindNext(pipeMap, side, x,y)
+	}
+	return count
+
+}
+

2023/10/part1/lib/lib_test.go

@@ -0,0 +1,131 @@
+
+package part1
+
+import (
+	"testing"
+	"reflect"
+	"bufio"
+	"strings"
+)
+
+const basicInput =
+	".....\n" +
+	".S-7.\n" +
+	".|.|.\n" +
+	".L-J.\n" +
+	".....\n"
+
+var basicMap = []string{
+	".....",
+	".S-7.",
+	".|.|.",
+	".L-J.",
+	".....",
+}
+
+const complexInput = 
+	"7-F7-\n" +
+	".FJ|7\n" +
+	"SJLL7\n" +
+	"|F--J\n" +
+	"LJ.LJ\n"
+
+var complexMap = []string{
+	"7-F7-",
+	".FJ|7",
+	"SJLL7",
+	"|F--J",
+	"LJ.LJ",
+}
+
+func TestReadMap(t *testing.T) {
+	reader := bufio.NewScanner(strings.NewReader(basicInput));
+	pipes := ReadMap(reader)
+	equal(t, pipes, basicMap)
+}
+
+func TestReadMapComplex(t *testing.T) {
+	reader := bufio.NewScanner(strings.NewReader(complexInput));
+	pipes := ReadMap(reader)
+	equal(t, pipes, complexMap)
+}
+
+func TestFindStart(t *testing.T) {
+	x,y := FindStart(basicMap)
+	equal(t, x, 1)
+	equal(t, y, 1)
+}
+
+func TestFindStartComplex(t *testing.T) {
+	x,y := FindStart(complexMap)
+	equal(t, x, 0)
+	equal(t, y, 2)
+}
+
+func TestFindFirstBasic(t *testing.T) {
+	x,y := 1,1
+	side,newX,newY := FindFirst(basicMap, x,y)
+	equal(t, side, 0)
+	equal(t, newX, 2)
+	equal(t, newY, 1)
+}
+
+func TestFindFirstComplex(t *testing.T) {
+	x,y := 0, 2
+	side,newX,newY := FindFirst(complexMap, x,y)
+	equal(t, side, 1)
+	equal(t, newX, 1)
+	equal(t, newY, 2)
+}
+
+func TestGetSide(t *testing.T) {
+	side,ok := GetSide(basicMap, 1,1, 2,1)
+	equal(t, side, 0)
+	equal(t, ok, true)
+}
+
+func TestFindNext(t *testing.T) {
+	cx,cy := 2,1
+
+	s,nx,ny := FindNext(basicMap, 0, cx,cy)
+	equal(t, nx, 3)
+	equal(t, ny, 1)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 3)
+	equal(t, ny, 2)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 3)
+	equal(t, ny, 3)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 2)
+	equal(t, ny, 3)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 1)
+	equal(t, ny, 3)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 1)
+	equal(t, ny, 2)
+
+	s,nx,ny = FindNext(basicMap, s, nx,ny)
+	equal(t, nx, 1)
+	equal(t, ny, 1)
+}
+
+func TestLoopSize(t *testing.T) {
+	size := LoopSize(basicMap)
+	equal(t, size, 8)
+	size = LoopSize(complexMap)
+	equal(t, size, 16)
+}
+
+func equal(t *testing.T, actual any, target any) {
+	if !reflect.DeepEqual(actual, target) {
+		t.Errorf("expected %v, got %v", target, actual)
+	}
+}
+