efim
/
Advent-of-Code-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: efim:762e72744c361bb4366168f6c8b24f1c4b0a9b4e
Branches Tags
efim:master
..
compare: efim:37ee3e99dad49f6b6d2f1e119330f3127b46bb37
Branches Tags
efim:master

No commits in common. "762e72744c361bb4366168f6c8b24f1c4b0a9b4e" and "37ee3e99dad49f6b6d2f1e119330f3127b46bb37" have entirely different histories.
762e72744c ... 37ee3e99da

15 changed files with 3 additions and 4773 deletions
Show Stats Expand all files Collapse all files

109
day11/dayEleven.go
View File

@ -1,109 +0,0 @@
package day11
import (
"fmt"
"log"
"os"
"strings"
)
func Run() int64 {
fmt.Println("hello day 11")
filename := "day11/input"
bytes, err := os.ReadFile(filename)
if err != nil {
panic(fmt.Sprint("cannot read file ", filename))
}
text := strings.TrimSpace( string(bytes) )
starCoords := make([]StarCoord, 0)
lines := strings.Split(text, "\n")
nonEmptyRows := make(map[int]any)
nonEmptyCols := make(map[int]any)
for rowNum, line := range lines {
for colNum, symb := range line {
if symb == '#' {
starCoords = append(starCoords, StarCoord{rowNum, colNum})
nonEmptyCols[colNum] = struct{}{}
nonEmptyRows[rowNum] = struct{}{}
}
}
}
emptyRowsAbove := make([]int, len(lines))
emptyColsToTheLeft := make([]int, len(lines))
for rowNum, _ := range lines {
if rowNum > 0 {
emptyRowsAbove[rowNum] = emptyRowsAbove[rowNum-1]
}
_, isRowNonempty := nonEmptyRows[rowNum]
if !isRowNonempty {
emptyRowsAbove[rowNum] += 1
}
}
for colNum, _ := range lines[0] {
if colNum > 0 {
emptyColsToTheLeft[colNum] = emptyColsToTheLeft[colNum-1]
}
_, isColNonempty := nonEmptyCols[colNum]
if !isColNonempty {
emptyColsToTheLeft[colNum] += 1
}
}
var distanceSum int64
for i := 0; i < len(starCoords); i++ {
for j := i+1; j < len(starCoords); j++ {
// calc distance between stars i and j
starA := starCoords[i]
starB := starCoords[j]
maxRow := starA.Row
minRow := starB.Row
if maxRow < minRow {
maxRow, minRow = minRow, maxRow
}
var multiplier int64
multiplier = 1000000 - 1
emptyRowsBetween := int64(emptyRowsAbove[maxRow]) - int64(emptyRowsAbove[minRow])
rowDistance := int64(maxRow) - int64(minRow) + emptyRowsBetween*multiplier
maxCol := starA.Col
minCol := starB.Col
if maxCol < minCol {
maxCol, minCol = minCol, maxCol
}
emptyColsBetween := int64(emptyColsToTheLeft[maxCol]) - int64(emptyColsToTheLeft[minCol])
colDistance := int64(maxCol) - int64(minCol) + emptyColsBetween*multiplier
distance := rowDistance + colDistance
log.Printf("between stars %d %+v and %d %+v distance is %d. emptyColsBetween %d ; emptyRowsBetween %d\n", i, j, starA, starB, distance, emptyColsBetween, emptyRowsBetween)
distanceSum += int64(distance)
}
}
// oh, i have list of all stars, i can just iterate over them and
// only keep rowNums for which there are stars. yeah
fmt.Println(starCoords)
fmt.Println(emptyRowsAbove)
fmt.Println(emptyColsToTheLeft)
return distanceSum
}
type StarCoord struct {
Row, Col int
}

10
day11/example
View File

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

140
day11/input
View File

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

184
day12/dayTwelve.go
View File

