🌟 Advent of Code (AoC) 2022 🌟

import numpy as np
from functools import reduce

def get_shorter(l, level):
    for i in l:
        yield i
        if i >= level: return

print((lambda a, fs:
       [(lambda a, f1, f2, f3: f1(reduce(f2,
                                         [np.rot90(f3(np.rot90(a, k = i)), k = -i)
                                          for i in range(4)])))
                       (a, *f) for f in fs])(
                          np.array([[int(c) for c in l.strip()]
                                    for l in open("input08").readlines()]),
                          
                          [(np.sum, np.logical_or,
                            lambda a: (a > np.insert(np.maximum.accumulate(a, axis = 0)[:-1,:], 0, -1, axis = 0))),
                           (np.max, np.multiply,
                            lambda a: np.array([[len(list(get_shorter(l[i+1:], l[i])))
                                                 for i in range(len(l))]
                                                for l in a]))]))

import {readFileSync} from 'fs';

const trees = readFileSync("08data","utf8")
.split("\n")
.map(line => 
    line.split("").map( height => Number(height))
);

const amountOfVisibleTrees = (y,x, part) => {
    const baseTreeHeight = trees[y][x];

    let visibleFromLeft = true;
    let visibleTreesLookingLeft = 0; 
    for(let _x = x - 1; _x >= 0 && visibleFromLeft; _x--){
        visibleTreesLookingLeft++;
        visibleFromLeft = trees[y][_x] < baseTreeHeight;
    }

    let visibleFromRight = true;
    let visibleTreesLookingRight = 0; 
    for(let _x = x + 1; _x < trees[y].length && visibleFromRight; _x++){
        visibleTreesLookingRight++;
        visibleFromRight = trees[y][_x] < baseTreeHeight ; //visibleFromRight = !(trees[y][_x] >= baseTreeHeight );
    }

    let visibleFromUp = true;
    let visibleTreesLookingUp = 0; 
    for(let _y = y - 1; _y >= 0 && visibleFromUp; _y--){
        visibleTreesLookingUp++;
        visibleFromUp = trees[_y][x] < baseTreeHeight;
    }

    let visibleFromDown = true;
    let visibleTreesLookingDown = 0;
    for(let _y = y + 1; _y < trees[x].length && visibleFromDown; _y++){
        visibleTreesLookingDown++;
        visibleFromDown = trees[_y][x] < baseTreeHeight;
    }

    return part ? (visibleFromLeft || visibleFromRight|| visibleFromUp || visibleFromDown) : visibleTreesLookingLeft * visibleTreesLookingRight * visibleTreesLookingUp * visibleTreesLookingDown;
};

let totalVisisble = 0;
let highestScore = 0;
for(let y = 0; y < trees[0].length; y++){
    for(let x = 0; x < trees[y].length; x++){
        totalVisisble += amountOfVisibleTrees(y,x,1) ? 1:0;
        const visibleTrees = amountOfVisibleTrees(y,x);
        if (visibleTrees>highestScore){
            highestScore = visibleTrees;
        }
    }
}
console.log("Part 1:",totalVisisble);
console.log("Part 2:",highestScore);

with open("8.txt") as f:
    a = [[*map(int, r)] for r in f.read().splitlines()]

v = lambda t: (t[0], [[1 if (j == 0 or t[0][i][j] > max(t[0][i][:j])) else t[1][i][j] for j in range(len(t[0][0]))] for i in range(len(t[0]))])
h = lambda t: [[list(r) for r in zip(*m[::-1])] for m in t]

sum(sum(w) for w in v(h(v(h(v(h(v((a, [[0 for _ in r] for r in a]))))))))[1])

package main

import "fmt"

type TreePos struct {
	x, y int
}
type Forest map[TreePos]int

var allDirections = [4]TreePos{{0, -1}, {-1, 0}, {0, 1}, {1, 0}}

