2023 Day 13 Complete!

2023/day13/main.go

@@ -0,0 +1,194 @@
+package main
+
+import (
+	"fmt"
+
+	h "git.bullercodeworks.com/brian/adventofcode/helpers"
+)
+
+func main() {
+	inp := h.StdinToStringSlice()
+	part1(inp)
+	fmt.Println()
+	part2(inp)
+}
+
+func part1(input []string) {
+	var maps []*h.CoordByteMap
+	var wrkInput []string
+	bld := func() {
+		m := h.StringSliceToCoordByteMap(wrkInput)
+		maps = append(maps, &m)
+		wrkInput = []string{}
+	}
+	for i := range input {
+		if len(input[i]) == 0 {
+			bld()
+		} else {
+			wrkInput = append(wrkInput, input[i])
+		}
+	}
+	if len(wrkInput) > 0 {
+		bld()
+	}
+
+	var result int
+	for _, m := range maps {
+		result += findMirror(m, -1)
+	}
+	fmt.Println("# Part 1")
+	fmt.Println(result)
+}
+
+func part2(input []string) {
+	var maps []*h.CoordByteMap
+	var wrkInput []string
+	bld := func() {
+		m := h.StringSliceToCoordByteMap(wrkInput)
+		maps = append(maps, &m)
+		wrkInput = []string{}
+	}
+	for i := range input {
+		if len(input[i]) == 0 {
+			bld()
+		} else {
+			wrkInput = append(wrkInput, input[i])
+		}
+	}
+	if len(wrkInput) > 0 {
+		bld()
+	}
+
+	var result int
+	for _, m := range maps {
+		result += checkForSmudge(m)
+	}
+	fmt.Println("# Part 2")
+	fmt.Println(result)
+}
+
+func checkForSmudge(m *h.CoordByteMap) int {
+	origMirror := findMirror(m, -1)
+	for y := m.TLY; y <= m.BRY; y++ {
+		for x := m.TLX; x <= m.BRX; x++ {
+			orig := m.Get(c(x, y))
+			switch orig {
+			case '#':
+				m.Put(c(x, y), '.')
+			case '.':
+				m.Put(c(x, y), '#')
+			}
+			res := findMirror(m, origMirror)
+			if res > 0 && res != origMirror {
+				return res
+			}
+			m.Put(c(x, y), orig)
+		}
+	}
+	return 0
+}
+
+// findMirror finds a mirror in the map
+// returning the value of that mirror (vertical (x+1), horizontal (y+1)* 100)
+func findMirror(m *h.CoordByteMap, exclude int) int {
+	var found bool
+	for x := m.TLX; x <= m.BRX; x++ {
+		val := (x + 1)
+		if found = checkForVerticalMirror(m, x, x+1); found && val != exclude {
+			return x + 1
+		}
+	}
+	for y := m.TLY; y <= m.BRY; y++ {
+		val := (y + 1) * 100
+		if found = checkForHorizontalMirror(m, y, y+1); found && val != exclude {
+			return (y + 1) * 100
+		}
+	}
+	return 0
+}
+
+func c(x, y int) h.Coordinate {
+	return h.Coordinate{X: x, Y: y}
+}
+
+func checkForVerticalMirror(m *h.CoordByteMap, x1, x2 int) bool {
+	var wrkX1, wrkX2 int
+	for y := m.TLY; y <= m.BRY; y++ {
+		wrkX1, wrkX2 = x1, x2
+		var match, cont bool
+		for wrkX1 >= m.TLX || wrkX2 <= m.BRX {
+			if match, cont = hPointsMatch(m, y, wrkX1, wrkX2); match {
+				if cont {
+					break
+				}
+				wrkX1--
+				wrkX2++
+			} else {
+				return false
+			}
+		}
+		if cont {
+			continue
+		}
+		if wrkX1 < m.TLX || wrkX2 > m.BRX {
+			return false
+		}
+	}
+	// Mirrors _shouldn't_ be at the very edge (or else what are we even doing here)
+	if wrkX1 == m.BRX || wrkX2 == m.TLX {
+		return false
+	}
+	return true
+}
+
+func hPointsMatch(m *h.CoordByteMap, y, x1, x2 int) (bool, bool) {
+	c1, c2 := c(x1, y), c(x2, y)
+	// If either is off the map, it could be
+	if m.Opt(c1, byte(0)) == 0 || m.Opt(c2, byte(0)) == 0 {
+		return true, true
+	}
+	// Check if (x1, y) == (x2, y)
+	v1, v2 := m.Get(c1), m.Get(c2)
+	return v1 == v2, false
+}
+
+func checkForHorizontalMirror(m *h.CoordByteMap, y1, y2 int) bool {
+	var wrkY1, wrkY2 int
+	for x := m.TLX; x <= m.BRX; x++ {
+		wrkY1, wrkY2 = y1, y2
+		var match, cont bool
+		for wrkY1 >= m.TLY || wrkY2 <= m.BRY {
+			if match, cont = vPointsMatch(m, x, wrkY1, wrkY2); match {
+				if cont {
+					break
+				}
+				wrkY1--
+				wrkY2++
+			} else {
+				return false
+			}
+		}
+		if cont {
+			continue
+		}
+		if wrkY1 > m.TLY && wrkY2 < m.BRY {
+			return false
+		}
+	}
+	// Mirrors _shouldn't_ be at the very edge (or else what are we even doing here)
+	if wrkY1 == m.BRY || wrkY2 == m.TLY {
+		return false
+	}
+	return true
+}
+
+func vPointsMatch(m *h.CoordByteMap, x, y1, y2 int) (bool, bool) {
+	c1, c2 := c(x, y1), c(x, y2)
+	// If either is off the map, it could be
+	if m.Opt(c1, byte(0)) == 0 || m.Opt(c2, byte(0)) == 0 {
+		return true, true
+	}
+	// Check if (x, y1) == (x, y2)
+	v1, v2 := m.Get(c1), m.Get(c2)
+	return v1 == v2, false
+}

