advent2022

main.go (4385B)

---

 package main
 
 import (
 	"fmt"
 	"log"
 	"os"
 )
 
 func main() {
 	if len(os.Args) > 1 {
 		day17(os.Args[1])
 	} else if len(os.Args) == 1 {
 		fmt.Printf("usage: %s inputfile.txt\n", os.Args[0])
 	} else {
 		fmt.Println("No input data")
 	}
 }
 
 func day17(input_file string) {
 	fmt.Printf("day 17 input filename: %s\n", input_file)
 	dirs, err := os.ReadFile(input_file)
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	shapes := []Shape{
 		CreateLine(),
 		CreateCross(),
 		CreateL(),
 		CreateBeam(),
 		CreateBox(),
 	}
 
 	dsum := 0
 	for _, d := range dirs {
 		if d == '<' {
 			dsum--
 		} else if d == '>' {
 			dsum++
 		}
 	}
 
 	field := Field{width: 7, points: make(map[Pos]bool)}
 	var di int64 = -1
 	var si int64 = -1
 	var oy int64 = 0 // old max y
 	var i int64 = 0
 	cache := make(map[string]Pos)
 	getCacheSum := func() Pos {
 		var ret Pos
 		for _, v := range cache {
 			ret.x += v.x
 			ret.y += v.y
 		}
 		return ret
 	}
 	var cachesum Pos
 	for {
 		if i == 2022 {
 			fmt.Println("Part 1:", field.maxY)
 		}
 		if i == 1000000000000 {
 			fmt.Println("Part 2:", field.maxY)
 			break
 		}
 		si++
 		if si >= int64(len(shapes)) {
 			si %= int64(len(shapes))
 		}
 		odi := di
 
 		if i > int64(len(dirs)*2) && i > 20220 {
 			if cachesum.x == 0 || cachesum.y == 0 {
 				cachesum = getCacheSum()
 			}
 			var mul int64 = (1000000000000 - i) / int64(len(cache))
 			var ii int64 = i + int64(len(cache))*mul + 1
 			if mul > 0 {
 				field.maxY += cachesum.x * mul
 				i = ii
 				cpos1 := fmt.Sprintf("%d-%d", si, odi)
 				di = cache[cpos1].y
 				field.maxY += cache[cpos1].x
 				continue
 			} else {
 				cpos1 := fmt.Sprintf("%d-%d", si, odi)
 				if c1, e1 := cache[cpos1]; e1 {
 					field.maxY += c1.x
 					di = c1.y
 					i++
 					continue
 				} else {
 					log.Fatal("missing cache:", cpos1)
 				}
 			}
 		}
 
 		// spawning new block
 		p := Pos{x: 2, y: field.maxY + 3}
 		for {
 			// wind
 			di++
 			if di >= int64(len(dirs)-1) {
 				di %= int64(len(dirs) - 1)
 			}
 			d := dirs[di]
 			if d == '<' && p.x > 0 {
 				p1 := Pos{x: p.x - 1, y: p.y}
 				occ := shapes[si].GetOccupied(p1)
 				if !field.Has(occ) {
 					p.x--
 				}
 			} else if d == '>' && p.x+shapes[si].width < field.width {
 				p1 := Pos{x: p.x + 1, y: p.y}
 				occ := shapes[si].GetOccupied(p1)
 				if !field.Has(occ) {
 					p.x++
 				}
 			}
 
 			// try moving down
 			p1 := Pos{x: p.x, y: p.y - 1}
 			occ := shapes[si].GetOccupied(p1)
 			if p1.y < 0 || field.Has(occ) {
 				// can't move further, gotta stop
 				field.Add(shapes[si].GetOccupied(p))
 				my := p.y + shapes[si].height
 				if my > field.maxY {
 					field.maxY = my
 				}
 				if i > int64(len(dirs)) {
 					tp := fmt.Sprintf("%d-%d", si, odi)
 					cache[tp] = Pos{x: field.maxY - oy, y: di}
 				}
 				oy = field.maxY
 				break
 			} else {
 				p = p1
 			}
 		}
 		i++
 	}
 }
 
 type Pos struct {
 	x, y int64
 }
 type Points []Pos
 
 func (pts Points) Has(p Pos) bool {
 	for _, p1 := range pts {
 		if p1.x == p.x && p1.y == p.y {
 			return true
 		}
 	}
 	return false
 }
 
 type Field struct {
 	width  int64
 	points map[Pos]bool
 	maxY   int64
 }
 
 func (f Field) Has(pts Points) bool {
 	for _, p := range pts {
 		_, has := f.points[p]
 		if has {
 			return true
 		}
 	}
 	return false
 }
 func (f Field) Add(pts Points) {
 	for _, p := range pts {
 		f.points[p] = true
 	}
 }
 
 type Shape struct {
 	width, height int64
 	occupied      Points
 }
 
 func (s Shape) GetOccupied(p Pos) Points {
 	var res Points
 	for _, o := range s.occupied {
 		res = append(res, Pos{p.x + o.x, p.y + o.y})
 	}
 	return res
 }
 
 func CreateLine() Shape {
 	var s Shape
 	s.occupied = Points{
 		Pos{x: 0, y: 0},
 		Pos{x: 1, y: 0},
 		Pos{x: 2, y: 0},
 		Pos{x: 3, y: 0},
 	}
 	s.width = 4
 	s.height = 1
 	return s
 }
 func CreateCross() Shape {
 	var s Shape
 	s.occupied = Points{
 		Pos{x: 1, y: 0},
 		Pos{x: 0, y: 1},
 		Pos{x: 1, y: 1},
 		Pos{x: 2, y: 1},
 		Pos{x: 1, y: 2},
 	}
 	s.width = 3
 	s.height = 3
 	return s
 }
 func CreateL() Shape {
 	var s Shape
 	s.occupied = Points{
 		Pos{x: 0, y: 0},
 		Pos{x: 1, y: 0},
 		Pos{x: 2, y: 0},
 		Pos{x: 2, y: 1},
 		Pos{x: 2, y: 2},
 	}
 	s.width = 3
 	s.height = 3
 	return s
 }
 func CreateBeam() Shape {
 	var s Shape
 	s.occupied = Points{
 		Pos{x: 0, y: 0},
 		Pos{x: 0, y: 1},
 		Pos{x: 0, y: 2},
 		Pos{x: 0, y: 3},
 	}
 	s.width = 1
 	s.height = 4
 	return s
 }
 func CreateBox() Shape {
 	var s Shape
 	s.occupied = Points{
 		Pos{x: 0, y: 0},
 		Pos{x: 1, y: 0},
 		Pos{x: 0, y: 1},
 		Pos{x: 1, y: 1},
 	}
 	s.width = 2
 	s.height = 2
 	return s
 }