func parseForest(input []string) Forest {
	forest := Forest{}
	for y, row := range input {
		for x, height := range row {
			pos := TreePos{x, y}
			forest[pos] = int(height - '0')
		}
	}
	return forest
}

func (forest Forest) moveAt(pos TreePos, dx, dy int, visitor func(Forest, TreePos) bool) {
	for {
		pos.x += dx
		pos.y += dy
		if !visitor(forest, pos) {
			break
		}
	}
}

func (forest Forest) isVisible(pos TreePos) bool {
	startHeight := forest[pos]
	visible := false
	for i := 0; !visible && i < len(allDirections); i++ {
		d := allDirections[i]
		forest.moveAt(pos, d.x, d.y, func(f Forest, p TreePos) bool {
			if height, inForest := f[p]; !inForest {
				visible = true
				return false
			} else {
				return height < startHeight
			}
		})
	}
	return visible
}

func (forest Forest) numVisibleTrees() int {
	visibleTrees := 0
	for pos := range forest {
		if forest.isVisible(pos) {
			visibleTrees++
		}
	}
	return visibleTrees
}

func (forest Forest) scenicScore(pos TreePos) int {
	startHeight := forest[pos]
	score := 1
	for _, d := range allDirections {
		steps := 0
		forest.moveAt(pos, d.x, d.y, func(f Forest, p TreePos) bool {
			if height, inForest := f[p]; !inForest {
				return false
			} else {
				steps += 1
				return height < startHeight
			}
		})
		score *= steps
	}
	return score
}

func (forest Forest) bestScenicScore() int {
	bestScore := 0
	for pos := range forest {
		score := forest.scenicScore(pos)
		if bestScore < score {
			bestScore = score
		}
	}
	return bestScore
}

func day8(input []string) {
	forest := parseForest(input)
	fmt.Println(forest.numVisibleTrees())
	fmt.Println(forest.bestScenicScore())
}

func init() {
	Solutions[8] = day8
}

using System.Diagnostics;
using AoCUtils;

Console.WriteLine("Mickur's Advent of Code 2022 - Day 9!");

// Setup
var input = File.ReadAllLines("input.txt");
const int ropeLength = 10; // Includes the head!

// Initialize the positions of the head and tail as a tuple of coordinates
var ropeArray = new (int, int)[ropeLength];
var ropeVisitedArray = new Dictionary<string, int>[ropeLength];

// Fill arrays with starting data
for (var i = 0; i < ropeLength; i++)
{
    ropeArray[i] = (0, 0);
    ropeVisitedArray[i] = new Dictionary<string, int> {{"0x0", 1}};
}

var sw = new Stopwatch();
sw.Start();

// Loop through each move in the input
foreach (var move in input)
{
    var splitMove = move.Split(' ');
    var steps = Parsing.FastIntParse(splitMove[1]);

    for (var i = 0; i < steps; i++)
    {
        // Loop through rope
        for (var j = 0; j < ropeLength; j++)
        {
            var temp = ropeArray[j];
            
            // Update the position of the rope
            if(j == 0)
                ropeArray[j] = UpdateHeadPosition(ropeArray[j], move[0]);
            else
                ropeArray[j] = UpdateTailPosition(ropeArray[j-1], ropeArray[j]);
            
            // Save visited state
            if (ropeArray[j] != temp)
            {
                var key = $"{ropeArray[j].Item1}x{ropeArray[j].Item2}";

                if (ropeVisitedArray[j].TryGetValue(key, out var value))
                    value++;
                else
                {
                    ropeVisitedArray[j].Add(key, 1);
                }
            }
        }
    }
}

sw.Stop();
Console.WriteLine($"Finished in {sw.ElapsedMilliseconds} ms ({sw.ElapsedTicks} ticks)");

// Print the final position of the tails
for (var i = 0; i < ropeLength; i++)
{
    if (i == 0)
        Console.WriteLine($"Head visited: {ropeVisitedArray[i].Count} places");
    else
        Console.WriteLine($"Tail {i} visited: {ropeVisitedArray[i].Count} places");
}

