advent2022

main.go (4146B)

---

 package main
 
 import (
 	"bufio"
 	"fmt"
 	"log"
 	"math"
 	"os"
 )
 
 func abs(a int) int {
 	return int(math.Abs(float64(a)))
 }
 func copysign(x, s int) int {
 	return int(math.Copysign(float64(x), float64(s)))
 }
 
 type Pos struct {
 	x, y int
 }
 
 func (p Pos) Diff(o Pos) Pos {
 	var diff Pos
 	diff.x = p.x - o.x
 	diff.y = p.y - o.y
 	return diff
 }
 func (p Pos) Dist(o Pos) int {
 	// returns maximum of distances by X or Y axis
 	diff := p.Diff(o)
 	dx := abs(diff.x)
 	dy := abs(diff.y)
 	if dx > dy {
 		return dx
 	} else {
 		return dy
 	}
 }
 
 type Rope struct {
 	id         int
 	head, tail Pos
 	visited    []Pos
 	attach     *Rope
 }
 
 func (r *Rope) AddVisited(p Pos) {
 	add := true
 	for _, v := range r.visited {
 		if v.x == p.x && v.y == p.y {
 			add = false
 			break
 		}
 	}
 	if add {
 		r.visited = append(r.visited, p)
 	}
 }
 func (r *Rope) MoveTail() {
 	if r.head.Dist(r.tail) > 1 {
 		d := r.head.Diff(r.tail)
 		if abs(d.x) > 1 {
 			d.x /= 2
 		}
 		if abs(d.y) > 1 {
 			d.y /= 2
 		}
 		r.tail.x += d.x
 		r.tail.y += d.y
 
 		r.AddVisited(r.tail)
 	}
 }
 func (r *Rope) Step(dx, dy int) {
 	r.head.x += dx
 	r.head.y += dy
 	r.MoveTail()
 
 	if r.attach != nil {
 		d := r.tail.Diff(r.attach.head)
 		if d.x != 0 || d.y != 0 {
 			r.attach.MoveBy(d)
 		}
 	}
 }
 func (r *Rope) MoveBy(p Pos) {
 	ax, ay := abs(p.x), abs(p.y)
 	if ax != 0 && ay != 0 {
 		// diagonal move
 		for {
 			if ax == 0 || ay == 0 {
 				break
 			}
 			r.Step(copysign(1, p.x), copysign(1, p.y))
 			ax--
 			ay--
 		}
 	}
 	if ax != 0 {
 		for i := 0; i < ax; i++ {
 			r.Step(copysign(1, p.x), 0)
 		}
 	} else if ay != 0 {
 		for i := 0; i < ay; i++ {
 			r.Step(0, copysign(1, p.y))
 		}
 	}
 }
 func (r *Rope) Move(dir string, dist int) {
 	switch dir {
 	case "L":
 		r.MoveBy(Pos{x: -dist})
 	case "R":
 		r.MoveBy(Pos{x: dist})
 	case "U":
 		r.MoveBy(Pos{y: dist})
 	case "D":
 		r.MoveBy(Pos{y: -dist})
 	default:
 		log.Fatal("Invalid direction", dir)
 	}
 }
 
 type Chain struct {
 	first *Rope
 	last  *Rope
 	size  int
 }
 
 func (c *Chain) Move(dir string, dist int) {
 	c.first.Move(dir, dist)
 	// c.Print()
 }
 func (c *Chain) Print() {
 	var points []Pos
 	for rope := c.first; rope != nil; {
 		points = append(points, rope.head)
 		points = append(points, rope.tail)
 		rope = rope.attach
 	}
 	PrintPoints(points)
 }
 func makeChain(size int) Chain {
 	var c Chain
 	c.size = size
 	c.first = &Rope{}
 	c.first.AddVisited(c.first.tail)
 
 	prev := c.first
 	for i := 1; i < size; i++ {
 		r := &Rope{id: i}
 		r.AddVisited(r.tail)
 		prev.attach = r
 		prev = r
 	}
 	c.last = prev
 	return c
 }
 
 func main() {
 	if len(os.Args) > 1 {
 		day09(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 day09(input_file string) {
 	fmt.Printf("day 09 input filename: %s\n", input_file)
 	input, err := os.Open(input_file)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer input.Close()
 	scanner := bufio.NewScanner(input)
 	var rope Rope
 	rope.AddVisited(rope.tail)
 	chain := makeChain(9)
 	for scanner.Scan() {
 		in := scanner.Text()
 		var dir string
 		var dist int
 		found, err := fmt.Sscanf(in, "%s %d", &dir, &dist)
 		if err != nil || found != 2 {
 			log.Fatal("Invalid input string", in, err)
 		}
 		rope.Move(dir, dist)
 		chain.Move(dir, dist)
 	}
 	if err = scanner.Err(); err != nil {
 		log.Fatal(err)
 	}
 
 	fmt.Println("Part 1:", len(rope.visited))
 	fmt.Println("Part 2:", len(chain.last.visited))
 
 	// PrintPoints(chain.last.visited)
 }
 
 func PrintPoints(points []Pos) {
 	var min, max Pos
 	for _, p := range points {
 		if p.x < min.x {
 			min.x = p.x
 		}
 		if p.y < min.y {
 			min.y = p.y
 		}
 		if p.x > max.x {
 			max.x = p.x
 		}
 		if p.y > max.y {
 			max.y = p.y
 		}
 	}
 	if min.x > 0 {
 		min.x = 0
 	}
 	if min.y > 0 {
 		min.y = 0
 	}
 	dx, dy := -min.x, -min.y
 	mx, my := max.x+dx+3, max.y+dy+3
 	grid := make([][]bool, my)
 	for i := 0; i < my; i++ {
 		grid[i] = make([]bool, mx)
 	}
 	for _, p := range points {
 		p.x += dx
 		p.y += dy
 		grid[p.y][p.x] = true
 	}
 	for y := my - 1; y >= 0; y-- {
 		for x := 0; x < mx; x++ {
 			if grid[y][x] {
 				fmt.Print("#")
 			} else if x == dx && y == dy {
 				fmt.Print("X")
 			} else {
 				fmt.Print(".")
 			}
 		}
 		fmt.Print("\n")
 	}
 }