2023/day13/problem

@@ -0,0 +1,222 @@
+                               [1]Advent of Code
+
+     • [2][About]
+     • [3][Events]
+     • [4][Shop]
+     • [5][Settings]
+     • [6][Log Out]
+
+   br0xen [7](AoC++) 26*
+
+                                     /*[8]2023*/
+
+     • [9][Calendar]
+     • [10][AoC++]
+     • [11][Sponsors]
+     • [12][Leaderboard]
+     • [13][Stats]
+
+   Our [14]sponsors help make Advent of Code possible:
+   [15]Jane Street - Will our next great idea come from you? We hire smart,
+   humble people who love to solve problems, build systems, and test
+   theories. Our success is driven by our people and we never stop improving.
+
+--- Day 13: Point of Incidence ---
+
+   With your help, the hot springs team locates an appropriate spring which
+   launches you neatly and precisely up to the edge of Lava Island.
+
+   There's just one problem: you don't see any lava.
+
+   You do see a lot of ash and igneous rock; there are even what look like
+   gray mountains scattered around. After a while, you make your way to a
+   nearby cluster of mountains only to discover that the valley between them
+   is completely full of large mirrors. Most of the mirrors seem to be
+   aligned in a consistent way; perhaps you should head in that direction?
+
+   As you move through the valley of mirrors, you find that several of them
+   have fallen from the large metal frames keeping them in place. The mirrors
+   are extremely flat and shiny, and many of the fallen mirrors have lodged
+   into the ash at strange angles. Because the terrain is all one color, it's
+   hard to tell where it's safe to walk or where you're about to run into a
+   mirror.
+
+   You note down the patterns of ash (.) and rocks (#) that you see as you
+   walk (your puzzle input); perhaps by carefully analyzing these patterns,
+   you can figure out where the mirrors are!
+
+   For example:
+
+ #.##..##.
+ ..#.##.#.
+ ##......#
+ ##......#
+ ..#.##.#.
+ ..##..##.
+ #.#.##.#.
+
+ #...##..#
+ #....#..#
+ ..##..###
+ #####.##.
+ #####.##.
+ ..##..###
+ #....#..#
+
+   To find the reflection in each pattern, you need to find a perfect
+   reflection across either a horizontal line between two rows or across a
+   vertical line between two columns.
+
+   In the first pattern, the reflection is across a vertical line between two
+   columns; arrows on each of the two columns point at the line between the
+   columns:
+
+ 123456789
+     ><
+ #.##..##.
+ ..#.##.#.
+ ##......#
+ ##......#
+ ..#.##.#.
+ ..##..##.
+ #.#.##.#.
+     ><
+ 123456789
+
+   In this pattern, the line of reflection is the vertical line between
+   columns 5 and 6. Because the vertical line is not perfectly in the middle
+   of the pattern, part of the pattern (column 1) has nowhere to reflect onto
+   and can be ignored; every other column has a reflected column within the
+   pattern and must match exactly: column 2 matches column 9, column 3
+   matches 8, 4 matches 7, and 5 matches 6.
+
+   The second pattern reflects across a horizontal line instead:
+
+ 1 #...##..# 1
+ 2 #....#..# 2
+ 3 ..##..### 3
+ 4v#####.##.v4
+ 5^#####.##.^5
+ 6 ..##..### 6
+ 7 #....#..# 7
+
+   This pattern reflects across the horizontal line between rows 4 and 5. Row
+   1 would reflect with a hypothetical row 8, but since that's not in the
+   pattern, row 1 doesn't need to match anything. The remaining rows match:
+   row 2 matches row 7, row 3 matches row 6, and row 4 matches row 5.
+
+   To summarize your pattern notes, add up the number of columns to the left
+   of each vertical line of reflection; to that, also add 100 multiplied by
+   the number of rows above each horizontal line of reflection. In the above
+   example, the first pattern's vertical line has 5 columns to its left and
+   the second pattern's horizontal line has 4 rows above it, a total of 405.
+
+   Find the line of reflection in each of the patterns in your notes. What
+   number do you get after summarizing all of your notes?
+
+   Your puzzle answer was 27742.
+
+--- Part Two ---
+
+   You resume walking through the valley of mirrors and - SMACK! - run
+   directly into one. Hopefully nobody was watching, because that must have
+   been pretty embarrassing.
+
+   Upon closer inspection, you discover that every mirror has exactly one
+   smudge: exactly one . or # should be the opposite type.
+
+   In each pattern, you'll need to locate and fix the smudge that causes a
+   different reflection line to be valid. (The old reflection line won't
+   necessarily continue being valid after the smudge is fixed.)
+
+   Here's the above example again:
+
+ #.##..##.
+ ..#.##.#.
+ ##......#
+ ##......#
+ ..#.##.#.
+ ..##..##.
+ #.#.##.#.
+
+ #...##..#
+ #....#..#
+ ..##..###
+ #####.##.
+ #####.##.
+ ..##..###
+ #....#..#
+
+   The first pattern's smudge is in the top-left corner. If the top-left #
+   were instead ., it would have a different, horizontal line of reflection:
+
+ 1 ..##..##. 1
+ 2 ..#.##.#. 2
+ 3v##......#v3
+ 4^##......#^4
+ 5 ..#.##.#. 5
+ 6 ..##..##. 6
+ 7 #.#.##.#. 7
+
+   With the smudge in the top-left corner repaired, a new horizontal line of
+   reflection between rows 3 and 4 now exists. Row 7 has no corresponding
+   reflected row and can be ignored, but every other row matches exactly: row
+   1 matches row 6, row 2 matches row 5, and row 3 matches row 4.
+
+   In the second pattern, the smudge can be fixed by changing the fifth
+   symbol on row 2 from . to #:
+
+ 1v#...##..#v1
+ 2^#...##..#^2
+ 3 ..##..### 3
+ 4 #####.##. 4
+ 5 #####.##. 5
+ 6 ..##..### 6
+ 7 #....#..# 7
+
+   Now, the pattern has a different horizontal line of reflection between
+   rows 1 and 2.
+
+   Summarize your notes as before, but instead use the new different
+   reflection lines. In this example, the first pattern's new horizontal line
+   has 3 rows above it and the second pattern's new horizontal line has 1 row
+   above it, summarizing to the value 400.
+
+   In each pattern, fix the smudge and find the different line of reflection.
+   What number do you get after summarizing the new reflection line in each
+   pattern in your notes?
+
+   Your puzzle answer was 32728.
+
+   Both parts of this puzzle are complete! They provide two gold stars: **
+
+   At this point, you should [16]return to your Advent calendar and try
+   another puzzle.
+
+   If you still want to see it, you can [17]get your puzzle input.
+
+   You can also [Shareon [18]Twitter [19]Mastodon] this puzzle.
+
+References
+
+   Visible links
+   1. https://adventofcode.com/
+   2. https://adventofcode.com/2023/about
+   3. https://adventofcode.com/2023/events
+   4. https://teespring.com/stores/advent-of-code
+   5. https://adventofcode.com/2023/settings
+   6. https://adventofcode.com/2023/auth/logout
+   7. Advent of Code Supporter
+	https://adventofcode.com/2023/support
+   8. https://adventofcode.com/2023
+   9. https://adventofcode.com/2023
+  10. https://adventofcode.com/2023/support
+  11. https://adventofcode.com/2023/sponsors
+  12. https://adventofcode.com/2023/leaderboard
+  13. https://adventofcode.com/2023/stats
+  14. https://adventofcode.com/2023/sponsors
+  15. https://www.janestreet.com/
+  16. https://adventofcode.com/2023
+  17. https://adventofcode.com/2023/day/13/input
+  18. https://twitter.com/intent/tweet?text=I%27ve+completed+%22Point+of+Incidence%22+%2D+Day+13+%2D+Advent+of+Code+2023&url=https%3A%2F%2Fadventofcode%2Ecom%2F2023%2Fday%2F13&related=ericwastl&hashtags=AdventOfCode
+  19. javascript:void(0);

2023/day13/testinput

@@ -0,0 +1,15 @@
+#.##..##.
+..#.##.#.
+##......#
+##......#
+..#.##.#.
+..##..##.
+#.#.##.#.
+
+#...##..#
+#....#..#
+..##..###
+#####.##.
+#####.##.
+..##..###
+#....#..#

helpers/coordinateByteMap.go

@@ -303,6 +303,20 @@ func (m CoordByteMap) Map(l func(c Coordinate, in byte) byte) CoordByteMap {
 	}
 	return i
 }
+func (m CoordByteMap) RowAsString(y int) string {
+	var res string
+	for x := m.TLX; x <= m.BRX; x++ {
+		res = fmt.Sprintf("%s%s", res, string(m.Get(Coordinate{X: x, Y: y})))
+	}
+	return res
+}
+func (m CoordByteMap) ColAsString(x int) string {
+	var res string
+	for y := m.TLY; y <= m.BRY; y++ {
+		res = fmt.Sprintf("%s%s", res, string(m.Get(Coordinate{X: x, Y: y})))
+	}
+	return res
+}
 
 func (m CoordByteMap) String() string {
 	var ret string

sbin/aoc

@@ -53,7 +53,6 @@ getproblem() {
   DY=$(echo "$CURRDAY"|awk '$0*=1')
   echo "Getting problem at $CURRYEAR/day/$DY"
   elinks -dump https://adventofcode.com/$CURRYEAR/day/$DY > problem
-  vim problem
 }
 
 getinput() {