386 lines
8.3 KiB
Go
386 lines
8.3 KiB
Go
package day18
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
func Run() int {
|
|
log.Println("hello day 18")
|
|
log.Println("problem of lagoon bgins")
|
|
filename := "day18/example"
|
|
instructions := ReadInstructionas(filename)
|
|
h, w := calcHeightWidth(instructions)
|
|
log.Printf("read %+v instructions", instructions)
|
|
|
|
field := CreateField(h, w)
|
|
log.Println("created field")
|
|
|
|
// fmt.Println(field.String())
|
|
borderAmount := field.digByInstructions(instructions)
|
|
|
|
fmt.Println(field.String())
|
|
// WriteToFile("borders.txt", field.String())
|
|
// convert -size 3000x6000 xc:white -font "FreeMono" -pointsize 13 -fill black -draw @borders.txt borders.png
|
|
|
|
insideAmount := field.digInsides()
|
|
|
|
log.Printf("border is %d; inside is %d", borderAmount, insideAmount)
|
|
fmt.Println(field.String())
|
|
// fmt.Println(field.Height, field.Width)
|
|
// WriteToFile("fulldug.txt", field.String())
|
|
// convert -size 3000x6000 xc:white -font "FreeMono" -pointsize 13 -fill black -draw @fulldug.txt fulldug.png
|
|
|
|
// field.countDugOut()
|
|
return borderAmount + insideAmount
|
|
}
|
|
|
|
// determine size of field. max(sum(up), sum(down)) for height,
|
|
// same for left and right,
|
|
// translate (0,0) into center of the field
|
|
//
|
|
// have cells, with coord. and i guess four sides, with color.
|
|
// i guess have directions, map[direction]color
|
|
// and have 'opposite' on directoin.
|
|
// for each direction apply it to cell coord, get cell, get opposite directoin and color it
|
|
//
|
|
// then have method on field and cell that excavates cell and colors all neighbors
|
|
//
|
|
// last part is filling in isides, should be ok with horizontal scans from left by even crossings
|
|
|
|
type Direction int
|
|
|
|
const (
|
|
Upward Direction = iota
|
|
Downward
|
|
Leftward
|
|
Rightward
|
|
)
|
|
|
|
func (d Direction) opposite() Direction {
|
|
switch d {
|
|
case Upward:
|
|
return Downward
|
|
case Downward:
|
|
return Upward
|
|
case Leftward:
|
|
return Rightward
|
|
case Rightward:
|
|
return Leftward
|
|
}
|
|
panic("unaccounted direction")
|
|
}
|
|
|
|
var DirectionNames []string = []string{"U", "D", "L", "R"}
|
|
|
|
func (d Direction) String() string {
|
|
return DirectionNames[d]
|
|
}
|
|
func DirectionFromString(s string) Direction {
|
|
index := slices.Index(DirectionNames, s)
|
|
if index == -1 {
|
|
panic(fmt.Sprint("bad direction", s))
|
|
}
|
|
return Direction(index)
|
|
}
|
|
|
|
type Instruction struct {
|
|
Direction Direction
|
|
Steps int
|
|
Color string
|
|
}
|
|
|
|
func ReadInstructionas(filename string) (result []Instruction) {
|
|
bytes, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
panic(fmt.Sprint("error reading file: ", filename))
|
|
}
|
|
text := strings.TrimSpace(string(bytes))
|
|
for _, line := range strings.Split(text, "\n") {
|
|
result = append(result, ReadInstruction(line))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func ReadInstruction(line string) Instruction {
|
|
fields := strings.Fields(line)
|
|
direction := DirectionFromString(fields[0])
|
|
steps, err := strconv.Atoi(fields[1])
|
|
if err != nil {
|
|
panic(fmt.Sprint("bad steps in line: ", line))
|
|
}
|
|
color := fields[2][1 : len(fields[2])-1]
|
|
|
|
return Instruction{Direction: direction, Steps: steps, Color: color}
|
|
}
|
|
|
|
func ReadInstructionas2(filename string) (result []Instruction) {
|
|
bytes, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
panic(fmt.Sprint("error reading file: ", filename))
|
|
}
|
|
text := strings.TrimSpace(string(bytes))
|
|
for _, line := range strings.Split(text, "\n") {
|
|
result = append(result, ReadInstruction2(line))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func ReadInstruction2(line string) Instruction {
|
|
fields := strings.Fields(line)
|
|
|
|
hexDist := fields[2][2 : len(fields[2])-2]
|
|
hexDirection := fields[2][len(fields[2])-2 : len(fields[2])-1]
|
|
var direction Direction
|
|
switch hexDirection {
|
|
case "0":
|
|
direction = Rightward
|
|
case "1":
|
|
direction = Downward
|
|
case "2":
|
|
direction = Leftward
|
|
case "3":
|
|
direction = Upward
|
|
}
|
|
|
|
dist, err := strconv.ParseUint(hexDist, 16, 64)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return Instruction{
|
|
Steps: int(dist),
|
|
Direction: direction,
|
|
}
|
|
}
|
|
|
|
func calcHeightWidth(instructions []Instruction) (height, width int) {
|
|
movements := make(map[Direction]int)
|
|
for _, instr := range instructions {
|
|
movements[instr.Direction] += instr.Steps
|
|
}
|
|
if movements[Downward] > movements[Upward] {
|
|
height = 2 * movements[Downward]
|
|
} else {
|
|
height = 2 * movements[Upward]
|
|
}
|
|
|
|
if movements[Leftward] > movements[Rightward] {
|
|
width = 2 * movements[Leftward]
|
|
} else {
|
|
width = 2 * movements[Rightward]
|
|
}
|
|
|
|
height += 10
|
|
width += 10
|
|
|
|
return
|
|
}
|
|
|
|
type Coord struct {
|
|
X, Y int
|
|
}
|
|
|
|
func (c Coord) applyDirection(d Direction) Coord {
|
|
switch d {
|
|
case Upward:
|
|
c.Y -= 1
|
|
case Downward:
|
|
c.Y += 1
|
|
case Leftward:
|
|
c.X -= 1
|
|
case Rightward:
|
|
c.X += 1
|
|
}
|
|
|
|
return c
|
|
}
|
|
|
|
type Cell struct {
|
|
IsDug bool
|
|
ToBeDug bool
|
|
Coord Coord
|
|
}
|
|
type Field struct {
|
|
Height, Width int
|
|
Cells [][]*Cell
|
|
}
|
|
|
|
func CreateField(height, width int) Field {
|
|
rows := make([][]*Cell, height)
|
|
for i := 0; i < height; i++ {
|
|
row := make([]*Cell, width)
|
|
rows[i] = row
|
|
// for j := 0; j < width; j++ {
|
|
// row[j] = &Cell{}
|
|
// }
|
|
}
|
|
return Field{
|
|
Height: height, Width: width,
|
|
Cells: rows,
|
|
}
|
|
}
|
|
|
|
func (f *Field) coordToIndices(c Coord) (row, col int) {
|
|
row = c.Y + (f.Height / 2)
|
|
col = c.X + (f.Width / 2)
|
|
return
|
|
}
|
|
|
|
func (f *Field) digByInstructions(instructions []Instruction) (borderAmount int) {
|
|
runnerCoord := Coord{X: 0, Y: 0}
|
|
row, col := f.coordToIndices(runnerCoord)
|
|
f.Cells[row][col] = &Cell{
|
|
IsDug: true,
|
|
}
|
|
// borderAmount += 1
|
|
|
|
for _, instruction := range instructions {
|
|
log.Printf("starting instruction %+v", instruction)
|
|
for i := 0; i < instruction.Steps; i++ {
|
|
runnerCoord = runnerCoord.applyDirection(instruction.Direction)
|
|
row, col := f.coordToIndices(runnerCoord)
|
|
f.Cells[row][col] = &Cell{
|
|
IsDug: true,
|
|
}
|
|
borderAmount += 1
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (f *Field) String() string {
|
|
s := "text 15,15 \""
|
|
firstNonemptyRow, lastNonemptyRow := 0, 0
|
|
log.Print("just use", firstNonemptyRow, lastNonemptyRow)
|
|
seenInRows := false
|
|
firstNonemptyCol, lastNonemptyCol := 0, 0
|
|
seenInCols := false
|
|
|
|
for i, row := range f.Cells {
|
|
seenInRow := false
|
|
for j := 0; j < len(row); j++ {
|
|
if f.isCellDug(i, j) {
|
|
seenInRow = true
|
|
}
|
|
}
|
|
seenInRows = seenInRows || seenInRow
|
|
if seenInRow {
|
|
lastNonemptyRow = i
|
|
}
|
|
if !seenInRows {
|
|
firstNonemptyRow = i
|
|
}
|
|
}
|
|
|
|
for col := 0; col < f.Width; col++ {
|
|
seenInCol := false
|
|
for row := 0; row < f.Height; row++ {
|
|
if f.isCellDug(row, col) {
|
|
seenInCol = true
|
|
}
|
|
}
|
|
seenInCols = seenInCols || seenInCol
|
|
if seenInCol {
|
|
lastNonemptyCol = col
|
|
}
|
|
if !seenInCols {
|
|
firstNonemptyCol = col
|
|
}
|
|
}
|
|
|
|
rowLen := lastNonemptyCol - firstNonemptyCol + 1
|
|
log.Print(rowLen)
|
|
for i := 0; i <= f.Height-1; i++ {
|
|
rowChars := make([]rune, f.Width)
|
|
for col := 0; col <= f.Width-1; col++ {
|
|
cell := f.Cells[i][col]
|
|
if cell != nil && cell.ToBeDug {
|
|
rowChars[col] = '@'
|
|
} else if f.isCellDug(i, col) {
|
|
rowChars[col] = '#'
|
|
} else {
|
|
rowChars[col] = '.'
|
|
}
|
|
}
|
|
|
|
s += string(rowChars)
|
|
s += "\n"
|
|
}
|
|
s += "\""
|
|
return s
|
|
}
|
|
|
|
func (f *Field) digInsides() (countInside int) {
|
|
for row := 1; row < f.Height-1; row++ {
|
|
isInside := false
|
|
seenUp, seenDown := false, false // for detecting L---7 walls
|
|
for col := 0; col < f.Width-1; col++ {
|
|
rightCellIsDug := f.isCellDug(row, col+1)
|
|
if f.isCellDug(row, col) {
|
|
upCellIsDug := f.isCellDug(row-1, col)
|
|
downCellIsDug := f.isCellDug(row+1, col)
|
|
if !rightCellIsDug {
|
|
if (upCellIsDug && seenDown) || (downCellIsDug && seenUp) {
|
|
isInside = !isInside
|
|
}
|
|
seenUp, seenDown = false, false
|
|
}
|
|
} else {
|
|
// not a dug out cell, maybe inside and needs to be dug out
|
|
if isInside {
|
|
f.Cells[row][col] = &Cell{
|
|
ToBeDug: true,
|
|
}
|
|
|
|
countInside += 1
|
|
log.Printf("tick count inside for %d %d", row, col)
|
|
// cellPtr.ToBeDug = true
|
|
}
|
|
if rightCellIsDug {
|
|
seenUp = f.isCellDug(row-1, col+1)
|
|
seenDown = f.isCellDug(row+1, col+1)
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (f *Field) isCellDug(row, col int) bool {
|
|
cell := f.Cells[row][col]
|
|
return cell != nil && cell.IsDug
|
|
}
|
|
|
|
// func (f *Field)countDugOut() (result int) {
|
|
// for _, row := range f.Cells {
|
|
// for _, cell := range row {
|
|
// if cell.IsDug || cell.ToBeDug {
|
|
// result += 1
|
|
// }
|
|
// }
|
|
// }
|
|
// return
|
|
// }
|
|
|
|
func WriteToFile(filename string, content string) {
|
|
fileBorder, err := os.Create(filename)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer func() {
|
|
if err := fileBorder.Close(); err != nil {
|
|
panic(err)
|
|
}
|
|
}()
|
|
|
|
fileBorder.WriteString(content)
|
|
}
|