(int, int) UpdateHeadPosition((int, int) head, char move)
{
    var x = head.Item1;
    var y = head.Item2;

    switch (move)
    {
        case 'U':
            y--;
            break;
        case 'D':
            y++;
            break;
        case 'L':
            x--;
            break;
        case 'R':
            x++;
            break;
    }

    return (x, y);
}

(int, int) UpdateTailPosition((int, int) head, (int, int) tail)
{
    // Get the current positions of the head and tail
    var headX = head.Item1;
    var headY = head.Item2;
    var tailX = tail.Item1;
    var tailY = tail.Item2;

    // If tail is close enough to head, don't move
    if (Math.Abs(headX - tailX) <= 1 && Math.Abs(headY - tailY) <= 1)
        return tail;

    // Same X dimension, move in Y dimension
    if (headX == tailX)
        tailY = tailY < headY ? headY - 1 : headY + 1;
    
    // Same Y dimension, move in X dimension
    else if (headY == tailY)
        tailX = tailX < headX ? headX - 1 : headX + 1;

    // Else move diagonally towards head
    else
    {
        tailX = headX > tailX ? tailX + 1 : tailX - 1;
        tailY = headY > tailY ? tailY + 1 : tailY - 1;
    }

    // Return the new position of the tail as a tuple of coordinates
    return (tailX, tailY);
}

dir = {"U": complex(0,1), "D": complex(0,-1), "L": complex(-1,0), "R": complex(1,0)}
parts = [complex(0,0)] * 10
visited = [set(), set(), set(), set(), set(), set(), set(), set(), set(), set(), set()]

for move in open("input09").readlines():
    m = move.strip().split()
    for _ in range(int(m[1])):
        parts[0] += dir[m[0]]
        for i in range(1, len(parts)):
            if abs(diff := parts[i - 1] - parts[i]) > 1.5:
                parts[i] += complex(diff.real / abs(diff.real) if diff.real else 0,
                                    diff.imag / abs(diff.imag) if diff.imag else 0) 
            visited[i].add(parts[i])
print([len(visited[i]) for i in [1,9]])

main() {
	println(day9(MutableList(2) {Point(0, 0)}, input.lines())) // Part 1
	println(day9(MutableList(10) {Point(0, 0)}, input.lines())) // Part 2
}

fun day9(chain: MutableList<Point>, instructions: List<String>): Int{
	val usedPositions = mutableSetOf<Point>()
	for (line in instructions) {
		val (direction, length) = line.split(" ")
		for (iterate in 0 until length.toInt()) {
			chain[0] = chain[0].relativePosition(direction, 1)

			for (i in 1 until chain.size) {
				if (chain[i] !in chain[i-1].surroundingPoints() && chain[i] != chain[i-1]) {
					chain[i] = chain[i].surroundingPoints().intersect(chain[i-1].surroundingPoints()).toList()
						.minBy{ it.manhattanDistance(chain[i-1]) }
				}
			}
			usedPositions.add(chain.last())
		}
	}
	return usedPositions.size
}

data class Point(val x: Int, val y: Int) {

	fun relativePosition(direction: String, distance: Int):Point {
		return when (direction) {
			"U" -> Point(this.x, this.y + distance)
			"D" -> Point(this.x, this.y - distance)
			"R" -> Point(this.x + distance, this.y)
			"L" -> Point(this.x - distance, this.y)
			else -> throw IllegalArgumentException("Not a valid direction code")
		}
	}

	fun surroundingPoints() = listOf(-1, -1, -1, 0, -1, 1, 0, -1, 0, 1, 1, -1, 1, 0, 1, 1).chunked(2).map { Point(this.x + it[0], this.y + it[1]) }.toSet()

	fun manhattanDistance(other:Point):Int {
		return abs(this.x - other.x) + abs(this.y - other.y)
	}
}

CHILL OUT input STICK AROUND `<input här>`

