Day 5: Supply Stacks

#!/usr/bin/env pypy3

from collections import defaultdict
import re
import string
import sys

def build_stacks(lines):
    stacks = defaultdict(list)
    for line in lines.split('\n')[:-1]:
        for col, char in enumerate(line):
            if char in string.ascii_uppercase:
                stacks[(col - 1) // 4].insert(0, char)

    return stacks

def move_crates(moves, stacks):
    for move in moves.split('\n')[:-1]:
        m = re.match(r'^move ([0-9]+) from ([0-9]+) to ([0-9]+)$', move.strip())
        amount, stack_from, stack_to = map(int, m.groups())
        for _ in range(amount):
            crate = stacks[stack_from - 1].pop()
            stacks[stack_to - 1].append(crate)

def main():
    stack_lines, move_lines = sys.stdin.read().split('\n\n')
    stacks = build_stacks(stack_lines)
    move_crates(move_lines, stacks)
    msg = ''.join(stacks[i][-1] for i in sorted(stacks.keys()))
    print(msg)

if __name__ == '__main__':
    main()

#!/usr/bin/env pypy3

from collections import defaultdict
import re
import string
import sys

def build_stacks(lines):
    stacks = defaultdict(list)
    for line in lines.split('\n')[:-1]:
        for col, char in enumerate(line):
            if char in string.ascii_uppercase:
                stacks[(col - 1) // 4].insert(0, char)

    return stacks

def move_crates(moves, stacks):
    for move in moves.split('\n')[:-1]:
        m = re.match(r'^move ([0-9]+) from ([0-9]+) to ([0-9]+)$', move.strip())
        amount, stack_from, stack_to = map(int, m.groups())
        crates = [stacks[stack_from - 1].pop() for _ in range(amount)][::-1]
        stacks[stack_to - 1] += crates

def main():
    stack_lines, move_lines = sys.stdin.read().split('\n\n')
    stacks = build_stacks(stack_lines)
    move_crates(move_lines, stacks)
    msg = ''.join(stacks[i][-1] for i in sorted(stacks.keys()))
    print(msg)

if __name__ == '__main__':
    main()

Parsing is relatively easy with the wonderful in-slice and a few helper procedures, groups and lines from day 1 and integers (converting the result of regex \d+ to numbers).

BUT... I lost so much time because I kept testing my parser with a pre-formatted, hard-coded list, rather than the 2 strings that groups returns. smh

To see how dumb I am, can anyone spot the difference between

[Z] [M] [P]\n 1   2   3
move 1 from 2 to 1\nmove 3 from 1 to 3

and

[Z] [M] [P]
 1   2   3

move 1 from 2 to 1
move 3 from 1 to 3

good for you, because apparently I can't.

My take-away from this is simply not to bother testing your code before you run it.

(define (part-01 input)
  (define stacks (arrange-crates input reverse))
  (list->string (map first (hash-values stacks))))

(define (arrange-crates input crane)
  (define-values (procedure crates) (parse-stacks (groups input)))
  (for/fold ([crates crates])
            ([is (in-list procedure)])
    (match-define (list amount from to) is)
    (move-with crates amount from to crane)))

(define (move-with crates amount from to move)
  (define-values (lifted left) (split-at (hash-ref crates from) amount))
  (define target (hash-ref crates to))
  (hash-set (hash-set crates from left)
            to
            (append (move lifted) target)))

(define ((adjoin x) xs) (append xs (list x)))
(define (parse-stacks input)
  (match-define (list stacks procedure) input)
  (define instructions (map integers (lines procedure)))
  (define arrangement
    (for*/fold ([crates (hash)])
               ([row (in-list (lines stacks))]
                [(crate i) (in-indexed (in-slice 4 row))])
      (if (eq? (first crate) #\[)
          (hash-update crates (add1 i) (adjoin (second crate)) null)
          crates)))
  (values instructions arrangement))

Initially of course there was no arrange-crates or move-with - it was all hard-coded into part 1 and copy-pasted into part 2, but I feel icky with so much duplication, so I extracted them to post here.

Part 2 was so easy, just replace the reverse for identity (which in Racket is values)

(define (part-02 input)
  (define stacks (arrange-crates input values))
  (list->string (map first (hash-values stacks))))

Before each part took ~2.1 ms (after reading the file into a string) because each part built up the same data structure, total time ~4.3ms

Attempt 1: ~80% elapsed time
Removing the duplicated work building data structures, and re-use them for both parts.

Attempt 2: ~30% elapsed time

As always, one trick is to build your data structure/s as you read the file, instead of slurping the whole thing in and then running over it several times parsing values.

Two parsing phases, the drawing and the instructions.
These are pretty much the same with two significant changes.
Use a hasheq instead of hash and push each new crate to the front of the stack and reverse all stacks as a final step.

Racket's hasheq is faster than a regular hash because it uses eq? to test keys. For objects eq? is identity (aka memory location), so super fast. Luckily integers are eq? if their values are =, so hasheq speeds up all hash operations.

Instead of adjoin appending to the current stack, push the crate onto the existing stack. This means the parsed stacks are reversed so there's a final step to reverse them.

Change part-01 and part-02 to accept the parsed stacks and instructions.
The rest is the same as before.

(define (part-01 procedure stacks)
  (define crates (arrange-crates procedure stacks reverse))
  (list->string (map first (hash-values crates))))
  
(define (part-02 procedure stacks)
  (define crates (arrange-crates procedure stacks values))
  (list->string (map first (hash-values crates))))

(define (arrange-crates procedure crates crane)
  (for/fold ([crates crates])
            ([is (in-list procedure)])
    (match-define (list amount from to) is)
    (move-with crates amount from to crane)))

(define (move-with crates amount from to move)
  (define-values (lifted left) (split-at (hash-ref crates from) amount))
  (define target (hash-ref crates to))
  (hash-set (hash-set crates from left)
            to
            (append (move lifted) target)))
  
(define ((adjoin x) xs) (cons x xs))

(define (place-crates stacks line)
  (for/fold ([stacks stacks])
            ([c (in-string line)]
             [i (in-naturals 1)]
             #:when (char-upper-case? c))
    (hash-update stacks (ceiling (/ i 4)) (adjoin c) null)))

(define-values (crates procedure)
   (with-input-from-file "day05.input"
     (thunk
      (let ([crates
             (for/fold ([stacks (hasheq)]
                        #:result (for/hasheq ([(k v) (in-hash stacks)]) (values k (reverse v))))
                       ([line (in-lines)]
                        #:break (string=? line ""))
               (place-crates stacks line))]
            [procedure (for/list ([line (in-lines)])
                         (integers line))])
        (values crates procedure)))))
(part-01 procedure crates)
(part-02 procedure crates)

(*ls_top, ls_top_last), ls_btm = ls > p | (split_at, X, ~(X == ""))
stacks = (ls_top
          > fe(X.ljust(len(ls_top_last) + 1))
          | fe(p | (chunked, X, 4) | fe("".join))
          | as_args(zip)
          | fe(fe(X[1])
               | where(X != " ")
               | always_reversible | list)
          | tuple)
for n, i, f in (ls_btm
                > fe((re.search, r"move (\d+) from (\d+) to (\d+)")
                     | X.groups() | fe(int))):
     for _ in range(n):
          stacks[f - 1].append(stacks[i - 1].pop())
stacks > fe(X[-1]) | "".join

from more_itertools import always_reversible
from more_itertools import chunked
from more_itertools import split_at
from pipetools import X
from pipetools import as_args
from pipetools import foreach
from pipetools import pipe
from pipetools import where
import re
import sys
from pyp import pypprint
p = pipe
fe = foreach
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
((*ls_top, ls_top_last), ls_btm) = ls > p | (split_at, X, ~(X == ''))
stacks = ls_top > fe(X.ljust(len(ls_top_last) + 1)) | fe(p | (chunked, X, 4) | fe(''.join)) | as_args(zip) | fe(fe(X[1]) | where(X != ' ') | always_reversible | list) | tuple
for (n, i, f) in ls_btm > fe((re.search, 'move (\\d+) from (\\d+) to (\\d+)') | X.groups() | fe(int)):
    for _ in range(n):
        stacks[f - 1].append(stacks[i - 1].pop())
output = stacks > fe(X[-1]) | ''.join
if output is not None:
    pypprint(output)

(*ls_top, ls_top_last), ls_btm = ls > p | (split_at, X, ~(X == ""))
stacks = (ls_top
          > fe(X.ljust(len(ls_top_last) + 1))
          | fe(p | (chunked, X, 4) | fe("".join))
          | as_args(zip)
          | fe(fe(X[1])
               | where(X != " ")
               | always_reversible | list)
          | list)
for n, i, f in (ls_btm
                > fe((re.search, r"move (\d+) from (\d+) to (\d+)")
                     | X.groups() | fe(int))):
     stacks[f - 1] += stacks[i - 1][-n:]
     stacks[i - 1] = stacks[i - 1][:-n]
stacks > fe(X[-1]) | "".join

from more_itertools import always_reversible
from more_itertools import chunked
from more_itertools import split_at
from pipetools import X
from pipetools import as_args
from pipetools import foreach
from pipetools import pipe
from pipetools import where
import re
import sys
from pyp import pypprint
p = pipe
fe = foreach
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
((*ls_top, ls_top_last), ls_btm) = ls > p | (split_at, X, ~(X == ''))
stacks = ls_top > fe(X.ljust(len(ls_top_last) + 1)) | fe(p | (chunked, X, 4) | fe(''.join)) | as_args(zip) | fe(fe(X[1]) | where(X != ' ') | always_reversible | list) | list
for (n, i, f) in ls_btm > fe((re.search, 'move (\\d+) from (\\d+) to (\\d+)') | X.groups() | fe(int)):
    stacks[f - 1] += stacks[i - 1][-n:]
    stacks[i - 1] = stacks[i - 1][:-n]
output = stacks > fe(X[-1]) | ''.join
if output is not None:
    pypprint(output)

(ls > p
 | (split_at, X, ~(X == ""))
 | as_args(λ t, b: (t > p
                    | always_reversible | (λ ls: (λ top_width: ls > fe(X.ljust(top_width)))
                                                 (len(first(ls)) + 1))
                    | fe(p | (chunked, X, 4) | fe("".join))
                    | as_args(zip)
                    | fe(fe(X[1])
                         | where(X != " ")
                         | list)
                    | list,
                    b
                    > fe((re.search, r"move (\d+) from (\d+) to (\d+)")
                         | X.groups() | fe(int))))
 | as_args(λ sl, ii: (ii
                      > fe(as_args(λ n, i, f: range(n)
                                              > fe_do(λ _: sl[f - 1].append(sl[i - 1].pop())))) | tuple,
                      sl > fe(X[-1]) | "".join
                     )[1]))

from more_itertools import always_reversible
from more_itertools import chunked
from more_itertools import first
from more_itertools import split_at
from pipetools import X
from pipetools import as_args
from pipetools import foreach
from pipetools import foreach_do
from pipetools import pipe
from pipetools import where
import re
import sys
from pyp import pypprint
p = pipe
fe = foreach
fe_do = foreach_do
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
output = ls > p | (split_at, X, ~(X == '')) | as_args(lambda t, b: (t > p | always_reversible | (lambda ls: (lambda top_width: ls > fe(X.ljust(top_width)))(len(first(ls)) + 1)) | fe(p | (chunked, X, 4) | fe(''.join)) | as_args(zip) | fe(fe(X[1]) | where(X != ' ') | list) | list, b > fe((re.search, 'move (\\d+) from (\\d+) to (\\d+)') | X.groups() | fe(int)))) | as_args(lambda sl, ii: (ii > fe(as_args(lambda n, i, f: range(n) > fe_do(lambda _: sl[f - 1].append(sl[i - 1].pop())))) | tuple, sl > fe(X[-1]) | ''.join)[1])
if output is not None:
    pypprint(output)

(ls > p
 | (split_at, X, ~(X == ""))
 | as_args(λ t, b: (t > p
                    | always_reversible | (λ ls: (λ top_width: ls > fe(X.ljust(top_width)))
                                                 (len(first(ls)) + 1))
                    | fe(p | (chunked, X, 4) | fe("".join))
                    | as_args(zip)
                    | fe(fe(X[1])
                         | where(X != " ")
                         | list)
                    | list,
                    b
                    > fe((re.search, r"move (\d+) from (\d+) to (\d+)")
                         | X.groups() | fe(int))))
 | as_args(λ sl, ii: (ii
                      > fe(as_args(λ n, i, f: range(n)
                                              > fe_do(λ j: sl[f - 1].append(sl[i - 1].pop(-n + j))))) | tuple,
                      sl > fe(X[-1]) | "".join
                     )[1]))

from more_itertools import always_reversible
from more_itertools import chunked
from more_itertools import first
from more_itertools import split_at
from pipetools import X
from pipetools import as_args
from pipetools import foreach
from pipetools import foreach_do
from pipetools import pipe
from pipetools import where
import re
import sys
from pyp import pypprint
p = pipe
fe = foreach
fe_do = foreach_do
lines = [x.rstrip('\n') for x in sys.stdin]
ls = lines
output = ls > p | (split_at, X, ~(X == '')) | as_args(lambda t, b: (t > p | always_reversible | (lambda ls: (lambda top_width: ls > fe(X.ljust(top_width)))(len(first(ls)) + 1)) | fe(p | (chunked, X, 4) | fe(''.join)) | as_args(zip) | fe(fe(X[1]) | where(X != ' ') | list) | list, b > fe((re.search, 'move (\\d+) from (\\d+) to (\\d+)') | X.groups() | fe(int)))) | as_args(lambda sl, ii: (ii > fe(as_args(lambda n, i, f: range(n) > fe_do(lambda j: sl[f - 1].append(sl[i - 1].pop(-n + j))))) | tuple, sl > fe(X[-1]) | ''.join)[1])
if output is not None:
    pypprint(output)

from curses.ascii import isdigit
import collections, copy, re

file = [block.split("\n") for block in open("input.txt").read().split("\n\n")]
procedures = [list(map(int, re.findall("\d+", line))) for line in file[1]]
crates = collections.defaultdict(list)

for line in file[0][-2::-1]:
    for i, mark in enumerate(file[0][-1]):
        if isdigit(mark) and i < len(line) and line[i] != " ":
            crates[int(mark)].append(line[i])


def crateMover(version: int = 9000) -> str:
    cell = copy.deepcopy(crates)
    for move, a, b in procedures:
        moved = [cell[a].pop() for _ in range(move)]
        cell[b].extend(moved if version == 9000 else moved[::-1])

    return "".join([cell[i][-1] for i in cell])


print(crateMover())  # Part One: QNHWJVJZW
print(crateMover(9001))  # Part Two: BPCZJLFJW

for line in file[0][-2::-1]:
    for i, mark in [(i, int(mark)) for i, mark in enumerate(file[0][-1]) if isdigit(mark)]:
        if i >= len(line):
            break
        elif line[i] != " ":
            crates[mark].append(line[i])

To

for line in file[0][-2::-1]:
    for i, mark in enumerate(file[0][-1]):
        if isdigit(mark) and i < len(line) and line[i] != " ":
            crates[int(mark)].append(line[i])

Yeah, the parsing took more time than both solutions…

import { assertEquals } from "https://deno.land/std@0.167.0/testing/asserts.ts";
import { runPart } from "https://deno.land/x/aocd@v1.2.1/mod.ts";

// the first item in the list is the item at the bottom of the stack
type Stack = string[];

interface Challenge {
  startingStacks: Stack[];
  procedures: Procedure[];
}

interface Procedure {
  amount: number;
  source: number;
  destination: number;
}

function parse(input: string): Challenge {
  const challenge: Challenge = {
    startingStacks: [],
    procedures: [],
  };
  type Section = "startingStacks" | "procedures";
  let section: Section = "startingStacks";
  for (const line of input.trimEnd().split("\n")) {
    switch (section) {
      case "startingStacks": {
        if (line.startsWith(" 1")) {
          section = "procedures";
          // stacks were inserted backwards, so flip them now
          for (const stack of challenge.startingStacks) {
            stack.reverse();
          }
        } else {
          // split line into list of strings every 4 characters
          const chunks = line.match(/.{1,4}/g) ?? [];
          // `chunks` looks like ["    ", "[D]"] now
          chunks.forEach((chunk, index) => {
            if (chunk[0] === "[") {
              const letter = chunk[1];
              // put the letter into the correct list inside of the challenge object.
              // we're assembling the stack backwards, so we'll reverse it later.

              if (!challenge.startingStacks[index]) {
                challenge.startingStacks[index] = [];
              }
              challenge.startingStacks[index].push(letter);
            }
          });
        }
        break;
      }
      case "procedures": {
        if (line.length > 0) {
          const match = /^move (\d+) from (\d+) to (\d+)$/.exec(line);
          if (!match) {
            throw new Error("line did not match expected format");
          }
          const procedure: Procedure = {
            amount: Number(match[1]),
            source: Number(match[2]),
            destination: Number(match[3]),
          };
          challenge.procedures.push(procedure);
        }
        break;
      }
    }
  }
  return challenge;
}

function part1(input: string): string {
  const challenge = parse(input);
  const stacks: Stack[] = structuredClone(challenge.startingStacks);
  for (const procedure of challenge.procedures) {
    // execute procedure, moving 1 item at a time
    for (let i = 0; i < procedure.amount; i++) {
      const item = stacks[procedure.source - 1].pop();
      if (!item) {
        throw new Error("stack was empty");
      }
      stacks[procedure.destination - 1].push(item);
    }
  }
  // return a string made up of the letters at the end of each stack
  return stacks.map((stack) => stack[stack.length - 1]).join("");
}

function part2(input: string): string {
  const challenge = parse(input);
  const stacks: Stack[] = structuredClone(challenge.startingStacks);
  for (const procedure of challenge.procedures) {
    // execute procedure, moving `procedure.amount` items at a time
    const items = stacks[procedure.source - 1].splice(
      stacks[procedure.source - 1].length - procedure.amount,
      procedure.amount,
    );
    stacks[procedure.destination - 1].push(...items);
  }
  // return a string made up of the letters at the end of each stack
  return stacks.map((stack) => stack[stack.length - 1]).join("");
}

if (import.meta.main) {
  runPart(2022, 5, 1, part1);
  runPart(2022, 5, 2, part2);
}

const TEST_INPUT = `\
    [D]
[N] [C]
[Z] [M] [P]
 1   2   3

move 1 from 2 to 1
move 3 from 1 to 3
move 2 from 2 to 1
move 1 from 1 to 2
`;

Deno.test("part1", () => {
  assertEquals(part1(TEST_INPUT), "CMZ");
});

Deno.test("part2", () => {
  assertEquals(part2(TEST_INPUT), "MCD");
});

#!/usr/bin/awk -f
/[][]/ { input[NR] = $0 }

/^ 1/ {
	for (i = 2; i < length($0); i += 4) {
		j = substr($0, i, 1)
		for (k = NR; k > 0; --k) {
			c = substr(input[k], i, 1)
			if (c != " ") {
				stack[j, ++stack[j]] = c
			}
		}
	}
}

/move/ {
	for (i = 1; i <= $2; ++i) {
		stack[$6, ++stack[$6]] = stack[$4, stack[$4]--]
	}
}

END {
	for (i = 1; i <= j; ++i) {
		printf("%s", stack[i, stack[i]])
	}

	print ""
}

#!/usr/bin/awk -f
/[][]/ { input[NR] = $0 }

/^ 1/ {
	for (i = 2; i < length($0); i += 4) {
		j = substr($0, i, 1)
		for (k = NR; k > 0; --k) {
			c = substr(input[k], i, 1)
			if (c != " ") {
				stack[j, ++stack[j]] = c
			}
		}
	}
}

/move/ {
	for (i = $2-1; i >= 0; --i) {
		stack[$6, ++stack[$6]] = stack[$4, stack[$4]-i]
	}

	stack[$4] -= $2
}

END {
	for (i = 1; i <= j; ++i) {
		printf("%s", stack[i, stack[i]])
	}

	print ""
}

(struct move (amount src dst) #:transparent)

(define (parse-stacks stack-lines)
  (define stacks# (length (string-split (last stack-lines))))
  (define stacks (make-vector stacks# '()))
  (for ([stack-line (rest (reverse stack-lines))])
    (define matches (regexp-match* #rx"(...) ?" stack-line))
    (for ([m matches]
          [i (in-range stacks#)])
      (when (not (char=? (string-ref m 1) #\ )) ; only add something if the slot is not empty
        (vector-set! stacks i (cons (string-ref m 1) (vector-ref stacks i))))))
  stacks)

(define (parse-moves move-lines)
  (for/list ([line move-lines])
    (define matches (regexp-match #px"move (\\d+) from (\\d+) to (\\d+)" line))
    (move (string->number (second matches)) ; amount
          (sub1 (string->number (third matches))) ; src
          (sub1 (string->number (fourth matches)))))) ; dst

;; function to make input usable
(define (sanitize-input input)
  (define split (string-split input "\n\n"))
  (define stack-def-raw (string-split (first split) "\n"))
  (define proc-def-raw (string-split (second split) "\n"))

  (define stacks (parse-stacks stack-def-raw))
  (define moves (parse-moves proc-def-raw))

  (values stacks moves))

(define (proc-moves! stacks moves)
  (for ([m moves])
    (for ([i (in-range (move-amount m))])
      (move-container! stacks (move-src m) (move-dst m)))))

(define (move-container! stack src dst)
  (define container (first (vector-ref stack src)))
  (vector-set! stack src (rest (vector-ref stack src)))
  (vector-set! stack dst (cons container (vector-ref stack dst))))

;; take the small input from the text
(define raw-small-input (file->string "small-input_05"))
(define small-answer-1 "CMZ")

;; workhorse, part 1
(define (part-1 raw-input)
  (define-values (stacks moves) (sanitize-input raw-input))
  (proc-moves! stacks moves)
  (list->string (vector->list (vector-map first stacks))))

;; test that "workhorse, part 1" does as it should
(check-equal? (part-1 raw-small-input) small-answer-1)

(displayln (~a "part 1: " (part-1 raw-aoc-input)))

(define (move-multiple-containers! stacks move)
  (define containers (take (vector-ref stacks (move-src move)) (move-amount move)))
  (vector-set! stacks (move-src move) (drop (vector-ref stacks (move-src move)) (move-amount move)))
  (vector-set! stacks (move-dst move) (append containers (vector-ref stacks (move-dst move)))))

(define (proc-moves-2! stacks moves)
  (for ([m moves])
    (move-multiple-containers! stacks m)))

;; part 2
(define small-answer-2 "MCD")

(define (part-2 raw-input)
  (define-values (stacks moves) (sanitize-input raw-input))
  (proc-moves-2! stacks moves)
  (list->string (vector->list (vector-map first stacks))))


(check-equal? (part-2 raw-small-input) small-answer-2)
(displayln (~a "part 2: " (part-2 raw-aoc-input)))

type Crates = string[][];
type Move = [number, number, number];
type Moves = Move[];
interface InputData {
  crates: Crates;
  moves: Moves;
}

// Bit of a pattern change for me here, in earlier challenges I formatted the
// input once and used the result for both parts. This time, because I'm
// changing arrays in place, I'm calling formatInput() twice, so the second
// part doesn't begin with the end state of the first part.
// Kinda hacky but I was in a hurry.
function formatInput(input: string): InputData {
  const [rawCrates, rawMoves] = input.split('\n\n');
  const crateLines = rawCrates.split('\n').slice(0, -1);
  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  const crates = new Array((crateLines[0].length + 1) / 4 + 1) as Crates;
  for (const line of crateLines) {
    for (let stack = 1, i = 0; i < line.length; i += 4, stack++) {
      if (alphabet.includes(line[i + 1])) {
        if (!crates[stack]) {
          crates[stack] = [];
        }
        crates[stack].unshift(line[i + 1]);
      }
    }
  }

  const moves = rawMoves
    .split('\n')
    .filter(e => !!e)
    .map(e =>
      e
        .split(/[^0-9]/g)
        .filter(f => f !== '')
        .map(f => Number(f))
    ) as Moves;

  return {
    crates,
    moves,
  } as InputData;
}

export function run(input: string): string[] {

  const getTopCratesAfterSingleMoves = (rawInput: string): string => {
    const { crates, moves } = formatInput(rawInput);
    for (const move of moves) {
      for (let i = 0; i < move[0]; i++) {
        const crateToMove = crates[move[1]].pop();
        crates[move[2]].push(crateToMove);
      }
    }
    return crates.map(e => e[e.length - 1]).join('');
  };

  const getTopCratesAfterMultiMoves = (rawInput: string): string => {
    const { crates, moves } = formatInput(rawInput);
    for (const move of moves) {
      const cratesToMove = [] as string[];
      for (let i = 0; i < move[0]; i++) {
        cratesToMove.unshift(crates[move[1]].pop());
      }
      crates[move[2]].push(...cratesToMove);
    }
    return crates.map(e => e[e.length - 1]).join('');
  };

  return [`${getTopCratesAfterSingleMoves(input)}`, `${getTopCratesAfterMultiMoves(input)}`];
}

use std::env;
use std::io::{self};

extern crate regex;
use regex::Regex;

#[macro_use] extern crate lazy_static;
lazy_static! {
    static ref RE_MOVES: Regex = {
        Regex::new(r"move ([\d]+) from ([\d]+) to ([\d]+)").unwrap()
    };
}

#[derive(Debug)]
struct Move {
    qty: usize,
    from: usize,
    to: usize,
}
impl From<&str> for Move {
    fn from(s: &str) -> Self {
        let matches = RE_MOVES.captures(s).unwrap();
        Self {
            qty:  matches[1].parse().unwrap(),
            from: matches[2].parse().unwrap(),
            to:   matches[3].parse().unwrap(),
        }
    }
}

const MAX_NUM_STACKS: usize = 9;

fn move_last_n_chars(s1: &str, s2: &str, n: usize) -> (String, String) {
    let mut s1_chars: Vec<char> = s1.chars().collect();
    let     s2_chars: Vec<char> = s2.chars().collect();
    
    let mut moved_chars: String = s1_chars.iter().rev().take(n).collect();
    moved_chars = moved_chars.chars().rev().collect();

    for _ in 0..n { s1_chars.pop().unwrap(); }

    let s1_new = s1_chars.into_iter().collect();
    let mut s2_new: String = s2_chars.into_iter().collect();
    s2_new.push_str(&moved_chars);

    (s1_new, s2_new)
}

fn solve(input: &str) -> io::Result<()> {
    let input_str = std::fs::read_to_string(input).unwrap();
    let input_str = input_str.trim();
    let input: Vec<_> = input_str.split("\n\n").collect();

    // Initialize moves
    let moves: Vec<_> = input[1].split("\n").map(Move::from).collect();

    // Initialize stacks
    let mut stacks: [String; MAX_NUM_STACKS] = Default::default();
    for line in input[0].lines() {
        if line.chars().nth(1).unwrap() == '1' { continue } // Skip last line indexing the stacks
        for (ix,ch) in line.chars().enumerate() {
            match ix {
                1  => if ch != ' ' { stacks[0].push_str(&ch.to_string()) },
                5  => if ch != ' ' { stacks[1].push_str(&ch.to_string()) },
                9  => if ch != ' ' { stacks[2].push_str(&ch.to_string()) },
                13 => if ch != ' ' { stacks[3].push_str(&ch.to_string()) },
                17 => if ch != ' ' { stacks[4].push_str(&ch.to_string()) },
                21 => if ch != ' ' { stacks[5].push_str(&ch.to_string()) },
                25 => if ch != ' ' { stacks[6].push_str(&ch.to_string()) },
                29 => if ch != ' ' { stacks[7].push_str(&ch.to_string()) },
                33 => if ch != ' ' { stacks[8].push_str(&ch.to_string()) },
                _  => {},
            }
        }
    }

    // Reverse the stacks
    for ix in 0..MAX_NUM_STACKS {
        stacks[ix] = stacks[ix].chars().rev().collect::<String>();
    }
    
    // Copy original state for part 2
    let stacks_copy = stacks.clone();

    // Process part 1 moves
    for moved in &moves {
        let (qty,from,to) = (moved.qty,moved.from-1, moved.to-1);
        for _ in 0..qty {
            //(stacks[from],stacks[to]) = move_last_char(&stacks[from],&stacks[to]);
            (stacks[from],stacks[to]) = move_last_n_chars(&stacks[from],&stacks[to],1);
        }
    }

    // Part 1 Output
    print!("Part 1: "); // VGBBJCRMN
    for ix in 0..MAX_NUM_STACKS { print!("{}",stacks[ix].chars().last().unwrap()); }
    println!();

    // Process part 2 moves
    stacks = stacks_copy;
    for moved in &moves {
        let (qty,from,to) = (moved.qty,moved.from-1, moved.to-1);
        (stacks[from],stacks[to]) = move_last_n_chars(&stacks[from],&stacks[to],qty);
    }

    // Part 2 Output
    print!("Part 2: "); // LBBVJBRMH
    for ix in 0..MAX_NUM_STACKS { print!("{}",stacks[ix].chars().last().unwrap()); }
    println!();

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

def parse_input(
    lines: List[str],
) -> Tuple[List[deque[str]], List[Tuple[int, int, int]]]:

    line_num = 0 
    while lines[line_num] != "\n":
        line_num += 1

    num_stacks = int(lines[line_num - 1].split()[-1])
    crates: List[deque[str]] = [deque() for stack in range(num_stacks)]
    for layer in lines[line_num - 2 :: -1]:
        # doing this the lazy way because I think I'll get away with it
        for stack, location in enumerate(range(1, len(layer), 4)):
            if layer[location] == " ":
                continue

            crates[stack].append(layer[location])

    instructions = []
    for instruction in lines[line_num + 1 :]: 
        # Is there a better way to do this while still enforcing tuple length?
        breakdown = instruction.strip().split()
        amount: int = int(breakdown[1])
        src: int = int(breakdown[3]) - 1 
        dst: int = int(breakdown[5]) - 1 
        instructions.append((amount, src, dst))

    return (crates, instructions)


def apply_instruction(crates: List[deque[str]], instruction: Tuple[int, int, int]):
    for _ in range(instruction[0]):
        crates[instruction[2]].append(crates[instruction[1]].pop())


def apply_fancy_instruction(
    crates: List[deque[str]], instruction: Tuple[int, int, int]
):

    hand = []
    for _ in range(instruction[0]):
        hand.append(crates[instruction[1]].pop())

    for _ in range(instruction[0]):
        crates[instruction[2]].append(hand.pop())


def main(filepath: str) -> Tuple[str, str]:

    lines = load_file.load_lines(filepath)
    crates, instructions = parse_input(lines)
    crates_2 = deepcopy(crates)
    for instruction in instructions:
        apply_instruction(crates, instruction)
        apply_fancy_instruction(crates_2, instruction)

    return (
        "".join((crate[-1] for crate in crates)),
        "".join((crate[-1] for crate in crates_2)),
    )

import std/[deques, strutils]

proc day05*() =
  let f = open("inputs/day05.in")
  defer: f.close()

  var 
    line = f.readLine()
    stacksP1: seq[Deque[char]]
    crateIdx: int
    topWordP1: string
    topWordP2: string

  # Get all of the stacks
  while line != "":
    crateIdx = line.find('[', 0)
    while crateIdx != -1:
      # Make sure stacks is long enough
      while stacksP1.len <= int(crateIdx / 4):
        var deque: Deque[char]
        stacksP1.add(deque)
      stacksP1[int(crateIdx / 4)].addFirst(line[crateIdx + 1])
      crateIdx = line.find('[', crateIdx + 1)

    line = f.readLine()
  var stacksP2 = deepCopy(stacksP1)

  # Move the crates between stacks
  while (f.readLine(line)):
    let splitLine = line.splitWhitespace()
    let
      count = parseInt(splitLine[1])
      srcStack = parseInt(splitLine[3]) - 1 # My stacks are zero-indexed
      dstStack = parseInt(splitLine[5]) - 1 # but these aren't
    var tmpStack: Deque[char]

    for i in 0..<count:
      # CrateMover 9000
      stacksP1[dstStack].addLast(stacksP1[srcStack].popLast())
      # CrateMover 9001
      tmpStack.addFirst(stacksP2[srcStack].popLast())
    while tmpStack.len > 0:
      stacksP2[dstStack].addLast(tmpStack.popFirst)

  for stack in stacksP1:
    topWordP1.add(stack.peekLast())
  for stack in stacksP2:
    topWordP2.add(stack.peekLast())
  echo "Part 1: " & topWordP1
  echo "Part 2: " & topWordP2

defmodule AdventOfCode.Solution.Year2022.Day05 do
  def part1(input), do: solve(input, &Enum.reverse/1)
  def part2(input), do: solve(input, &Function.identity/1)

  def solve(input, crane_fn) do
    {stacks, instrs} = parse(input)

    instrs
    |> Enum.reduce(stacks, &move(&1, &2, crane_fn))
    |> Enum.sort_by(fn {stack_label, _stack} -> stack_label end)
    |> Enum.map(fn {_stack_label, [crate | _]} -> crate end)
    |> to_string()
  end

  defp move({source, dest, count}, stacks, crane_fn) do
    {to_move, to_remain} = Enum.split(stacks[source], count)

    stacks
    |> Map.put(source, to_remain)
    |> Map.update!(dest, &Enum.concat(crane_fn.(to_move), &1))
  end

  defp parse(input) do
    [stack_lines, instr_lines] = String.split(input, "\n\n")
    {parse_stacks(stack_lines), parse_instrs(instr_lines)}
  end

  # Assumes crate labels are always 1 char
  # Assumes stack labels are always 1 digit and listed in order: "1 2 ... 9"
  defp parse_stacks(stack_lines) do
    stack_lines
    |> String.split("\n", trim: true)
    # Faster to build lists tail-first
    |> Enum.reverse()
    # Skip last line with stack labels
    |> Enum.drop(1)
    |> Enum.map(&parse_stacks_row/1)
    |> Enum.reduce(fn stacks_row, stacks ->
      Map.merge(stacks, stacks_row, fn _stack_label, stack, [crate] -> [crate | stack] end)
    end)
  end

  defp parse_stacks_row(line) do
    line
    |> String.to_charlist()
    |> Enum.drop(1)
    |> Enum.take_every(4)
    |> Enum.with_index(fn crate, i -> {i + 1, [crate]} end)
    |> Enum.reject(&match?({_stack_label, ' '}, &1))
    |> Map.new()
  end

  defp parse_instrs(instr_lines) do
    instr_lines
    |> String.split("\n", trim: true)
    |> Enum.map(fn line ->
      ~r/^move (\d+) from (\d) to (\d)$/
      |> Regex.run(line, capture: :all_but_first)
      |> Enum.map(&String.to_integer/1)
      |> then(fn [count, from_label, to_label] -> {from_label, to_label, count} end)
    end)
  end
end

#!/usr/bin/env bash

file1=day5_1.dat
file2=day5_2.dat
part=1

# if [[ ${part} -eq 1 ]]; then
# /////////////////////////////////////////////////////////////////////////////
#part 1 0.114 VCTFTJQCG
#part 2 0.07s GCFGLDNJZ
mapfile -t stackedRows < $file1

# # shopt -s extglob #necessary for match below
# # stackedRows=("${stackedRows[@]//[[:blank:]]}")

#   -- reorder rows into columns
length=${#stackedRows[@]}
i=0
j=1
n=0
cols=()
declare -A "stacks" #make assosciative array
#   -- outer loop gets width of line
while [[ $i -le $length ]]; do 
    width=${#stackedRows[$i]}
#   -- next loop (j) holds our horiztonal position
    while [[ $j -lt $width ]]; do
        k=0
#       -- now, for this horizontal position, loop through vertically
        while [[ $k -lt $length ]]; do
            # echo line $(($k+1)) col $(($j+1)) #debug print
            # echo ${stackedRows[k]:j:1}
            cols+=("${stackedRows[k]:j:1}")
            (( k = k + 1))
        done
    ((j = j + 4))
    done
    noSpace="${cols[@]:n:$length}"
    stacks["stack${i}"]=${noSpace// /}
    # echo "${stacks["stack${i}"]}"
    ((n = n + $length))
    ((i = i + 1))
done

#   --access to stacks 
# col=stack1
# echo "${stacks[$col]}"
# echo "${stacks[stack1]}"
# or
# echo "${stacks["stack1"]}"


while read -ra line || [ -n "$line" ]; do
    m=0
    move=${line[1]}
    from=${line[3]}
    to=${line[5]}

#   -- zero offset
    ((move = move -1 ))
    ((from = from -1 ))
    ((to = to -1))

    # echo move $move from $from to $to
    while [[ m -le $move ]]; do
#       -- get column we're taking from
        colA="stack${from}"
        fromCol=("${stacks[$colA]}")
#       -- get column we're adding to
        colB="stack${to}"
        toCol=("${stacks[$colB]}")
#       -- get the single container we're moving, unless it's 3 at a time...
        if [[ $move -gt 0 && ${part} -eq 2 ]]; then
            ((numCrates=move + 1))
        else
            numCrates=1
        fi
        movingContainer=${fromCol:0:$numCrates}

# # #       -- debug print
        #   echo moving $movingContainer to $toCol

#       -- move to the new column
        toCol="${movingContainer}${toCol}"
#       -- removing from old one
        z=${#fromCol}
        fromCol=${fromCol:$numCrates:z}

# # #       -- debug print
        # echo after moving we have: $fromCol and $toCol

#       -- update assosciate array 'stacks'
        stacks["$colA"]=${fromCol}
        stacks["$colB"]=${toCol}
# #       -- debug print
        # echo just checking, we have: ${stacks[$colA]} and ${stacks[$colB]}

        ((m = m + 1 ))

        if [[ $numCrates -gt 1 ]]; then
            m=$(($move+1))
        fi

    done
        # echo next move

done < $file2
echo Final crates: ${stacks[stack0]:0:1}${stacks[stack1]:0:1}${stacks[stack2]:0:1}${stacks[stack3]:0:1}${stacks[stack4]:0:1}${stacks[stack5]:0:1}${stacks[stack6]:0:1}${stacks[stack7]:0:1}${stacks[stack8]:0:1}
# /////////////////////////////////////////////////////////////////////////////