🌟 Advent of Code (AoC) 2022 🌟

goos: darwin
goarch: arm64
pkg: aoc2022
BenchmarkDay24_parsing-10    	   90315	     11377 ns/op	    9184 B/op	     294 allocs/op
BenchmarkDay24_part1-10      	      61	  19287990 ns/op	 8760548 B/op	  276388 allocs/op
BenchmarkDay24_part2-10      	      20	  55455177 ns/op	25256915 B/op	  796742 allocs/op

import re
import numpy as np
from collections import defaultdict
from math import prod

adm, res, cost, robots, br = 0, 1, 1, 2, 3 # adm, resources, cost, robots, built robot
ore, cly, obs, geo = 0, 1, 2, 3
bm, cbm, lbm, lcbm = 0, 1, 2, 3 # Built Mask, Can Build Mask, Last Build Mask, Last Can Build Mask

bp = []
for l in open("input19").readlines():
    _, or0, cl0, ob0, ob1, ge0, ge2 = tuple(map(int, re.findall(r'\d+', l)))
    bp.append(
        np.array(
            # Adm,          Cost                    Owned robots   Built Robot
            [[[1, 0, 0, 0], [-or0,    0,    0, 0],  [0, 0, 0, 0],  [1, 0, 0, 0]],
             [[2, 0, 0, 0], [-cl0,    0,    0, 0],  [0, 0, 0, 0],  [0, 1, 0, 0]],
             [[4, 0, 0, 0], [-ob0, -ob1,    0, 0],  [0, 0, 0, 0],  [0, 0, 1, 0]],
             [[8, 0, 0, 0], [-ge0,    0, -ge2, 0],  [0, 0, 0, 0],  [0, 0, 0, 1]],
             [[0, 0, 0, 0], [   0,    0,    0, 0],  [0, 0, 0, 0],  [0, 0, 0, 0]]],
            dtype=np.int_))

def tick(states, bp, limit):
    s = (states.reshape((-1, 16)) + bp.reshape((-1, 1, 16))).reshape(-1, 4, 4)
    
    # Did we have enough resources to build?
    s = s[s[:,res,:].min(axis = 1) >= 0,:]

    # No need to have more robots than the resource use each minute
    s = s[(s[:,robots,:geo] <= limit).all(axis = 1),:]
    
    # Can we build geode robot?
    s = s[((s[:, adm, cbm] & 8) != 0) == s[:, br, geo],:]

    # Should have built earlier?
    s = s[
        ~np.logical_and(
            np.logical_and(s[:, adm, bm] != 0, s[:, adm, lbm] == 0),
            (s[:, adm, bm] & s[:, adm, lcbm]) != 0),:]

    # Each robot collects one resource
    s[:, res, :] += s[:,robots,:]
    
    # Built any new robots?
    s[:, robots, :] += s[:, br,:]

    # Bookkeeping
    s[:, adm, lbm] = s[:, adm, bm]
    s[:, adm, lcbm] = s[:, adm, cbm]
    s[:, adm, bm] = 0
    s[:, adm, cbm] = (  (s[:, res, :] + bp[geo, cost, :] >= 0).all(axis = 1) << 3
                      | (s[:, res, :] + bp[obs, cost, :] >= 0).all(axis = 1) << 2
                      | (s[:, res, :] + bp[cly, cost, :] >= 0).all(axis = 1) << 1
                      | (s[:, res, :] + bp[ore, cost, :] >= 0).all(axis = 1))
    s[:, br: ,:] = 0

    return s

def bfs(bp, minutes):
    l = []
    for i,b in enumerate(bp):
        limit = -b[:, cost, :geo].min(axis=0)
        s = np.array([[0,0,0,0], [0,0,0,0], [1,0,0,0], [0,0,0,0]])
        for j in range(minutes):
            s = tick(s, b, limit)
        l.append((i + 1, s[:, res, geo].max()))
    return l

print(sum(map(prod, bfs(bp, 24))),
      prod(map(lambda x: x[1], bfs(bp[:3], 32))))