CHILL OUT sum STICK AROUND GIVE THESE PEOPLE AIR arr ENOUGH TALK => 
  arr I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE reduce GIVE THESE PEOPLE AIR GIVE THESE PEOPLE AIR a, b ENOUGH TALK =>
    a GET UP b, 0 ENOUGH TALK

CHILL OUT array STICK AROUND GIVE THESE PEOPLE AIR input ENOUGH TALK =>
  input I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE split GIVE THESE PEOPLE AIR '\n\n' ENOUGH TALK
    I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE map GIVE THESE PEOPLE AIR row => row
      I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE split GIVE THESE PEOPLE AIR '\n' ENOUGH TALK
      I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE map GIVE THESE PEOPLE AIR n => parseInt GIVE THESE PEOPLE AIR n ENOUGH TALK ENOUGH TALK
      I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE reduce GIVE THESE PEOPLE AIR GIVE THESE PEOPLE AIR a, b ENOUGH TALK => a GET UP b, 0 ENOUGH TALK
    ENOUGH TALK
  I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE sort GIVE THESE PEOPLE AIR GIVE THESE PEOPLE AIR a, b ENOUGH TALK => b GET DOWN a ENOUGH TALK TERMINATED

TALK TO THE HAND GIVE THESE PEOPLE AIR array GIVE THESE PEOPLE AIR input ENOUGH TALK [0] ENOUGH TALK

import {readFileSync} from 'fs';

const movements = readFileSync("09data","utf8")
.split("\n")
.map(line => {
    const parts = line.split(" ");
    return [parts[0], Number(parts[1])];
});

function moveTails(currentPositions, visitedPositionsByLastTail){
    for(let i = 1; i <= currentPositions.length -1 ; i++){
        const currentHeadPosition = currentPositions[i-1];
        const currentTailPosition = currentPositions[i];

        const xDiff = currentTailPosition[0] - currentHeadPosition[0];
        const yDiff = currentTailPosition[1] - currentHeadPosition[1];
        if(Math.abs(xDiff) + Math.abs(yDiff) > 2 ){ // means we need to do a diagonal move
            currentPositions[i] = [currentTailPosition[0] + (xDiff > 0 ? -1 : 1),currentTailPosition[1] + (yDiff > 0 ? -1 : 1) ];
        } else if(Math.abs(xDiff) > 1){ 
            currentPositions[i] = [currentTailPosition[0] + (xDiff > 0 ? -1 : 1), currentTailPosition[1]];
        } else if(Math.abs(yDiff) > 1){
            currentPositions[i] = [currentTailPosition[0], currentTailPosition[1] + (yDiff > 0 ? -1 : 1)];
        }
        if(i === currentPositions.length -1){ //record the position of the last piece of the tail. don't care if it didn't move as it's a Set.
            visitedPositionsByLastTail.add(`${currentPositions[i][0]},${currentPositions[i][1]}`);
        }
    }
}
const directions = {U:[0,1], R:[1,0], D:[0,-1], L:[-1,0]};

function run(part, currentPositions){
    const visitedPositionsByLastTail = new Set();
    movements.forEach((movement) => {
        for(let i = 1; i <= movement[1]; i++){
            currentPositions[0] = [
                currentPositions[0][0] + directions[movement[0]][0],
                currentPositions[0][1] + directions[movement[0]][1]
            ];
            moveTails(currentPositions, visitedPositionsByLastTail);
       }
   });
   console.log(`Part ${part}:`, visitedPositionsByLastTail.size);
}

const part1StartPositions = [[0,0],[0,0]];
run(1, part1StartPositions);
const part2StartPositions = [[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0],[0,0]];
run(2, part2StartPositions);

type direction string

const (
	left  direction = "L"
	right direction = "R"
	up    direction = "U"
	down  direction = "D"
)

type positions map[coordinate]struct{}
type coordinate struct {
	x, y int
}
type instruction struct {
	dir   direction
	steps int
}

