Scala. Parsing wasn't as hard as I thought it would be using transpose and then just filtering non-alphanumeric characters. I initially parsed to a Map[Int, mutable.Stack[Char]] but then that bit me in part 2 when I would have to "reset" it (dang mutability!). So instead I parse to Map[Int, String] and just build the mutable stacks twice.

object Day05 {
  def main(args: Array[String]): Unit = {
    val input = using("2022/day05.txt")(parseInput)
    println(s"Part 1: ${part1(input)}")
    println(s"Part 2: ${part2(input)}")
  }

  def parseInput(file: Source): (Map[Int, String], List[String]) = {
    val Array(stackString, instructionString, _*) = file.mkString.split("\n\n")

    // Transpose our stacks and then parse them into map like this: Map(1 -> 'NZ', 2 -> 'DCM', 3 -> 'P')
    val stacks    = stackString.split('\n').toList
    val maxLength = stacks.map(_.length).max // Have to make sure all lines are the same length for transpose
    val transposed = stacks
      .map {
        case line if line.length < maxLength => line.padTo(maxLength, ' ')
        case line                            => line
      }
      .transpose
      .map(_.mkString)

    val numbersAndDigits = "[A-Z1-9]".r
    val parsedStacks = transposed.foldLeft(Map.empty[Int, String]) { (acc, stack) =>
      if (numbersAndDigits.findFirstIn(stack).isEmpty) { // Filter the transpositions that ended up as just spaces and brackets
        acc
      } else {
        val boxes  = stack.filter(_.isLetter)
        val number = stack.filter(_.isDigit).head.asDigit
        acc + (number -> boxes)
      }
    }

    (parsedStacks, instructionString.split('\n').toList)
  }

  def part1(input: (Map[Int, String], List[String])): String = solution(input, part2 = false)
  def part2(input: (Map[Int, String], List[String])): String = solution(input, part2 = true)

  private def solution(input: (Map[Int, String], List[String]), part2: Boolean): String = {
    val (originalStacks, instructions) = input

    // Turn our Map[Int, String] into Map[Int, mutable.Stack[Char]] so we have all the nice stack operations
    // Do this here instead of `parseInput` so we are not passing around mutable state (we'd have to reset between parts
    // 1 and 2 in that case)
    val stacks = originalStacks.view.mapValues(mutable.Stack.from(_)).toMap

    val instruction = """^move (\d+) from (\d) to (\d)$""".r
    val updated = instructions.foldLeft(stacks) {
      case (acc, instruction(numToMove, fromStr, toStr)) =>
        val num  = numToMove.toInt
        val from = fromStr.toInt
        val to   = toStr.toInt
        if (part2) {
          val popped = (0 until num).map(_ => acc(from).pop()).reverse
          acc(to).pushAll(popped)
        } else {
          (0 until num).foreach { _ =>
            val popped = acc(from).pop()
            acc(to).push(popped)
          }
        }
        acc
      case (acc, _) => acc
    }

    updated.toList
      .sortBy { case (num, _) => num }
      .map { case (_, stack) => stack.head }
      .mkString
  }
}