#include <iostream>
#include <fstream>
#include <vector>
#include <cstdint>

using namespace std;

struct List {
  int64_t val;
  List *prev;
  List *next;

  List(int64_t v, struct List *&last) : val(v), next(this), prev(this) {}

  void remove()
  {
    next->prev = prev;
    prev->next = next;
    next = prev = this;
  }

  void precede(List *elem)
  {
    prev = elem->prev;
    next = prev->next;
    elem->prev = this;
    prev->next = this;
  }
};

List *forward(List *p, int n)
{
  for (auto i = 0; i < n; ++i)
    p = p->next;
  return p;
}

int64_t solve(int64_t scale, int times)
{
  ifstream file;
  file.open("input20");
  List *first = nullptr;
  List *last = nullptr;
  vector<List *> v;
  
  int64_t n;
  while (file >> n) {
    List *elem(new List(n * scale, last));
    v.push_back(elem);
    if (first) {
      elem->precede(first);
    }
    else {
      first = elem;
    }
  }
  
  int64_t count = v.size() - 1;
  
  for (int j = 0; j < times; ++j) {
    for (auto i : v ) {
      auto steps = i->val % count;
      if (steps > 0) {
	List *p = i;
	for (auto j = 0; j < steps; ++j) {
	  p = p->next;
	}
	i->remove();
	i->precede(p->next);
      }
    
      if (steps < 0) {
	List *p = i;
	for (auto j = 0; j > steps; --j) {
	  p = p->prev;
	}
	i->remove();
	i->precede(p);
      }
    }
  }
  
  auto p = first;
  while (p->val != 0) {
    p = p->next;
  }
  return forward(p, 1000)->val + forward(p, 2000)->val + forward(p, 3000)->val;
}

int main()
{
  cout << solve(1, 1) << ", " << solve(811589153, 10) << '\n';
  return 0;
}

import numpy as np
import re
from math import gcd

map_, moves = tuple(open("input22").read().split('\n\n'))
map_ = map_.split('\n')
sx, sy = max(len(l) for l in map_), len(map_)
grid = np.zeros((sy, sx), dtype = np.int_)
for y, l in enumerate(map_):
    grid[y, :len(l)] = [' .#'.find(c) for c in l]

def rotL(cube):
    return np.rot90(cube, axes=(0,2))

def rotR(cube):
    return np.rot90(cube, k = -1, axes=(0,2))

def rotU(cube):
    return np.rot90(cube, axes=(0,1))

def turnL(cube, pos = (0, 0, 0)):
    return np.rot90(cube, axes=(2,1)), (0, pos[2], cube.shape[1] - pos[1] - 1)

def turnR(cube, pos):
    return np.rot90(cube, axes=(1,2)), (0, cube.shape[2] - pos[2] - 1, pos[1])

def corners(cube):
    return cube[0,0,0], cube[0,-1,0], cube[0,0,-1], cube[0,-1,-1]

def find_start_face(cube, first):
    for _ in range(3):
        if set(corners(cube)) == set(first): return cube
        cube = rotL(cube)
        if set(corners(cube)) == set(first): return cube
        cube = rotU(cube)
    
def project_grid_onto_cube(grid):
    fs = gcd(sx, sy)
    first = None
    faces = dict()
    cube = np.zeros([fs + 2] * 3, dtype=np.int_)

    # Mark corners for navigation
    for ix,x in enumerate([0, fs + 1]):
        for iy,y in enumerate([0, fs + 1]):
            for iz,z in enumerate([0, fs + 1]):
                cube[x,y,z] = ix << 2 | iy << 1 | iz

    for iy, y in enumerate(range(0, sy, fs)):
        # Map face and rotate
        for ix, x in enumerate(range(0, sx, fs)):
            if grid[y:y+fs, x:x+fs].sum():
                cube[0, 1:-1, 1:-1] = grid[y:y+fs, x:x+fs]
                c = corners(cube)
                faces[frozenset(c)] = (c, (y, x))
                first = first if first else c
            cube = rotL(cube)
        # Rotate back and rotate down if non-zero face on the down side
        for ix, x in enumerate(range(sx - fs, -1, -fs)):
            cube = rotR(cube)
            if y + fs < sy and grid[y:y+fs, x:x+fs].sum() and grid[y+fs: y+2*fs, x:x+fs].sum():
                cube = rotU(cube)
    #
    cube = find_start_face(cube, first)
    while corners(cube) != faces[frozenset(first)][0]:
        cube, _ = turnL(cube)
        
    return [cube, faces]