func main() {
	input, err := helpers.ReadLines(os.Args[1])

	if err != nil {
		panic(err)
	}

	visitedPositionsLongRope := make(positions)
	longRope := make([]coordinate, 10)
	for i := 0; i < len(longRope); i++ {
		longRope[i] = coordinate{x: 0, y: 0}
	}

	visitedPositionsShortRope := make(positions)
	shortRope := make([]coordinate, 2)
	for i := 0; i < len(shortRope); i++ {
		shortRope[i] = coordinate{x: 0, y: 0}
	}

	visitedPositionsShortRope[shortRope[0]] = struct{}{}
	visitedPositionsLongRope[longRope[0]] = struct{}{}

	for _, line := range input {
		instructions := strings.Split(line, " ")
		ins := instruction{dir: direction(instructions[0]), steps: helpers.GetInt(instructions[1])}
		shortRope = visitedPositionsShortRope.performSteps(shortRope, ins)
		longRope = visitedPositionsLongRope.performSteps(longRope, ins)
	}
	fmt.Println(len(visitedPositionsShortRope))
	fmt.Println(len(visitedPositionsLongRope))
}

func (positions positions) performSteps(knots []coordinate, instruction instruction) []coordinate {
	head := knots[0]
	for s := 0; s < instruction.steps; s++ {
		switch instruction.dir {
		case left:
			head.x = head.x - 1
		case right:
			head.x = head.x + 1
		case up:
			head.y = head.y - 1
		case down:
			head.y = head.y + 1
		}

		knots[0] = head
		for t := 0; t < len(knots)-1; t++ {
			head := knots[t]
			tail := knots[t+1]
			dx, dy := head.x-tail.x, head.y-tail.y

			if math.Abs(float64(dx)) <= 1 && math.Abs(float64(dy)) <= 1 {
				continue
			}

			tail.x += moveTail(dx)
			tail.y += moveTail(dy)
			if _, ok := positions[tail]; !ok && t == len(knots)-2 {
				positions[tail] = struct{}{}
			}
			knots[t+1] = tail
		}
	}
	return knots
}

func moveTail(diff int) int {
	if diff == 0 {
		return 0
	} else if diff < 0 {
		return -1
	} else {
		return 1
	}
}

X, during = 1, [1]

for i in open("input10").readlines():
    during.append(X)
    if i[0] == "a":
            X += int(i[5:])
            during.append(X)

print(sum([i * during[i] for i in range(20, len(during), 40)]))

s = "".join([".#"[during[i] in [(i - 1) % 40, i % 40, (i + 1) % 40]] for i in range(240)])
for i in range(0,240,40):
    print(s[i:i + 40])

using System.Diagnostics;
using AoCUtils;

Console.WriteLine("Mickur's Advent of Code 2022 - Day 10!");

// Setup
var input = File.ReadAllLines("input.txt");

var toBeAdded = 0;
var shouldBeAdded = false;

var register = 1;
var cycles = 0;
var signalStrengths = new List<int>();

var crt = new char[40, 6];
crt[0, 0] = '#';

var sw = new Stopwatch();
sw.Start();

// Loop through each move in the input
for (var i = 0; cycles < 240; i++)
{
    // Cycle Start
    cycles++;

    AddSignalStrength();
    DrawCrt();
    
    // 2 cycle operation
    if (input[i] != "noop")
    {
        toBeAdded = Parsing.FastIntParse(input[i].AsSpan(5));
        shouldBeAdded = true;
        
        cycles++;

        AddSignalStrength();
        DrawCrt();
    }
    
    // Add values
    if (shouldBeAdded)
    {
        register += toBeAdded;
        shouldBeAdded = false;
    }
}

sw.Stop();
Console.WriteLine($"Finished in {sw.ElapsedMilliseconds} ms ({sw.ElapsedTicks} ticks)");

Console.WriteLine($"Part One answer: Sum of signal strengths is {signalStrengths.Sum()}");

