2022 Day 23 Complete
This commit is contained in:
422
2022/day22/main.go
Normal file
422
2022/day22/main.go
Normal file
@@ -0,0 +1,422 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
|
||||
h "git.bullercodeworks.com/brian/adventofcode/helpers"
|
||||
)
|
||||
|
||||
func main() {
|
||||
inp := h.StdinToStringSlice()
|
||||
//part1(inp)
|
||||
part2(inp)
|
||||
}
|
||||
func part1(inp []string) {
|
||||
board, inst := inp[:len(inp)-2], inp[len(inp)-1]
|
||||
b := BuildBoard(board)
|
||||
var count int
|
||||
var turn byte
|
||||
fmt.Println(b)
|
||||
fmt.Println(b.pos)
|
||||
for len(inst) > 0 {
|
||||
count, turn, inst = getNextInstructions(inst)
|
||||
b.Move(count)
|
||||
if turn == 'L' || turn == 'R' {
|
||||
b.Turn(turn)
|
||||
}
|
||||
}
|
||||
fmt.Println("Password:", b.Password())
|
||||
}
|
||||
|
||||
func part2(inp []string) {
|
||||
board, inst := inp[:len(inp)-2], inp[len(inp)-1]
|
||||
b := BuildCubeBoard(board)
|
||||
var count int
|
||||
var turn byte
|
||||
fmt.Println(b)
|
||||
fmt.Println(b.pos)
|
||||
for len(inst) > 0 {
|
||||
count, turn, inst = getNextInstructions(inst)
|
||||
b.Move(count)
|
||||
if turn == 'L' || turn == 'R' {
|
||||
b.Turn(turn)
|
||||
}
|
||||
}
|
||||
fmt.Println("Password:", b.Password())
|
||||
}
|
||||
|
||||
func getNextInstructions(inst string) (int, byte, string) {
|
||||
for i := range inst {
|
||||
if inst[i] == 'L' || inst[i] == 'R' {
|
||||
return h.Atoi(inst[:i]), inst[i], inst[i+1:]
|
||||
}
|
||||
}
|
||||
return h.Atoi(inst), 0, ""
|
||||
}
|
||||
|
||||
const (
|
||||
dirR = iota
|
||||
dirD
|
||||
dirL
|
||||
dirU
|
||||
dirErr
|
||||
|
||||
sideTop = iota
|
||||
sideBottom
|
||||
sideRight
|
||||
sideLeft
|
||||
sideFront
|
||||
sideBack
|
||||
)
|
||||
|
||||
type CubeBoard struct {
|
||||
Top *CubeBoardSide
|
||||
Bottom *CubeBoardSide
|
||||
Left *CubeBoardSide
|
||||
Right *CubeBoardSide
|
||||
Front *CubeBoardSide
|
||||
Back *CubeBoardSide
|
||||
|
||||
// Pos now holds:
|
||||
// y, x, dir, side
|
||||
pos []int
|
||||
}
|
||||
|
||||
// For the purposes of directions, we treat the board like this:
|
||||
// [T]
|
||||
// [B][L][F][R]
|
||||
// [B]
|
||||
// So up from left, front, back, and right are all top
|
||||
// Up from bottom is front
|
||||
// Down from bottom is back
|
||||
// Up from top is back
|
||||
// Down from top is front
|
||||
// So you can continually go left on the main level and circumnavigate the cube
|
||||
// Continually going up from anywhere will eventually get you bouncing between top and back
|
||||
// Continually going down from anywhere will eventually get you bouncing between bottom and back
|
||||
func BuildCubeBoard(inp []string) *CubeBoard {
|
||||
cb := CubeBoard{}
|
||||
var side string
|
||||
for i := 0; i < len(inp); i++ {
|
||||
if len(inp) == 0 {
|
||||
break
|
||||
}
|
||||
side = inp[i]
|
||||
i++
|
||||
cbs := BuildCubeBoardSide(inp[i : i+len(inp[i])])
|
||||
switch side {
|
||||
case "Top":
|
||||
cb.Top = cbs
|
||||
case "Bottom":
|
||||
cb.Bottom = cbs
|
||||
case "Left":
|
||||
cb.Left = cbs
|
||||
case "Right":
|
||||
cb.Right = cbs
|
||||
case "Front":
|
||||
cb.Front = cbs
|
||||
case "Back":
|
||||
cb.Back = cbs
|
||||
}
|
||||
i = i + cbs.Size() - 1
|
||||
}
|
||||
cb.pos = []int{0, 0, dirR, sideTop}
|
||||
return &cb
|
||||
}
|
||||
func (cb *CubeBoard) Size() int { return cb.Top.Size() }
|
||||
func (cb *CubeBoard) Move(count int) {
|
||||
|
||||
}
|
||||
func (cb *CubeBoard) GetPosUp() []int {
|
||||
y := cb.pos[0]
|
||||
x := cb.pos[1]
|
||||
dir := cb.pos[2]
|
||||
side := cb.pos[3]
|
||||
if y == 0 {
|
||||
// Going to another side
|
||||
switch side {
|
||||
case sideTop:
|
||||
side = sideBack
|
||||
case sideBottom:
|
||||
side = sideFront
|
||||
case sideFront:
|
||||
side = sideTop
|
||||
case sideBack:
|
||||
side = sideTop
|
||||
case sideLeft:
|
||||
side = sideTop
|
||||
case sideRight:
|
||||
side = sideTop
|
||||
}
|
||||
}
|
||||
return []int{y, x, dir, side}
|
||||
}
|
||||
func (cb *CubeBoard) GetPosDown() []int {
|
||||
y := cb.pos[0]
|
||||
x := cb.pos[1]
|
||||
dir := cb.pos[2]
|
||||
side := cb.pos[3]
|
||||
if y == cb.Size()-1 {
|
||||
// Going to another side
|
||||
switch side {
|
||||
case sideTop:
|
||||
side = sideFront
|
||||
case sideBottom:
|
||||
side = sideBack
|
||||
case sideFront:
|
||||
side = sideBottom
|
||||
case sideBack:
|
||||
side = sideBottom
|
||||
case sideLeft:
|
||||
side = sideBottom
|
||||
case sideRight:
|
||||
side = sideBottom
|
||||
}
|
||||
} else {
|
||||
y = y + 1
|
||||
}
|
||||
return []int{y, x, dir, side}
|
||||
}
|
||||
func (cb *CubeBoard) GetPosRight() []int {
|
||||
y := cb.pos[0]
|
||||
x := cb.pos[1]
|
||||
dir := cb.pos[2]
|
||||
side := cb.pos[3]
|
||||
if x == cb.Size()-1 {
|
||||
// Going to another side
|
||||
switch side {
|
||||
case sideTop:
|
||||
side = sideRight
|
||||
case sideBottom:
|
||||
side = sideRight
|
||||
case sideFront:
|
||||
side = sideRight
|
||||
case sideBack:
|
||||
side = sideLeft
|
||||
case sideLeft:
|
||||
side = sideFront
|
||||
case sideRight:
|
||||
side = sideBack
|
||||
}
|
||||
} else {
|
||||
y = y + 1
|
||||
}
|
||||
return []int{y, x, dir, side}
|
||||
}
|
||||
|
||||
// Get the current pos' side
|
||||
func (cb *CubeBoard) Side() *CubeBoardSide {
|
||||
switch cb.pos[3] {
|
||||
case sideTop:
|
||||
return cb.Top
|
||||
case sideBottom:
|
||||
return cb.Bottom
|
||||
case sideFront:
|
||||
return cb.Front
|
||||
case sideBack:
|
||||
return cb.Back
|
||||
case sideLeft:
|
||||
return cb.Left
|
||||
case sideRight:
|
||||
return cb.Right
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (cb *CubeBoard) Turn(dir byte) {
|
||||
if dir == 'R' {
|
||||
cb.pos[2] = (cb.pos[2] + 1) % dirErr
|
||||
} else if dir == 'L' {
|
||||
cb.pos[2] = (cb.pos[2] - 1 + dirErr) % dirErr
|
||||
}
|
||||
}
|
||||
func (cb *CubeBoard) Tile(y, x, side int) byte {
|
||||
switch side {
|
||||
case sideTop:
|
||||
return cb.Top.Tile(y, x)
|
||||
case sideBottom:
|
||||
return cb.Bottom.Tile(y, x)
|
||||
case sideLeft:
|
||||
return cb.Left.Tile(y, x)
|
||||
case sideRight:
|
||||
return cb.Right.Tile(y, x)
|
||||
case sideFront:
|
||||
return cb.Front.Tile(y, x)
|
||||
case sideBack:
|
||||
return cb.Back.Tile(y, x)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
func (cb *CubeBoard) Password() int {
|
||||
return 0
|
||||
}
|
||||
|
||||
type CubeBoardSide struct {
|
||||
spots [][]byte
|
||||
}
|
||||
|
||||
func BuildCubeBoardSide(inp []string) *CubeBoardSide {
|
||||
cbs := CubeBoardSide{}
|
||||
fmt.Println("Building CBS from:", inp)
|
||||
cbs.spots = make([][]byte, len(inp))
|
||||
for y := range inp {
|
||||
row := make([]byte, len(inp[y]))
|
||||
for x := range inp[y] {
|
||||
row[x] = inp[y][x]
|
||||
}
|
||||
cbs.spots[y] = row
|
||||
}
|
||||
return &cbs
|
||||
}
|
||||
func (cbs *CubeBoardSide) Size() int {
|
||||
return len(cbs.spots)
|
||||
}
|
||||
func (cbs *CubeBoardSide) Tile(y, x int) byte {
|
||||
if len(cbs.spots) < y && len(cbs.spots[y]) < x {
|
||||
return cbs.spots[y][x]
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
type Board struct {
|
||||
spots [][]byte
|
||||
// pos holds
|
||||
// y, x, dir
|
||||
pos []int
|
||||
}
|
||||
|
||||
func BuildBoard(inp []string) *Board {
|
||||
maxX := math.MinInt
|
||||
for y := range inp {
|
||||
maxX = h.Max(maxX, len(inp[y]))
|
||||
}
|
||||
b := Board{
|
||||
spots: make([][]byte, len(inp)),
|
||||
}
|
||||
for y := range inp {
|
||||
sl := make([]byte, maxX)
|
||||
for x := range inp[y] {
|
||||
sl[x] = inp[y][x]
|
||||
}
|
||||
b.spots[y] = sl
|
||||
}
|
||||
|
||||
b.pos = make([]int, 3)
|
||||
for x := range b.spots[0] {
|
||||
if b.spots[0][x] == '.' {
|
||||
b.pos = []int{0, x, dirR}
|
||||
break
|
||||
}
|
||||
}
|
||||
return &b
|
||||
}
|
||||
func (b *Board) Password() int {
|
||||
return ((b.pos[0] + 1) * 1000) + ((b.pos[1] + 1) * 4) + b.pos[2]
|
||||
}
|
||||
func (b *Board) Tile(y, x int) byte {
|
||||
if len(b.spots) > y && len(b.spots[y]) > x {
|
||||
return b.spots[y][x]
|
||||
}
|
||||
return 0
|
||||
}
|
||||
func (b *Board) GetNextPos() []int {
|
||||
switch b.pos[2] {
|
||||
case dirU:
|
||||
return b.GetPosUp()
|
||||
case dirR:
|
||||
return b.GetPosRight()
|
||||
case dirD:
|
||||
return b.GetPosDown()
|
||||
case dirL:
|
||||
return b.GetPosLeft()
|
||||
}
|
||||
return []int{-1, -1}
|
||||
}
|
||||
func (b *Board) GetPosUp() []int {
|
||||
x := b.pos[1]
|
||||
y := ((b.pos[0] - 1) + len(b.spots)) % len(b.spots)
|
||||
for (b.spots[y][x] == 0 || b.spots[y][x] == 32) && y != b.pos[0] {
|
||||
y = ((y - 1) + len(b.spots)) % len(b.spots)
|
||||
}
|
||||
return []int{y, x}
|
||||
}
|
||||
func (b *Board) GetPosRight() []int {
|
||||
y := b.pos[0]
|
||||
x := (b.pos[1] + 1) % len(b.spots[y])
|
||||
for (b.spots[y][x] == 0 || b.spots[y][x] == 32) && x != b.pos[1] {
|
||||
x = (x + 1) % len(b.spots[y])
|
||||
}
|
||||
return []int{y, x}
|
||||
}
|
||||
func (b *Board) GetPosDown() []int {
|
||||
x := b.pos[1]
|
||||
y := (b.pos[0] + 1) % len(b.spots)
|
||||
for (b.spots[y][x] == 0 || b.spots[y][x] == 32) && y != b.pos[0] {
|
||||
y = (y + 1) % len(b.spots)
|
||||
}
|
||||
return []int{y, x}
|
||||
}
|
||||
func (b *Board) GetPosLeft() []int {
|
||||
y := b.pos[0]
|
||||
x := ((b.pos[1] - 1) + len(b.spots[y])) % len(b.spots[y])
|
||||
for (b.spots[y][x] == 0 || b.spots[y][x] == 32) && x != b.pos[1] {
|
||||
x = ((x - 1) + len(b.spots[y])) % len(b.spots[y])
|
||||
}
|
||||
return []int{y, x}
|
||||
}
|
||||
|
||||
func (b *Board) Move(count int) {
|
||||
var to []int
|
||||
for count > 0 {
|
||||
switch b.pos[2] {
|
||||
case dirU:
|
||||
to = b.GetPosUp()
|
||||
case dirR:
|
||||
to = b.GetPosRight()
|
||||
case dirD:
|
||||
to = b.GetPosDown()
|
||||
case dirL:
|
||||
to = b.GetPosLeft()
|
||||
}
|
||||
if b.Tile(to[0], to[1]) == '.' {
|
||||
count--
|
||||
b.pos[0], b.pos[1] = to[0], to[1]
|
||||
} else {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Board) Turn(dir byte) {
|
||||
if dir == 'R' {
|
||||
b.pos[2] = (b.pos[2] + 1) % dirErr
|
||||
} else if dir == 'L' {
|
||||
b.pos[2] = (b.pos[2] - 1 + dirErr) % dirErr
|
||||
}
|
||||
}
|
||||
|
||||
func (b Board) String() string {
|
||||
var ret string
|
||||
for y := range b.spots {
|
||||
for x := range b.spots[y] {
|
||||
bt := b.spots[y][x]
|
||||
if b.pos[1] == x && b.pos[0] == y {
|
||||
switch b.pos[2] {
|
||||
case dirU:
|
||||
bt = '^'
|
||||
case dirR:
|
||||
bt = '>'
|
||||
case dirD:
|
||||
bt = 'v'
|
||||
case dirL:
|
||||
bt = '<'
|
||||
default:
|
||||
bt = '!'
|
||||
}
|
||||
}
|
||||
ret = ret + fmt.Sprint(string(bt))
|
||||
}
|
||||
ret = ret + "\n"
|
||||
}
|
||||
return ret
|
||||
}
|
||||
Reference in New Issue
Block a user