day12

Author: DWethmar

day12.sh

@@ -0,0 +1,11 @@
+#! /bin/bash
+
+CHALLENGE=day12
+
+go build -o $(pwd)/bin/$CHALLENGE ./$CHALLENGE/*.go
+
+echo "Tests 1" 
+cat $CHALLENGE/input_test_01.txt | bin/$CHALLENGE
+
+echo "Tests 2"
+cat $CHALLENGE/input.txt | bin/$CHALLENGE

day12/debug.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	TopLeftCorner     = '╔'
+	TopRightCorner    = '╗'
+	BottomLeftCorner  = '╚'
+	BottomRightCorner = '╝'
+	VerticalLine      = '║'
+	HorizontalLine    = '═'
+)
+
+func PrintGrid(grid Grid) {
+	fmt.Print("  ")
+	for i := 0; i < len(grid[0]); i++ {
+		fmt.Printf("%d", i%10)
+	}
+	fmt.Println()
+
+	fmt.Printf(" %s", string(TopLeftCorner))
+	fmt.Print(strings.Repeat(string(HorizontalLine), len(grid[0])))
+	fmt.Print(string(TopRightCorner))
+	fmt.Println()
+
+	for i, row := range grid {
+		fmt.Printf("%d%s", i%10, string(VerticalLine))
+		for _, r := range row {
+			fmt.Printf("%c", r)
+		}
+		fmt.Print(string(VerticalLine))
+		fmt.Println()
+	}
+
+	fmt.Printf(" %s", string(BottomLeftCorner))
+	fmt.Print(strings.Repeat(string(HorizontalLine), len(grid[0])))
+	fmt.Print(string(BottomRightCorner))
+	fmt.Println()
+}

day12/grid.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"io"
+
+	"github.com/dwethmar/adventofcode2022/pkg/iterate"
+)
+
+type Grid [][]rune
+
+func (g Grid) Get(x, y int) rune {
+	return g[y][x]
+}
+
+func CreateGrid(in io.Reader) (grid Grid, err error) {
+	i := 0
+	err = iterate.Lines(in, func(s string) iterate.Step {
+		if grid == nil {
+			grid = make(Grid, 0)
+		}
+
+		grid = append(grid, make([]rune, len(s)))
+
+		for j, r := range s {
+			grid[i][j] = r
+		}
+
+		i++
+
+		return iterate.Continue
+	})
+
+	return
+}
+
+func FindPoints(grid Grid, p ...rune) []*Point {
+	points := make([]*Point, 0)
+
+	for y, row := range grid {
+		for x, r := range row {
+			for _, c := range p {
+				if r == c {
+					points = append(points, &Point{x, y})
+				}
+			}
+		}
+	}
+
+	return points
+}

day12/input.txt

@@ -0,0 +1,41 @@
+abcccccccccccccccccccccccccccccccccccccaaaaaaacccccccaaaaaaaaaaaccccccccccccccccccccaaacaaaaaaaacccccccccccccccccccccccccccccccccccaaaaa
+abccccccccccccccccccaaccaacccccccccccccaaaaaaaccccccccaaaaaaaaaaacccccccaaaaccccccccaaaaaaaaaaaaacccccccccccccccccccccccccccccccccaaaaaa
+abccccccccccccccccccaaaaaaccccccccccaaaccaaaaaacccccccaaaaaaaaaaccccccccaaaaccccccaaaaaaaaaaaaaaacccccccccccccccccccaaacccccccccccaaaaaa
+abcccccccccccccccccccaaaaacccccccccccaaccaacaaaccccccaaaaaaaaaaaccccccccaaaacccccaaaaaaaaacaaaaaaacccccccccccccccccaaaacccccccccccaaacaa
+abccccccccccccccccccaaaaaaccccccccaacaaaaaacccccccccaaaaaaaaaaaaacaaaccccaaccccccaaaaaaaaacaacccccccccccccccccaaaccaaaacccccccccccccccaa
+abcccccccccccccccccaaaaaaaacccccccaaaaaaaaccccccaaaaaaaacaaaacaaaaaaacccccccccaaccccaaaaaacaaacccccccccccccccaaaakkkaaccccccccccccccccaa
+abcccccccccccccccccaaaaaaaaccccccccaaaaaccccaacccaaaaaaaaaaaacaaaaaaccccccccccaacccaaaaaaaaaaaacccccccccccccccakkkkkklcccccccccccccccccc
+abaaacccccccccccaaccccaaccccccccccccaaaaaccaaacccaaaaaaaaaaaaaaaaaaaaccccccaaaaaaaacaacccaaaaaaccccccccccccccckkkkkkkllcccccccaaaccccccc
+abaaaacccccccaacaaccccaacccccccccccaaacaaaaaaaccccaaaaaaaaaaaaaaaaaaaacccccaaaaaaaaaaaccccaaaaacccccccccccccckkkksssllllccccccaaaaaacccc
+abaaaacccccccaaaaacccccccccccaaaccccaacaaaaaaccccaaaaaacaaaaaaaaaaaaaacccccccaaaaccccccccaaaaacccccccccccccckkkksssssllllcccccaaaaaacccc
+abaaacccccccccaaaaaaccccccccaaaaccccccccaaaaaaaacaaaaaaaaaaaaacaaacaaacccccccaaaaacccccccaaaaacccccccccccccjkkkrssssssllllccccccaaaccccc
+abccccccccccaaaaaaaaccccccccaaaacccccccaaaaaaaaacaacaaaaaaaaaacaaaccccccccccaaacaaccccccccccccccccccccccccjjkkrrsuuussslllllcccccaaccccc
+abccaaacccccaaaaacccccccccccaaaaccccccaaaaaaaaaacccccaaaaaaaaaacaaccccccccccaacccacccccccccccccccccccccjjjjjjrrrsuuuussslllllmcccddacccc
+abcccaaaccaccacaaaccccccccccccccccccccaaaaaaaccccccccccaaaaaaaaccccccaacccccccccccaaaaacccccccccccccccjjjjjjrrrruuuuuusssllmmmmmddddcccc
+abccaaaaaaaacccaaaccccccccccccccccaaacccccaaaccccccccccccaaacccccccccaacccccccccccaaaaacccccccccccccjjjjjrrrrrruuuxuuussqqqqmmmmmdddcccc
+abcaaaaaaaacccaaaaaacaaaaaccccccaaaaaaccccaaacccaaccccccccaaccccccaaaaaaaaccaaacccaaaaaaccccccccccccjjjjrrrrrruuuxxxuuuqqqqqqqmmmdddcccc
+abaaaaaaaaaccccaaaaacaaaaaccccccaaaaaaaaccccccaaaaaaccccccccccccccaaaaaaaaccaaacaaaaaaaacccccccccccjjjjrrrtttuuuuxxxyvvvvvqqqqmmmdddcccc
+abaaaaaaaaaccaaaaaaacaaaaaaccccccaaaaaaaacccccaaaaaaccccccccccccccccaaaaccaaaaaaaaaaaaaacccccccccaaiijqqqrttttuuuxxyyvvvvvvvqqmmmdddcccc
+abcaaaaaaaaccaaaaaaaaaaaaaacccccaaaaaaaacccccccaaaacccccaaaaccccccccaaaaacaaaaaaaaccaaccccccccccaaaiiiqqqttttxxxxxxyyyyyyvvvqqmmmdddcccc
+abcccaaaaaaacaaaaaaaaaaaaaacccccaaaaaaaaaaaccccaaaaccccaaaaacccccccaaaaaacaaaaaaacccccccccccccccaaaiiiqqqtttxxxxxxxyyyyyyvvqqqmmmdddcccc
+SbcccaacccaccccaaacacccaaacccccccccaaaaaaaaacccaccaccccaaaaaaccccccaaccaacccaaaaaccccccccccccccccaaiiiiqqtttxxxxEzzzyyyyvvvqqqmmmddccccc
+abccaaaccccccccaaccccccccccccccccccaaaaaaaaccccccccccccaaaaaaccccccccccccccaaacaaaccaacccccccccccccciiiqqqttttxxxyyyyyvvvvqqqmmmdddccccc
+abccccccccccccccccccccccccccccccccaaaaaaaccccccccccccccaaaaaacccccccccccccccaacccccaaaaaaaccccccccccciiiqqqttttxxyyyyyvvvrrrnnneeecccccc
+abcaaaaccccccccccccccccccccccccccaaaaaaaaccccccccccccccccaacccccccccccccccccccccccccaaaaacccccccccccciiiqqqqttxxyyyyyyyvvrrnnnneeecccccc
+abcaaaaacccccccccccccccccccccccccaaaacaaacccaccaaacccccccccccccccccccccccccaaaccccaaaaaaaccccccccccccciiiqqqttwwyywwyyywwrrnnneeeccccccc
+abaaaaaacccaccaccccccccccccccccccaaaaccaacccaaaaaaccccccccccccccccaaaccccaaaaaacccaaaaaaaacccccccccccciiiqqqtswwwwwwwwwwwrrnnneeeccccccc
+abaaaaaacccaaaaccccccccaaaacccccccaaacccccccaaaaaacccccccccccccccaaaaaaccaaaaaacccaaaaaaaacaaccccccaaciiiqppsswwwwsswwwwwrrrnneeeccccccc
+abcaaaaacccaaaaacccccccaaaacccccccccccccccccaaaaaaaccccccccccccccaaaaaaccaaaaaacccccaaaaaaaaaccccccaaaahhpppssswwsssswwwwrrrnneeeacccccc
+abcaaaccccaaaaaacccccccaaaaccccccccccccccccaaaaaaaaccccccccccccccaaaaacccaaaaaccccccaacaaaaaaaaccaaaaaahhpppsssssssssrrrrrrnnneeeacccccc
+abccccccccaaaaaaccccccccaacccccccccccccccccaaaaaaaaccccaacccccccccaaaaaccaaaaacccccccccaaaaaaaaccaaaaachhpppssssssoosrrrrrrnnneeeaaacccc
+abccccccccccaaccccccccccccccccaaaaaccccccaacccaaacccaaaaacccccccccaacaacccccccccccccccccaaaaaaacccaaaaahhhppppssppooooorroonnffeaaaacccc
+abaaccccccccccccccccccccccccccaaaaaccccccaacccaaaccccaaaaacccccccccccccccccccccccccccaacaaaaacccccaacaahhhppppppppoooooooooonfffaaaacccc
+abaccccccccccccccccccccccccccaaaaaacccaaaaaaaacccccccaaaaaccccccccccccccccccccccccaaaaaaaaaaaccccccccccchhhpppppppgggoooooooffffaacccccc
+abaccccccccccccccccccccccccccaaaaaacccaaaaaaaaccccccaaaaaccccccacccaacccccccccccccaaaaaccccaaccccccccccchhhhhhggggggggfffffffffaaacccccc
+abaacccccccccccccccccccccccccaaaaaacccccaaaacccccccccaaaacccaacaacaaacccccccccccccaaaaaaacccccccccccccccchhhhgggggggggffffffffccaacccccc
+abcccccccaacccccccccccccccccccaaaccccccaaaaaccccccccaaaaccaaaacaaaaacccccccccccccaaaaaaaaccccccccccccccccchhhggggaaaagffffffcccccccccccc
+abcccccccaacccccccccccccaacccccccccccccaaaaaaccaaccccaaaaaaaaacaaaaaacccccccaaaacaaaaaaaacccccccccccaacccccccaaaacaaaacccccccccccccccccc
+abccccaaaaaaaacccccccaacaaaccccccccccccaaccaacaaaacccaaaaaaaacaaaaaaaaccccccaaaaccacaaaccaaaccccaaaaaacccccccaacccaaaacccccccccccccaaaaa
+abccccaaaaaaaacccccccaaaaaccccccccccccccccccccaaaaccccaaaaaaacaaaaaaaaccccccaaaaccccaaaccaaaaaccaaaaaaaacccccccccccaaaccccccccccccccaaaa
+abccccccaaaaccccccccccaaaaaaccccccccccccccccccaaaacccaaaaaaaaaaccaaccccccccccaacccccccccaaaaacccaaaaaaaacccccccccccaaaccccccccccccccaaaa
+abcccccaaaaaacccccccaaaaaaaacccccccccccccccccccccccaaaaaaaaaaaaaaaacccccccccccccccccccccaaaaaacccaaaaaaaccccccccccccccccccccccccccaaaaaa

day12/input_test_01.txt

@@ -0,0 +1,5 @@
+Sabqponm
+abcryxxl
+accszExk
+acctuvwj
+abdefghi

day12/main.go

@@ -0,0 +1,148 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math"
+	"os"
+	"sort"
+	"strings"
+	"sync"
+)
+
+const Alphabet = "abcdefghijklmnopqrstuvwxyz"
+
+type Point struct {
+	X, Y int
+}
+
+func (p Point) String() string { return fmt.Sprintf("(%d, %d)", p.X, p.Y) }
+
+func (p Point) Distance(p2 *Point) int {
+	return int(math.Abs(float64(p.X-p2.X)) + math.Abs(float64(p.Y-p2.Y)))
+}
+
+func main() {
+	grid, err := CreateGrid(os.Stdin)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	path := GetPathToSignal(grid)
+
+	fmt.Printf("Part 1: %d: %+v\n", len(path)-1, path)
+}
+
+func GetPathToSignal(grid Grid) (path []*Point) {
+	PrintGrid(grid)
+
+	p := FindPoints(grid, 'S', 'E')
+	if len(p) != 2 {
+		log.Fatal("Could not find start and end point")
+	}
+
+	return Walk(grid, p[0], p[1], []string{p[0].String()})
+}
+
+func GetHeight(grid Grid, p *Point) int {
+	r := grid.Get(p.X, p.Y)
+	if r == 'S' { // Your current position (S) has elevation a.
+		return 0
+	} else if r == 'E' { // location that should get the best signal (E) has elevation z.
+		return 25
+	}
+
+	return strings.IndexRune(Alphabet, r)
+}
+
+func Walk(grid Grid, start *Point, end *Point, walked []string) []*Point {
+	path := []*Point{
+		start,
+	}
+
+	currentHeight := GetHeight(grid, start)
+
+	neighbors := []*Point{
+		// up
+		{start.X, start.Y - 1},
+		// down
+		{start.X, start.Y + 1},
+		// left
+		{start.X - 1, start.Y},
+		// right
+		{start.X + 1, start.Y},
+	}
+
+	// sort neighbors by distance to end
+	sort.Slice(neighbors, func(i, j int) bool {
+		return neighbors[i].Distance(end) < neighbors[j].Distance(end)
+	})
+
+	directions := map[string][]*Point{}
+
+	wg := sync.WaitGroup{}
+
+	for _, n := range neighbors {
+		// Check if we are out of bounds
+		if n.X < 0 || n.Y < 0 || n.X >= len(grid[0]) || n.Y >= len(grid) {
+			continue
+		}
+
+		// Check if we have already walked this path
+		if contains(walked, n.String()) {
+			continue
+		}
+
+		height := GetHeight(grid, n)
+
+		// Check if we can walk to this point
+		if math.Abs(float64(currentHeight-height)) > 1 {
+			continue
+		}
+
+		walked = append(walked, n.String())
+
+		newWalked := make([]string, len(walked))
+		copy(newWalked, walked)
+
+		wg.Add(1)
+
+		go func(p Point) {
+			// Walk to the next point
+			directions[p.String()] = Walk(grid, &p, end, newWalked)
+
+			defer wg.Done()
+		}(*n)
+	}
+
+	wg.Wait()
+
+	shortest := 0
+	shortestPath := ""
+
+	// Find the shortest path
+	for n, p := range directions {
+		// Check if the path is empty
+		if len(p) == 0 {
+			continue
+		}
+
+		// has reached end?
+		if p[len(p)-1].String() != end.String() {
+			continue
+		}
+
+		// Check if this is the shortest path
+		if shortest == 0 || len(p) < shortest {
+			shortest = len(p)
+			shortestPath = n
+		}
+	}
+
+	// Add the shortest path to the path
+	if shortestPath != "" {
+		path = append(path, directions[shortestPath]...)
+	}
+
+	return path
+}