Console.WriteLine($"Part Two answer: CRT output below");
for (var y = 0; y < 6; y++)
{
    for (var x = 0; x < 40; x++)
    {
        Console.Write(crt[x, y]);
    }
    Console.Write(Environment.NewLine);
}

void AddSignalStrength()
{
    if (cycles == 20 || (cycles + 20) % 40 == 0)
    {
        signalStrengths.Add(register * cycles);
    }
}

void DrawCrt()
{
    var x = (cycles - 1) % 40;
    var y = cycles / 40;

    if(x < 40 && y < 6)
        if (Math.Abs(register - x) <= 1)
            crt[x, y] = '#';
        else 
            crt[x, y] = '.';
}

use std::{fmt::Display, collections::BTreeSet};

#[derive(Debug, Clone, Default)]
struct Board {
  tail_length: i32,
  head: (i32, i32),
  tail: Vec<(i32, i32)>,
  visited: BTreeSet<(i32, i32)>,
}

impl Board {
  fn new(tail_length: i32) -> Self {
    Self {
      tail_length,
      tail: vec![(0, 0); tail_length as usize],
      ..Default::default()
    }
  }

  fn apply_move(&mut self, m: Move) {
    for Move(dx, dy) in m.steps() {
      let (x, y) = self.head;
      self.head = (x + dx, y + dy);
      for i in 0..self.tail_length {
        let head = 
          if i == 0 {
            self.head
          } else {
            self.tail[(i - 1) as usize]
          };
        let mut tail = self.tail[i as usize];

        if head != tail {
          let (hx, hy) = head;
          let (tx, ty) = tail;
          let (dx, dy) = (hx - tx, hy - ty);
          if dx != 0 && dy != 0 && dx.abs() + dy.abs() > 2 {
            tail = (tx + dx.signum(), ty + dy.signum());
          } else if (dx == 0 || dy == 0) && (dx != 0 || dy != 0) {
            tail = (tx + (dx - dx.signum()), ty + (dy - dy.signum()))
          }
          self.tail[i as usize] = tail;
        }
      }
      if let Some(tail) = self.tail.last() {
        self.visited.insert(*tail);
      }
    }
  }
}

impl Display for Board {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    let min_x = self.head.0
      .min(*self.tail.iter().map(|(x, _)| x).min().unwrap_or(&self.head.0))
      .min(*self.visited.iter().map(|(x, _)| x).min().unwrap_or(&self.head.0));
    let max_x = self.head.0
      .max(*self.tail.iter().map(|(x, _)| x).max().unwrap_or(&self.head.0))
      .max(*self.visited.iter().map(|(x, _)| x).max().unwrap_or(&self.head.0));
    let min_y = self.head.1
      .min(*self.tail.iter().map(|(_, y)| y).min().unwrap_or(&self.head.1))
      .min(*self.visited.iter().map(|(_, y)| y).min().unwrap_or(&self.head.1));
    let max_y = self.head.1
      .max(*self.tail.iter().map(|(_, y)| y).max().unwrap_or(&self.head.1))
      .max(*self.visited.iter().map(|(_, y)| y).max().unwrap_or(&self.head.1));

    for neg_y in min_y..=max_y {
      let y = (max_y + min_y) - neg_y;
      for x in min_x..=max_x {
        if (x, y) == self.head {
          write!(f, "H")?;
        } else if self.tail.contains(&(x, y)) {
          write!(f, "{}", self.tail.iter().position(|(tx, ty)| (x, y) == (*tx, *ty)).unwrap() + 1)?;
        } else if (x, y) == (0, 0) {
          write!(f, "s")?;
        } else if self.visited.contains(&(x, y)) {
          write!(f, "#")?;
        } else {
          write!(f, ".")?;
        }
      }
      writeln!(f)?;
    }

    Ok(())
  }
}

#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
struct Move(i32, i32);