def project_grid_onto_plane(grid):
    faces = dict()
    cube = np.zeros([1, grid.shape[0] + 2, grid.shape[1] + 2], dtype=np.int_)
    for iy,y in enumerate([0, grid.shape[0] + 1]):
        for iz,z in enumerate([0, grid.shape[1] + 1]):
            cube[0,y,z] = iy << 1 | iz
    cube[0, 1:-1, 1:-1] = grid
    c = corners(cube)
    faces[frozenset(c)] = (c, (0, 0))
    return [cube, faces]

def flip(cube, pos):
    return rotL(cube), tuple(pos - np.array((0,0,cube.shape[0] - 2)))

def skip(cube, pos):
    while cube[pos] == 0:
        pos = tuple((pos + np.array((0,0,1))) % cube.shape)
    return cube, pos

def next_move(moves):
    while moves:
        if m := re.match('\d+', moves):
            moves = moves[len(m[0]):]
            yield int(m[0])
        if moves:
            m, moves = moves[0], moves[1:]
            yield m
            
def next_pos(cube, pos, on_zero):
    pos = tuple(pos + np.array((0,0,1)))
    return (cube, pos) if cube[pos] else on_zero(cube, pos)

def do_moves(cube, faces, on_zero):
    cube, pos = skip(cube, (0,1,1))
    for n in next_move(moves):
        if n == 'L':
            cube, pos = turnL(cube, pos)
        elif n == 'R':
            cube, pos = turnR(cube, pos)
        else:
            for i in range(n):
                ncube, npos = next_pos(cube, pos, on_zero)
                if ncube[npos] == 2:
                    break
                cube, pos = ncube, npos

    (c, (y,x)) = faces[frozenset(corners(cube))]
    dir = 0
    while corners(cube) != c:
        cube, pos = turnL(cube, pos)
        dir += 1

    return (pos[1] + y)  * 1000 + (pos[2] + x) * 4 + dir

print([do_moves(*f1(grid), f2) for f1, f2 in [(project_grid_onto_plane, skip),
                                              (project_grid_onto_cube, flip)]])

import numpy as np

symbols = ".<>^v#"
g = np.array([[symbols.find(c)
               for c in l.strip()]
              for l in open("input24").readlines()], dtype = np.uint8)
b = np.array(([((g == i).astype(np.uint8) << i)[1:-1,1:-1]
               for i, _ in enumerate(symbols)]))[1:5]

def move_blizzards(g, b):
    for i, (k, a) in enumerate([(-1, 1), (1, 1), (-1, 0), (1, 0)]):
        b[i] = np.roll(b[i], k, axis = a)
    g[1:-1,1:-1] = b.sum(axis = 0)
    return g

steps = np.array([[0, 0], [-1,  0], [ 1,  0], [ 0, -1], [ 0,  1]])

def minute(t, g, b, pos, start):
    g = move_blizzards(g, b)
    return t + 1, g, {next
                      for p in pos
                      for s in steps
                      if ((p + s) < g.shape).all() and g[next := tuple(p + s)] == 0} | {start}
    
def traverse(t, g, b, start, goal):
    pos = {start}
    while goal not in pos:
        t, g, pos = minute(t, g, b, pos, start)
    return t, g

start, goal = (0,1), (len(g) - 1, len(g[0]) -2)
there, _ = traverse(0,     g, b, start, goal)
back, _  = traverse(there, g, b, goal, start)
again, _ = traverse(back,  g, b, start, goal)
print(there, again)