@ -1,184 +0,0 @@
package day12
import (
"fmt"
"log"
"os"
"strconv"
"strings"
"sync"
"time"
)
func Run() int {
fmt.Println("hello day 12.")
start := time.Now()
filename := "day12/input"
bytes, err := os.ReadFile(filename)
if err != nil {
panic(fmt.Sprintf("error reading file %s\n", filename))
}
result := 0
text := string(bytes)
text = strings.TrimSpace(text)
// testMask, testBlocks := ReadLine(".??..??...?##. 1,1,3")
// blocksSum := 0
// for _, block := range testBlocks {
// blocksSum += block
// }
// testVariants := generatePermutations("", len(testMask), testBlocks, blocksSum, testMask)
// fmt.Printf("for mask %s and blocks %+v\n", testMask, testBlocks)
// for _, variant := range testVariants {
// fmt.Println(variant)
// }
var wg sync.WaitGroup
lines := strings.Split(text, "\n")
wg.Add(len(lines))
matches := make(chan int)
go func() {
wg.Wait()
close(matches)
}()
for i, line := range lines {
go func(line string, lineNum int){
mask, blockLengs := ReadLine(line)
blockLengthSum := 0
for _, blockLen := range blockLengs {
blockLengthSum += blockLen
}
memo := make(map[string]int)
variantsCount := generatePermutations("", len(mask), blockLengs, blockLengthSum, mask, memo)
log.Printf("%d : for line %s blocks %+v matches %d\n", lineNum, mask, blockLengs, variantsCount)
matches <- variantsCount
wg.Done()
}(line, i)
}
num := 0
for match := range matches {
num += 1
result += match
log.Printf("%d. intermediate: %d\n", num, result)
fmt.Printf("%d\n", result)
}
end := time.Now()
diff := end.Sub(start)
log.Printf("> calculated for %s", diff.String())
return result
}
func myRepeat(line, sep string, amount int) string {
acc := ""
for i := 0; i < amount; i++ {
acc += sep
acc += line
}
acc, _ = strings.CutPrefix(acc, sep)
return acc
}
// ???.### 1,1,3
func ReadLine(line string) (string, []int) {
firstSplit := strings.Split(line, " ")
if len(firstSplit) != 2 {
panic(fmt.Sprintf("error splitting %s into 2", line))
}
mask := firstSplit[0]
mask = myRepeat(mask, "?", 5)
blocks := firstSplit[1]
blocks = myRepeat(blocks, ",", 5)
// log.Printf(">> repeating blocks %s", blocks)
blockLengthStrings := strings.Split(blocks, ",")
blockLengs := make([]int, len(blockLengthStrings))
for i, blockLenStr := range blockLengthStrings {
num, err := strconv.Atoi(blockLenStr)
if err != nil {
panic(fmt.Sprintf("error extracting num %s from %s\n", blockLenStr, line))
}
blockLengs[i] = num
}
return mask, blockLengs
}
func generatePermutations(curString string, targetLength int, blockLengths []int, blockLengthsSum int, mask string, memo map[string]int) int {
memoKey := fmt.Sprintf("%+v|%d", blockLengths, len(curString))
memoized, memoFound := memo[memoKey]
if memoFound {
return memoized
}
// fmt.Printf("> entering with \n%s\nfor map \n%s\n\n", curString, mask)
// time.Sleep(time.Second)
if !isVariantMatchesMask(curString, mask) {
return 0
}
// log.Printf("> entering with %s\n", curString)
if len(blockLengths) == 0 {
if len(curString) > targetLength {
return 0
}
variant := curString + strings.Repeat(".", targetLength-len(curString))
if !isVariantMatchesMask(variant, mask) {
return 0
}
memo[memoKey] = 1
return 1
}
nextBlock := blockLengths[0]
restBlocks := blockLengths[1:]
if len(curString) + blockLengthsSum + len(blockLengths) - 1 > targetLength {
return 0
}
isLast := len(restBlocks) == 0
rightPointRepeat := 1
if isLast {
rightPointRepeat = 0
}
whenPass := curString + "."
whenAdd := curString + strings.Repeat("#", nextBlock) + strings.Repeat(".", rightPointRepeat)
passCount := generatePermutations(whenPass, targetLength, blockLengths, blockLengthsSum, mask, memo)
addCount := generatePermutations(whenAdd, targetLength, restBlocks, blockLengthsSum-nextBlock, mask, memo)
memo[memoKey] = passCount + addCount
return passCount + addCount
}
func isVariantMatchesMask(variant, mask string) bool {
if len(mask) < len(variant) {
log.Printf("mask %s is less than variant %s\n", mask, variant)
}
maskRunes := []rune(mask)
for i, symb := range variant {
if maskRunes[i] == '?' {
continue
}
if maskRunes[i] != symb {
return false
}
}
return true
}

6
day12/example
View File