impl Move {
  fn parse(s: &str) -> Self {
    let mut chars = s.chars();
    let dir = chars.next().unwrap();
    chars.next();
    let dist = chars.as_str().parse::<i32>().unwrap();
    match dir {
      'U' => Self(0, dist),
      'D' => Self(0, -dist),
      'L' => Self(-dist, 0),
      'R' => Self(dist, 0),
      _ => panic!("Invalid direction"),
    }
  }

  fn steps(&self) -> Vec<Move> {
    let Move(x, y) = self;
    let mut result = vec![];
    for _ in 0..x.abs() {
      result.push(Move(x.signum(), 0));
    }
    for _ in 0..y.abs() {
      result.push(Move(0, y.signum()));
    }
    result
  }
}

pub fn one() {
  let input = include_str!("input1.txt");
  let mut board = Board::new(1);

  for line in input.lines() {
    let m = Move::parse(line);
    println!("{:?}", m);
    board.apply_move(m);
  }
  println!("{}", board);
  let result = board.visited.len();
  println!("Day 9, part 1: {}", result); // 6026
}

pub fn two() {
  let input = include_str!("input1.txt");
  let mut board = Board::new(9);

  for line in input.lines() {
    let m = Move::parse(line);
    println!("{:?}", m);
    board.apply_move(m);
  }
  println!("{}", board);
  let result = board.visited.len();
  println!("Day 9, part 2: {:?}", result);
}

use derivative::Derivative;

#[derive(Derivative)]
#[derivative(Debug)]
struct Cpu {
  result: u32,
  cycles: u32,
  x: i32,
  #[derivative(Debug = "ignore")]
  crt: [u8; 240]
}

impl Cpu {
  fn new() -> Cpu {
    Self {
      result: 0,
      cycles: 0,
      x: 1,
      crt: [0; 240],
    }
  }

  fn signal_strength(&self) -> u32 {
    self.cycles * self.x as u32
  }

  fn run(&mut self, inst: Instruction) {
    match inst {
      Instruction::Addx(i) => {
        self.tick();
        self.tick();
        self.x += i;
      },
      Instruction::Noop => {
        self.tick();
      },
    }
  }

  fn tick(&mut self) {
    match self.cycles {
      20 | 60 | 100 | 140 | 180 | 220 => {
        println!("cycle: {}, signal strength: {}", self.cycles, self.signal_strength());
        self.result += self.signal_strength();
      }
      _ => {}
    }
    let crt_pos = (self.cycles % 40) as i32;
    if ((self.x - 1)..=(self.x + 1)).contains(&crt_pos) {
      self.crt[self.cycles as usize] = 1;
    }
    self.cycles += 1;
  }
}

#[derive(Debug)]
enum Instruction {
  Addx(i32),
  Noop,
}

impl Instruction {
  fn parse(s: &str) -> Instruction {
    let mut parts = s.split_whitespace();
    let op = parts.next().unwrap();
    match op {
      "addx" => {
        let arg = parts.next().unwrap().parse::<i32>().unwrap();
        Instruction::Addx(arg)
      },
      "noop" => Instruction::Noop,
      _ => panic!("unknown op: {}", op),
    }
  }
}

pub fn one() {
  let input = include_str!("input1.txt");
  let mut cpu = Cpu::new();

  for line in input.lines() {
    let inst = Instruction::parse(line);
    // println!("{:?}", inst);
    cpu.run(inst);
    // println!("{:?}", cpu);
  }

  println!("Day 10, part 1: {}", cpu.result);
}

pub fn two() {
  let input = include_str!("input1.txt");
  let mut cpu = Cpu::new();

  for line in input.lines() {
    let inst = Instruction::parse(line);
    cpu.run(inst);
  }

  println!("Day 10, part 2:");
  for row in 0..6 {
    for col in 0..40 {
      let pos = row * 40 + col;
      if cpu.crt[pos] == 1 {
        print!("#");
      } else {
        print!(".");
      }
    }
    println!();
  }

}