oabrivard
/
aoc2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Completed part 1 of Day 22 puzzle (with a lot of pain, and I still don't understand why the 1st algo does not work

Browse Source
main
oabrivard 2 years ago
parent 62f9bf31f5
commit e30e6e8d0a
5 changed files with 1916 additions and 0 deletions
Show Stats Download Patch File Download Diff File

462
day22/archive/day22.go
Unescape Escape View File

@ -0,0 +1,462 @@
package day22
import (
"fmt"
"log"
"slices"
"strings"
"gitea.paas.celticinfo.fr/oabrivard/aoc2023/utils"
)
const BASE_MATRIX_SIZE = 10
type Coord struct {
row int
col int
height int
}
type Brick struct {
ID int
start Coord
end Coord
supportCount int
supports map[int]*Brick
}
func (a *Brick) CmpHeight(b *Brick) int {
return min(a.start.height, a.end.height) - min(b.start.height, b.end.height)
}
func parseBricks(lines []string) []*Brick {
bricks := []*Brick{}
ID := 1
for _, line := range lines {
parts := strings.Split(line, "~")
start := utils.ParseIntArray(parts[0], ",")
end := utils.ParseIntArray(parts[1], ",")
newBrick := Brick{
ID: ID,
start: Coord{start[0], start[1], start[2]},
end: Coord{end[0], end[1], end[2]},
supportCount: 0,
supports: map[int]*Brick{},
}
bricks = append(bricks, &newBrick)
ID++
}
return bricks
}
/*
func place(brick *Brick, tower [][][]int, heightMatrix [][]int, bricks map[int]*Brick) {
if brick.start.height != brick.end.height {
// standup brick
brickSize := brick.end.height - brick.start.height + 1
// insert brick in tower starting at the correct height
heightStart := heightMatrix[brick.start.row][brick.start.col]
for h := heightStart; h < heightStart+brickSize; h++ {
tower[h][brick.start.row][brick.start.col] = brick.ID
}
if heightStart > 0 {
// find the brick below
belowID := tower[heightStart-1][brick.start.row][brick.start.col]
belowBrick := bricks[belowID]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
// set new height for (row,col)
heightMatrix[brick.start.row][brick.start.col] = heightStart + brickSize
return
}
if brick.start.row != brick.end.row {
// vertical line
// find the height at which the brick will land
heightStart := 0
for r := brick.start.row; r <= brick.end.row; r++ {
if heightMatrix[r][brick.start.col] > heightStart {
heightStart = heightMatrix[r][brick.start.col]
}
}
// insert brick in tower starting at the correct height
belowID := 0
for r := brick.start.row; r <= brick.end.row; r++ {
tower[heightStart][r][brick.start.col] = brick.ID
if heightStart > 0 {
// find the brick below
if tower[heightStart-1][r][brick.start.col] != belowID {
belowID = tower[heightStart-1][r][brick.start.col]
if belowID > 0 {
belowBrick := bricks[belowID]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
}
}
}
// set new height for (row,col)
for r := brick.start.row; r <= brick.end.row; r++ {
heightMatrix[r][brick.start.col] = heightStart + 1
}
return
}
if brick.start.col != brick.end.col {
// horizontal line
// find the height at which the brick will land
heightStart := 0
for c := brick.start.col; c <= brick.end.col; c++ {
if heightMatrix[brick.start.row][c] > heightStart {
heightStart = heightMatrix[brick.start.row][c]
}
}
// insert brick in tower starting at the correct height
belowID := 0
for c := brick.start.col; c <= brick.end.col; c++ {
tower[heightStart][brick.start.row][c] = brick.ID
if heightStart > 0 {
// find the brick below
if tower[heightStart-1][brick.start.row][c] != belowID {
belowID = tower[heightStart-1][brick.start.row][c]
if belowID > 0 {
belowBrick := bricks[belowID]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
}
}
}
// set new height for (row,col)
for c := brick.start.col; c <= brick.end.col; c++ {
heightMatrix[brick.start.row][c] = heightStart + 1
}
return
}
}
func Part1(lines []string) (int, []*Brick) {
heightMatrix := make([][]int, BASE_MATRIX_SIZE)
for r := range heightMatrix {
heightMatrix[r] = make([]int, BASE_MATRIX_SIZE)
}
orderedBricks := parseBricks(lines)
maxHeight := 0
for _, b := range orderedBricks {
if b.start.height > b.end.height {
log.Fatalln("Bug with ", b)
}
maxHeight += b.end.height
}
slices.SortFunc(orderedBricks, func(a, b *Brick) int { return a.CmpHeight(b) })
tower := make([][][]int, maxHeight)
for h := range tower {
tower[h] = make([][]int, BASE_MATRIX_SIZE)
for r := range tower[h] {
tower[h][r] = make([]int, BASE_MATRIX_SIZE)
}
}
bricks := map[int]*Brick{}
for _, brick := range orderedBricks {
bricks[brick.ID] = brick
}
for _, brick := range orderedBricks {
fmt.Println("Placing brick ", brick.ID)
place(brick, tower, heightMatrix, bricks)
}
count := 0
for _, brick := range bricks {
canDisintegrate := true
for _, supportedBrick := range brick.supports {
if supportedBrick.supportCount == 0 {
log.Fatalln("Bug ", brick)
}
if supportedBrick.supportCount == 1 {
canDisintegrate = false
}
}
if canDisintegrate {
fmt.Println(brick.ID, string('A'+byte(brick.ID-1)))
count++
}
}
return count, orderedBricks
}
*/
func dropBrick(brick *Brick, heights [][]int, highest [][]*Brick, bricks map[int]*Brick) {
if brick.start.height != brick.end.height {
// standup brick
brickSize := brick.end.height - brick.start.height + 1
height := heights[brick.start.row][brick.start.col]
if height > 0 {
// find the brick below
belowBrick := highest[brick.start.row][brick.start.col]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
// set new height and the new highest brick for (row,col)
heights[brick.start.row][brick.start.col] = height + brickSize
highest[brick.start.row][brick.start.col] = brick
return
}
if brick.start.row != brick.end.row {
// vertical line
// find the height at which the brick will land
height := 0
for r := brick.start.row; r <= brick.end.row; r++ {
if heights[r][brick.start.col] > height {
height = heights[r][brick.start.col]
}
}
// Drop brick at the correct height
var belowBrick *Brick
for r := brick.start.row; r <= brick.end.row; r++ {
// the brick can be supported by multiple other bricks, with spaces in between
if height > 0 && heights[r][brick.start.col] == height {
// find the brick below, but do not count it as a support multiple times
if highest[r][brick.start.col] != belowBrick {
belowBrick = highest[r][brick.start.col]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
}
// set new height and the new highest brick for (row,col)
heights[r][brick.start.col] = height + 1
highest[r][brick.start.col] = brick
}
return
}
if brick.start.col != brick.end.col {
// horizontal line
// find the height at which the brick will land
height := 0
for c := brick.start.col; c <= brick.end.col; c++ {
if heights[brick.start.row][c] > height {
height = heights[brick.start.row][c]
}
}
// Drop brick at the correct height
var belowBrick *Brick
for c := brick.start.col; c <= brick.end.col; c++ {
// the brick can be supported by multiple other bricks, with spaces in between
if height > 0 && heights[brick.start.row][c] == height {
// find the brick below, but do not count it as a support multiple times
if highest[brick.start.row][c] != belowBrick {
belowBrick = highest[brick.start.row][c]
// indicate to the below brick that it supports the current brick
belowBrick.supports[brick.ID] = brick
// increase the number of bricks supporting the current brick
brick.supportCount++
}
}
// set new height and the new highest brick for (row,col)
heights[brick.start.row][c] = height + 1
highest[brick.start.row][c] = brick
}
return
}
}
func Part1(lines []string) (int, []*Brick) {
heights := make([][]int, BASE_MATRIX_SIZE)
highest := make([][]*Brick, BASE_MATRIX_SIZE)
for r := range heights {
heights[r] = make([]int, BASE_MATRIX_SIZE)
highest[r] = make([]*Brick, BASE_MATRIX_SIZE)
}
orderedBricks := parseBricks(lines)
slices.SortFunc(orderedBricks, func(a, b *Brick) int { return a.CmpHeight(b) })
bricks := map[int]*Brick{}
for _, brick := range orderedBricks {
bricks[brick.ID] = brick
}
for _, brick := range orderedBricks {
fmt.Println("Placing brick ", brick.ID)
dropBrick(brick, heights, highest, bricks)
}
count := 0
for _, brick := range bricks {
canDisintegrate := true
for _, supportedBrick := range brick.supports {
if supportedBrick.supportCount == 0 {
log.Fatalln("Bug ", brick)
}
if supportedBrick.supportCount == 1 {
canDisintegrate = false
}
}
if canDisintegrate {
fmt.Println(brick.ID, string('A'+byte(brick.ID-1)))
count++
}
}
return count, orderedBricks
}
/*
type Brick struct {
x, y, z int
x2, y2, z2 int
}
func (b *Brick) String() string {
return fmt.Sprintf("%d,%d,%d~%d,%d,%d", b.x, b.y, b.z, b.x2, b.y2, b.z2)
}
func (b *Brick) WouldCollide(otherBrick *Brick) bool {
if b.z <= otherBrick.z2 && b.z2 >= otherBrick.z {
if b.y <= otherBrick.y2 && b.y2 >= otherBrick.y {
if b.x <= otherBrick.x2 && b.x2 >= otherBrick.x {
return true
}
}
}
return false
}
func stack(bricks []Brick) int {
moves := make(map[int]int)
for i := 0; i < len(bricks); i++ {
// While the brick isn't on the floor keep checking the levels below
for bricks[i].z > 1 {
newBrick := bricks[i]
newBrick.z--
newBrick.z2--
wouldCollide := false
// See if moving the brick down a Z level would hit another brick
for j := i - 1; j > -1; j-- {
if bricks[j].WouldCollide(&newBrick) {
wouldCollide = true
break
}
}
if wouldCollide {
break
}
moves[i]++
bricks[i] = newBrick
}
}
return len(moves)
}
func process(input []string) int {
// Build the bricks
var bricks []Brick
for _, row := range input {
items := strings.FieldsFunc(row, func(r rune) bool {
return r == ',' || r == '~'
})
brick := Brick{
x: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[0]),
y: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[1]),
z: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[2]),
x2: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[3]),
y2: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[4]),
z2: func(item string) int { i, _ := strconv.Atoi(item); return i }(items[5]),
}
bricks = append(bricks, brick)
}
// Input isn't in Z order so sort
slices.SortFunc(bricks, func(a, b Brick) int {
return min(a.z, a.z2) - min(b.z, b.z2)
})
// Stack the bricks
stack(bricks)
// Now take each brick out, and see it if it was supporting anything
noneSupportingBricks := 0
for i := 0; i < len(bricks); i++ {
stackCopy := make([]Brick, len(bricks))
copy(stackCopy, bricks)
stackCopy = append(stackCopy[:i], stackCopy[i+1:]...)
changes := stack(stackCopy)
if changes == 0 {
noneSupportingBricks++
}
}
return noneSupportingBricks
}
*/

186
day22/day22.go
Unescape Escape View File

@ -0,0 +1,186 @@
package day22
import (
"fmt"
"log"
"slices"
"strings"
"gitea.paas.celticinfo.fr/oabrivard/aoc2023/utils"
)
type Coord struct {
x int
y int
z int
}
type Brick struct {
ID int
start Coord
end Coord
supportedBy map[int]*Brick
supports map[int]*Brick
}
type Tower struct {
floors [][][]*Brick
maxFloors int
floorWidth int
}
// parseBricks returns an array of bricks sorted by height
func parseBricks(lines []string) []*Brick {
bricks := []*Brick{}
ID := 1
for _, line := range lines {
parts := strings.Split(line, "~")
start := utils.ParseIntArray(parts[0], ",")
end := utils.ParseIntArray(parts[1], ",")
newBrick := Brick{
ID: ID,
start: Coord{start[0], start[1], start[2]},
end: Coord{end[0], end[1], end[2]},
supportedBy: map[int]*Brick{},
supports: map[int]*Brick{},
}
if newBrick.start.x > newBrick.end.x ||
newBrick.start.y > newBrick.end.y ||
newBrick.start.z > newBrick.end.z {
log.Fatalf("Input error for brick %v", newBrick)
}
bricks = append(bricks, &newBrick)
ID++
}
slices.SortFunc(bricks, func(a, b *Brick) int {
return a.start.z - b.start.z
})
return bricks
}
// create a tower with an empty floor at level 0
func NewTower(height, width int) Tower {
floors := make([][][]*Brick, height+1)
for z := range floors {
floors[z] = make([][]*Brick, width)
for x := range floors[z] {
floors[z][x] = make([]*Brick, width)
}
}
return Tower{floors, height, width}
}
func (tower *Tower) maxHeight() int { return tower.maxFloors }
func (tower *Tower) intersections(brick *Brick, currZ int) []*Brick {
bricks := []*Brick{}
for x := brick.start.x; x <= brick.end.x; x++ {
for y := brick.start.y; y <= brick.end.y; y++ {
if tower.floors[currZ][x][y] != nil {
bricks = append(bricks, tower.floors[currZ][x][y])
}
}
}
return bricks
}
func (tower *Tower) layout(brick *Brick, currZ int) {
brickHeight := brick.end.z - brick.start.z + 1
for z := currZ; z < currZ+brickHeight; z++ {
for x := brick.start.x; x <= brick.end.x; x++ {
for y := brick.start.y; y <= brick.end.y; y++ {
tower.floors[z][x][y] = brick
}
}
}
}
func (tower *Tower) addBrick(brick *Brick) {
currZ := tower.maxHeight()
for currZ > 0 {
intersections := tower.intersections(brick, currZ-1)
if len(intersections) > 0 {
// Layout the current brick on the current floor
tower.layout(brick, currZ)
// add the current brick to the "supports" list of each supporting brick
// and add the supporting bricks to the "supportedBy" list of the current brick
for _, supportingBrick := range intersections {
supportingBrick.supports[brick.ID] = brick
brick.supportedBy[supportingBrick.ID] = supportingBrick
}
// brick is layed out, exit function
return
}
currZ--
}
// layout the brick on the first floor
tower.layout(brick, 1)
}
func (tower *Tower) Print() {
//for z := tower.maxHeight(); z >= 0; z-- {
for z := 8; z > 0; z-- {
for x := 0; x < tower.floorWidth; x++ {
for y := 0; y < tower.floorWidth; y++ {
if tower.floors[z][x][y] != nil {
fmt.Print(tower.floors[z][x][y].ID)
} else {
fmt.Print(".")
}
}
fmt.Println(" ")
}
fmt.Println(" ")
}
fmt.Println(" ")
}
func Part1(lines []string) (int, []*Brick) {
bricks := parseBricks(lines)
tower := NewTower(500, 10)
for _, brick := range bricks {
fmt.Printf("Placing brick %d (%v)~(%v)\n", brick.ID, brick.start, brick.end)
tower.addBrick(brick)
}
count := 0
for _, brick := range bricks {
canDisintegrate := true
for _, supportedBrick := range brick.supports {
if len(supportedBrick.supportedBy) == 0 {
log.Fatalln("Bug ", brick)
}
if len(supportedBrick.supportedBy) == 1 {
canDisintegrate = false
}
}
if canDisintegrate {
fmt.Println(brick.ID, string('A'+byte(brick.ID-1)))
count++
}
}
tower.Print()
return count, bricks
}

37
day22/day22_test.go
Unescape Escape View File

@ -0,0 +1,37 @@
package day22
import (
"testing"
"gitea.paas.celticinfo.fr/oabrivard/aoc2023/utils"
)
func TestPart1(t *testing.T) {
lines := []string{
"1,0,1~1,2,1", // 1
"0,0,2~2,0,2", // 2
"0,2,3~2,2,3", // 3
"0,0,4~0,2,4", // 4
"2,0,5~2,2,5", // 5
"0,1,6~2,1,6", // 6
"1,1,8~1,1,9", // 7
}
result, _ := Part1(lines)
//result := process(lines)
if result != 5 {
t.Fatalf("expected 5, got %d", result)
}
}
func TestPart1WithInput(t *testing.T) {
lines := utils.ReadLines("input.txt")
result, _ := Part1(lines)
//result := process(lines)
if result != 428 {
t.Fatalf("expected 428, got %d", result)
}
}

1231
day22/input.txt
View File

File diff suppressed because it is too large Load Diff

0
go.sum
Unescape Escape View File

Write Preview
Loading…
Cancel
Save