@ -1,6 +0,0 @@
#.#.### 1,1,3
.#...#....###. 1,1,3
.#.###.#.###### 1,3,1,6
####.#...#... 4,1,1
#....######..#####. 1,6,5
.###.##....# 3,2,1

6
day12/example1
View File

@ -1,6 +0,0 @@
???.### 1,1,3
.??..??...?##. 1,1,3
?#?#?#?#?#?#?#? 1,3,1,6
????.#...#... 4,1,1
????.######..#####. 1,6,5
?###???????? 3,2,1

1000
day12/input
View File

File diff suppressed because it is too large Load Diff

104
day12/notes.org
View File

@ -1,104 +0,0 @@
#+title: Notes
* i guess let's generate all possible? and short circuit when they are not matching mask
how do i generate all possible?
i take length of the mask, that's max size
then for each step, either put . or put n # from the input.
add to current string, and do 2 recursive calls, one with diminished 'queue', one with same
* wrong answer on input
it's too high
and log shows:
2023/12/12 15:07:52 for line ???#?.?#?#.?#???#..? blocks [4 4 5 1] matches 2
and it should be 0
** huh, nope this looks good:
testMask := "???#?.?#?#.?#???#..?"
testBlocks := []int{4,4,5,1}
testVariants := generatePermutations("", len(testMask), testBlocks, 14, testMask)
fmt.Printf("for mask %s and blocks %+v\n", testMask, testBlocks)
fmt.Println(testVariants)
for mask ???#?.?#?#.?#???#..? and blocks [4 4 5 1]
[####..####..#####..# .####.####..#####..#]
** let's check this : for line ??????#???????? blocks [7 2] matches 21
** or this for line ?????.??#????? blocks [3 3 2 1] matches 3
looks ok
** this for line ??..??#?????#?##? blocks [1 1 1 1 4] matches 15
looks good
** for line ?#??#??#???.??.??.? blocks [1 2 3 1 1 1] matches 20
seems ok
** for line ???????#??.????####? blocks [1 1 1 1 1 6] matches 58
bingo?
for mask ???????#??.????####? and blocks [1 1 1 1 1 6]
#.#.#..#.#.######...
#.#.#..#.#..######..
#.#.#..#.#...######.
#.#.#..#.#....######
#.#.#..#...#.######.
#.#.#..#...#..######
#.#.#..#....#.######
#.#..#.#.#.######...
#.#..#.#.#..######..
#.#..#.#.#...######.
#.#..#.#.#....######
#.#..#.#...#.######.
#.#..#.#...#..######
#.#..#.#....#.######
#.#....#.#.#.######.
#.#....#.#.#..######
#.#....#.#..#.######
#..#.#.#.#.######...
#..#.#.#.#..######..
#..#.#.#.#...######.
#..#.#.#.#....######
#..#.#.#...#.######.
#..#.#.#...#..######
#..#.#.#....#.######
#..#...#.#.#.######.
#..#...#.#.#..######
#..#...#.#..#.######
#...#..#.#.#.######.
#...#..#.#.#..######
#...#..#.#..#.######
#....#.#.#.#.######.
#....#.#.#.#..######
#....#.#.#..#.######
.#.#.#.#.#.######...
.#.#.#.#.#..######..
.#.#.#.#.#...######.
.#.#.#.#.#....######
.#.#.#.#...#.######.
.#.#.#.#...#..######
.#.#.#.#....#.######
.#.#...#.#.#.######.
.#.#...#.#.#..######
.#.#...#.#..#.######
.#..#..#.#.#.######.
.#..#..#.#.#..######
.#..#..#.#..#.######
.#...#.#.#.#.######.
.#...#.#.#.#..######
.#...#.#.#..#.######
..#.#..#.#.#.######.
..#.#..#.#.#..######
..#.#..#.#..#.######
..#..#.#.#.#.######.
..#..#.#.#.#..######
..#..#.#.#..#.######
...#.#.#.#.#.######.
...#.#.#.#.#..######
...#.#.#.#..#.######
* well, maybe overnight will calculate.
but i guess i needed to check whether blocks are 'always' taking full width
then i'll only need to calculate once, and then multiply
** for example
2023/12/12 20:40:41 699 : for line ??#?????#???.? ???#?????#???.????#?????#???.????#?????#???.????#?????#???.? blocks [3 1 2 1 3 1 2 1 3 1 2 1 3 1 2 1 3 1 2 1] matches 38294856
??#?? ???#?? ?.?
3,1,2,1 - 10+3 = 13
lowest s ###.#.##.#..... - plenty of space for additional

226
day13/dayThirteen.go
View File

@ -1,226 +0,0 @@
package day13
import (
"fmt"
"log"
"os"
"strings"
)
func Run() int {
filename := "day13/input"
fmt.Println("hello day 13.", filename)
bytes, err := os.ReadFile(filename)
if err != nil {
panic(fmt.Sprintf("error reading file %s", filename))
}
allText := string(bytes)
fieldTexts := strings.Split(allText, "\n\n")
result := 0
for _, fieldText := range fieldTexts {
field := ReadField(fieldText)
result += Calc(field)
}
return result
}
func Calc(field Field) int {
verticals, horizontals := field.initMirrors()
fmt.Println(field.String())
fmt.Printf("field width %d and height %d\n", len(field.Symbols[0]), len(field.Symbols))
for rowNum, row := range field.Symbols {
for colNum, symb := range row {
for _, horizontalMirrorUnderCheck := range horizontals {
// if horizontalMirrorUnderCheck.Smaller != 4 {
// continue
// }
mirroredRow, shouldCheck := horizontalMirrorUnderCheck.reflectCoord(rowNum)
// log.Println("for mirror", horizontalMirrorUnderCheck.String())
// log.Printf("> checking row %d and mirrored %d; should %t\n", rowNum, mirroredRow, shouldCheck)
if shouldCheck {
// log.Printf("checking horizontal mirror %+v", horizontalMirrorUnderCheck)
// log.Printf("in should check for row %d, col %d, mirrored row %d\n", rowNum, colNum, mirroredRow)
mirroredSymb := field.Symbols[mirroredRow][colNum]
isMirrored := symb == mirroredSymb
if !isMirrored {
// log.Printf("found not mirrored : %s != %s\n", string(symb), string(mirroredSymb))
horizontalMirrorUnderCheck.FailedLineChecks[rowNum] += 1
}
}
}
}
// whole row got checked.
// let's mark successful line check for all that didn't fail this line check
for _, horizontalMirror := range horizontals {
_, failedCheckReported := horizontalMirror.FailedLineChecks[rowNum]
if !failedCheckReported {
horizontalMirror.SuccessfulLineChecks[rowNum] = struct{}{}
}
}
}
rowsAboveHorizontals := 0
for _, mirr := range horizontals {
fmt.Println("horizontal: ", mirr.String())
if mirr.isFullMirror() {
log.Printf(">> found perfect Horizontal %+v\n", mirr)
rowsAboveHorizontals += (mirr.Smaller + 1)
}
}
for colNum, _ := range field.Symbols[0] {
for rowNum, row := range field.Symbols {
symb := row[colNum]
for _, verticalMirrorUnderCheck := range verticals {
// if verticalMirrorUnderCheck.Smaller != 8 {
// continue
// }
mirroredCol, shouldCheck := verticalMirrorUnderCheck.reflectCoord(colNum)
if shouldCheck {
// log.Printf("checking vertical mirror %+v", verticalMirrorUnderCheck)
// log.Printf("in should check for row %d, col %d, mirrored col %d\n", rowNum, colNum, mirroredCol)
mirroredSymb := field.Symbols[rowNum][mirroredCol]
isMirrored := symb == mirroredSymb
if !isMirrored {
// log.Printf("found not mirrored : %s != %s\n", string(symb), string(mirroredSymb))
verticalMirrorUnderCheck.FailedLineChecks[colNum] += 1
}
}
}
}
// whole row got checked.
// let's mark successful line check for all that didn't fail this line check
for _, verticalMirror := range verticals {
_, failedCheckReported := verticalMirror.FailedLineChecks[colNum]
if !failedCheckReported {
verticalMirror.SuccessfulLineChecks[colNum] = struct{}{}
}
}
}
colsToLeftOfHorizontals := 0
for _, mirr := range verticals {
fmt.Println("vertical: ", mirr.String())
if mirr.isFullMirror() {
log.Printf(">> found perfect Vertical %+v\n", mirr)
colsToLeftOfHorizontals += (mirr.Smaller + 1)
}
}
result := colsToLeftOfHorizontals + 100*rowsAboveHorizontals
return result
}
type Field struct {
Symbols [][]rune
}
func ReadField(fieldText string) Field {
fieldText = strings.TrimSpace(fieldText)
lines := strings.Split(fieldText, "\n")
symbols := make([][]rune, len(lines))
for i, line := range lines {
symbols[i] = []rune(line)
}
return Field{
Symbols: symbols,
}
}
func (f *Field) String() string {
text := "\n"
for _, row := range f.Symbols {
text += string(row)
text += "\n"
}
return text
}
func (f *Field) initMirrors() (vertical []Mirror, horizontal []Mirror) {
height := len(f.Symbols)
width := len(f.Symbols[0])
amountHorizontal := height - 1
amountVertical := width - 1
horizontal = make([]Mirror, amountHorizontal)
vertical = make([]Mirror, amountVertical)
for rowNum := 0; rowNum < amountHorizontal; rowNum++ {
maxDist := min(rowNum, height - 1 - (rowNum+1))
// log.Println("maxDist ", maxDist, "for rowNum ", rowNum)
horizontal[rowNum] = Mirror{
Smaller: rowNum,
Bigger: rowNum + 1,
SuccessfulLineChecks: make(map[int]any),
FailedLineChecks: make(map[int]int),
MaxDistToCheck: maxDist,
}
}
for colNum := 0; colNum < amountVertical; colNum++ {
maxDist := min(colNum, width - 1 - (colNum+1))
vertical[colNum] = Mirror{
Smaller: colNum,
Bigger: colNum + 1,
SuccessfulLineChecks: make(map[int]any),
FailedLineChecks: make(map[int]int),
MaxDistToCheck: min(colNum, maxDist),
}
}
return
}
type Mirror struct {
// located between lines
Smaller, Bigger int
MaxDistToCheck int // how many steps from mirrow have to be checked to confirm
// i.e if mirror between 0 and 1 - only rows 0 & 1 have to be checked, row 2 is 'mirrored' outside of the field and 'ok'
// value 0 means one step from 'mirror' so rows 0 and 1
SuccessfulLineChecks map[int]any
FailedLineChecks map[int]int // from line num, to amount of errors in that line
}
func (m *Mirror)isFullMirror() bool {
correctFailedLinesCount := len(m.FailedLineChecks) == 2
if correctFailedLinesCount {
for failedLine, failedSymbols := range m.FailedLineChecks {
reflectedLine, _ := m.reflectCoord(failedLine)
doublyReflected, _ := m.reflectCoord(reflectedLine)
// log.Printf(">>>> checking failed line %d, reflected is %d; doubly %d. amount failed is %d\n", failedLine, reflectedLine, doublyReflected, failedSymbols)
if failedSymbols == 1 && (doublyReflected == failedLine) {
return true
}
}
}
return false
}
func (m *Mirror)String() string {
return fmt.Sprintf("Mirror (full %t) between %d and %d. successful lines: %+v ; failed lines: %+v. Max check dist: %d\n",
m.isFullMirror(), m.Smaller, m.Bigger, m.SuccessfulLineChecks, m.FailedLineChecks, m.MaxDistToCheck)
}
func (m *Mirror) reflectCoord(coord int) (reflected int, shouldCheck bool) {
dist := m.Smaller - coord
// _, distConfirmed := m.SuccessfulLineChecks[dist]
// if distConfirmed {
// // log.Printf("> getting dist confirmed for coord %d ; dist %d\n", coord, dist)
// return 0, false // either line already fully confirmed, or failed. no need for additional checks
// }
reflected = m.Bigger + dist
if dist < 0 {
dist = coord - m.Bigger
reflected = m.Smaller - dist
}
shouldCheck = dist <= m.MaxDistToCheck
return reflected, shouldCheck
}

15
day13/example
View File

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

7
day13/example1
View File

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

7
day13/example2
View File

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

1379
day13/input
View File

File diff suppressed because it is too large Load Diff

1577
log.txt
View File

File diff suppressed because it is too large Load Diff

6
main.go
View File

@ -3,12 +3,12 @@ package main
import ( import (
"log" "log"
"sunshine.industries/aoc2023/day13" "sunshine.industries/aoc2023/day10"
) )
func main() { func main() {
log.Print("> starting run:") log.Print("> starting run:")
result := day13.Run() result := day10.Run()
log.Printf("day13 result: %d\n****\n", result) log.Printf("day10 result: %d\n****\n", result)
} }