Day 6: Trash Compactor

def solve(input: str) -> int:
    return sum(calculations(input))


def calculations(input: str) -> Iterator[int]:
    operators = {"+": add, "*": mul}
    for operator, operands in operators_and_operands(input):
        yield reduce(operators[operator], operands)


def operators_and_operands(input: str) -> Iterator[tuple[str, Iterable[int]]]:
    for column in columns_of_rows(input):
        *operands, operator = column
        yield operator, map(int, operands)


def columns_of_rows(input: str) -> Iterator[Iterable[str]]:
    rows = input.strip().split("\n")
    rows_of_columns = map(str.split, rows)
    yield from zip(*rows_of_columns)

def solve(input: str) -> int:
    return sum(calculations(input))


def calculations(input: str) -> Iterator[int]:
    operators = {"+": add, "*": mul}
    for operator, operands in operators_and_operands(input):
        yield reduce(operators[operator], map(int, operands))


def operators_and_operands(input: str) -> Iterator[tuple[str, Iterable[str]]]:
    *operand_rows, operator_row = input.strip().split("\n")
    operand_cols = cephalpod_notation(operand_rows)
    return zip(operator_row.split(), operand_cols)


def cephalpod_notation(operand_rows: Iterable[str]) -> Iterator[Iterable[str]]:
    operands = map("".join, zip_longest(*operand_rows, fillvalue=""))
    operands = map(str.strip, operands)
    yield from split_at(operands, lambda operand: operand == "")

define add(sum: Integer, number: Integer): Integer {
    return sum + number
}

define multiply(product: Integer, number: Integer): Integer {
    return product * number
}

var lines = File.read_to_string("inputs/day_06.txt").split("\n")
var number_rows = lines.size() - 1

var numbers_horizontal: List[Integer] = List.repeat(number_rows, 0)
var factors_horizontal: List[Integer] = List.repeat(number_rows, 1)
var numbers_vertical: List[Integer] = []

var total_horizontal = 0
var total_vertical = 0

var skip_column = false
for column in lines[0].size() - 1...0 by -1: {
    if skip_column: {
        skip_column = false
        continue
    }

    var number_vertical = 0
    for i, number_horizontal in numbers_horizontal: {
        var char = lines[i][column]
        if char != ' ': {
            var digit = char - '0'
            numbers_horizontal[i] += digit * factors_horizontal[i]
            factors_horizontal[i] *= 10
            number_vertical = number_vertical * 10 + digit
        }
    }

    numbers_vertical.push(number_vertical)

    var char = lines[number_rows][column]
    if char == '+': {
        total_horizontal += numbers_horizontal.fold(0, add)
        total_vertical += numbers_vertical.fold(0, add)
    elif char == '*':
        total_horizontal += numbers_horizontal.fold(1, multiply)
        total_vertical += numbers_vertical.fold(1, multiply)
    else:
        continue
    }

    for i in 0...number_rows - 1: {
        numbers_horizontal[i] = 0
        factors_horizontal[i] = 1
    }

    numbers_vertical.clear()
    skip_column = true
}

print("Part 1: {}\nPart 2: {}".format(total_horizontal, total_vertical))

from functools import reduce
import operator

def gen_problems(s):
    lines = s.split("\n")
    grid = [list(line) for line in lines]
    operands = []
    buf = []
    for col in range(len(grid[0])):
        digits = "".join([grid[row][col] for row in range(len(grid)-1)])
        if digits.isspace():
            operands.append(buf)
            buf = []
        else:
            buf.append(int(digits))
    operands.append(buf)
    operations = lines[-1].split()
    return operands, operations

def compute_problems(operands, operations):
    total = 0
    for index, op in enumerate(operations):
        nums = operands[index]
        if op == "+":
            total += sum(nums)
        elif op == "*":
            total += reduce(operator.mul, nums)
    return total

input = open("./input.txt").read()[0:-2]
print(compute_problems(*gen_problems(input)))

  def parse() do
    parse(AocElixir.read_lines(6))
  end

  def parse_op(op) when op === "+", do: &Kernel.+/2
  def parse_op(op) when op === "*", do: &Kernel.*/2

  def parse_ops(raw_ops_row), do: raw_ops_row |> String.split() |> Enum.map(&parse_op/1)

  def parse(lines) do
    row_num = Enum.count(lines)
    {raw_num_rows, [raw_ops_row]} = Enum.split(lines, row_num - 1)
    {raw_num_rows, parse_ops(raw_ops_row)}
  end

  ### PART 1 ###

  def parse_str_num(str_num), do: str_num |> String.trim() |> String.to_integer()

  def combine(row1, row2, fns) do
    Enum.zip_with([row1, row2, fns], fn [a, b, op] -> op.(a, b) end)
  end

  def part1({raw_num_rows, ops}) do
    num_rows =
      Enum.map(
        raw_num_rows,
        fn row -> String.split(row) |> Enum.map(&parse_str_num/1) end
      )

    num_rows
    # associate each column with its operation
    |> Enum.reduce(&combine(&1, &2, ops))
    |> Enum.sum()
  end

  ### PART 2 ###

  def split_on_condition(enum, condition) do
    enum
    |> Enum.chunk_while(
      [],
      fn char, acc ->
        if condition.(char) do
          # emit a chunk with all previous values once condition is hit
          # reverse because cons would otherwise reverse the input
          {:cont, Enum.reverse(acc), []}
        else
          # accumulate non-matching values
          {:cont, [char | acc]}
        end
      end,
      # emit the remaining accumulator
      fn acc -> {:cont, Enum.reverse(acc), []} end
    )
  end

  def part2({raw_num_rows, ops}) do
    column_charlists =
      raw_num_rows
      |> Enum.map(&String.to_charlist/1)
      |> Enum.zip()
      |> Enum.map(&Tuple.to_list(&1))

    grouped_num_columns =
      column_charlists
      |> split_on_condition(&Enum.all?(&1, fn char -> char === ?\s end))
      |> Enum.map(
        &Enum.map(&1, fn col ->
          col
          |> to_string()
          |> String.trim()
          |> String.to_integer()
        end)
      )

    Enum.zip(ops, grouped_num_columns)
    |> Enum.map(fn {op, cols} -> Enum.reduce(cols, op) end)
    |> Enum.sum()
  end

Name               ips        average  deviation         median         99th %
parse          17.70 K       56.49 μs     ±8.84%       55.51 μs       72.43 μs
part one        1.44 K      696.27 μs    ±12.45%      668.96 μs     1012.20 μs
part two        0.62 K     1609.27 μs    ±11.51%     1605.36 μs     2125.26 μs

=SORT(
  SUM(
   BYCOL(
    SPLIT(A1:A5," "),
    LAMBDA(
     x,
     IF(OR(x="+"),
      SUM(x),
      PRODUCT(x))))))

import numpy
import math

def operate(params, operation):
  match operation:
    case '*':
      # numpy.prod() overflows
      return math.prod(params)
    case '+':
      return sum(params)

def part_one(lines):
  inputs = [[numpy.uint64(num) for num in l.split()] for l in lines[:-1]]
  operations = lines[-1].split()
  problems = numpy.rot90(inputs, k=3)
  return int(sum(operate(p, o) for p, o in zip(problems, operations)))
  

def part_two(lines):
  inputs = [list(l) for l in lines[:-1]]
  grid = numpy.rot90(inputs, k=1)
  numbers = [''.join(num).strip() for num in grid]
  problem = []
  problems = []
  for n in numbers:
    if (n == ''):
      problems.append(problem)
      problem = []
    else:
      problem.append(int(n))
  problems.append(problem)
  operations = lines[-1].split()[::-1]
  
  return int(sum(operate(p, o) for p, o in zip(problems, operations)))


with open('06.in') as file:
  lines = [line.rstrip('\n') for line in file]

print('Part 1:', part_one(lines))
print('Part 2:', part_two(lines))

:- ['src/util.pl'].
:- initialization(main).

main:-
    read_file_to_strings('inputs/day06.txt', Lines),

    parse_input_1(Lines, Vals, Ops),
    maplist(solve, Ops, Vals, Nums),
    sumlist(Nums, Result1),
    write("Part 1: "), write(Result1), nl,

    parse_input_2(Lines, Vals2, Ops2),
    maplist(solve, Ops2, Vals2, Nums2),
    sumlist(Nums2, Result2),
    write("Part 2: "), write(Result2), nl,

    halt.

solve("+", Vals, Result):- sum_list(Vals, Result).
solve("*", Vals, Result):- prod_list(Vals, Result).

parse_input_1(Lines, Vals, Ops):-
    maplist([S]>>split_string(S, " ", " "), Lines, SplitLines),
    last(SplitLines, Ops),
    append(ValStrings, [Ops], SplitLines),
    maplist(maplist(string_number), ValStrings, ValRows),
    transpose(ValRows, Vals).

parse_input_2(Lines, Vals, Ops):-
    last(Lines, OpsString),
    append(OrigValStrings, [OpsString], Lines),
    split_string(OpsString, " ", " ", Ops),
    maplist(string_chars, OrigValStrings, Chars),
    transpose(Chars, FlippedChars),
    maplist(exclude(=(' ')), FlippedChars, FilteredChars),
    maplist([C, S]>>string_chars(S, C), FilteredChars, FlippedStrings),
    split_list(FlippedStrings, "", ValStrings),
    maplist(maplist(string_number), ValStrings, Vals).

transpose([], []).
transpose([L], R):-
    maplist([X, V]>>(V = [X]), L, R).
transpose([H|T], R):-
    transpose(T, RecResult),
    maplist([X,Y,Z]>>(Z = [X|Y]), H, RecResult, R).

split_list(List, Delimiter, Result):-
    split_list(List, Delimiter, [], Result).
split_list([], _, Acc, [Acc]).
split_list([Delimiter], Delimiter, Acc, [Acc, []]).
split_list([Delimiter|T], Delimiter, Acc, Result):-
    split_list(T, Delimiter, [], Result1),
    Result = [Acc|Result1].
split_list([H|T], Delimiter, Acc, Result):-
    Acc1 = [H|Acc],
    split_list(T, Delimiter, Acc1, Result).

prod_list(List, Result):-
    foldl([A,B,C]>>(C is A * B), List, 1, Result).

use std::io;
use std::time::Instant;
use std::vec::Vec;

enum Op {
  Add,
  Mul,
}

impl Op {
  fn from_str(s: &str) -> Op {
    assert_eq!(s.len(), 1);
    match s {
      "+" => Op::Add,
      "*" => Op::Mul,
      _ => panic!("Bad op {}", s),
    }
  }

  fn neutral_element(&self) -> u64 {
    match self {
      Op::Add => 0,
      Op::Mul => 1,
    }
  }

  fn apply(&self, lhs: u64, rhs: u64) -> u64 {
    match self {
      Op::Add => lhs + rhs,
      Op::Mul => lhs * rhs,
    }
  }
}

struct Input {
  len: usize,
  numbers: Vec<Vec<u64>>,
  operators: Vec<Op>,

  raw_len: usize,
  raw_numbers: Vec<String>,
  raw_ops: String,
}

impl Input {
  fn read_from_stdin() -> Input {
    let raw_lines: Vec<String> = io::stdin().lines().map(|l| l.unwrap()).collect();
    assert!(raw_lines.len() > 0);
    let raw_len = raw_lines[0].len();
    for i in 1..raw_lines.len() {
      assert_eq!(raw_len, raw_lines[i].len());
    }
    let raw_numbers = raw_lines[..raw_lines.len() - 1].to_vec();
    let raw_ops = raw_lines.last().expect("").clone();

    let mut lines: Vec<Vec<String>> = raw_lines
      .into_iter()
      .map(|l| l.split_ascii_whitespace().map(|s| s.to_string()).collect())
      .collect();
    let len = lines[0].len();
    for i in 1..lines.len() {
      assert_eq!(len, lines[i].len());
    }
    let op_line = lines.pop().unwrap();
    Input {
      len,
      numbers: lines
        .into_iter()
        .map(|l| l.into_iter().map(|n| n.parse::<u64>().expect("")).collect())
        .collect(),
      operators: op_line
        .into_iter()
        .map(|op| Op::from_str(op.as_str()))
        .collect(),
      raw_len,
      raw_numbers,
      raw_ops,
    }
  }
}

fn part1(input: &Input) -> u64 {
  let mut ret = 0;
  for i in 0..input.len {
    let op = &input.operators[i];
    let mut tmp = op.neutral_element();
    for ns in &input.numbers {
      tmp = op.apply(tmp, ns[i]);
    }
    ret += tmp;
  }
  ret
}

fn part2(input: &Input) -> u64 {
  let mut ret = 0;
  let mut i = 0;
  while i < input.raw_len {
    let op = Op::from_str(str::from_utf8(&input.raw_ops.as_bytes()[i..i + 1]).expect(""));
    let mut number_end = input.raw_len;
    for j in i + 1..input.raw_len {
      if input.raw_ops.as_bytes()[j] != b' ' {
        number_end = j - 1;
        break;
      }
    }
    let mut tmp = op.neutral_element();
    for j in i..number_end {
      let mut n: u64 = 0;
      for l in &input.raw_numbers {
        let c = l.as_bytes()[j];
        if c != b' ' {
          n = n * 10 + (c - b'0') as u64;
        }
      }
      tmp = op.apply(tmp, n);
    }
    ret += tmp;
    i = number_end + 1;
  }
  ret
}

fn main() {
  let input = Input::read_from_stdin();
  timed_run("Part 1", || part1(&input));
  timed_run("Part 2", || part2(&input));
}

import { RunFunction } from '../../../types';

type Operation = '+' | '*';
interface MathProblem {
  operation: Operation;
  numbers: string[];
}
type InputData = MathProblem[];

function formatInput(input: string): InputData {
  const makeProblem = (operation: Operation) => ({
    operation,
    numbers: [],
  });

  const inputArr = input.split('\n');
  inputArr.length && inputArr[inputArr.length - 1] === '' && inputArr.pop();
  const problems: InputData = [];
  const lastRow = inputArr[inputArr.length - 1];
  let currentProblem = makeProblem(lastRow[0] as Operation);
  let currentSize = 0;
  for (let charIndex = 1; charIndex < lastRow.length; charIndex++) {
    const isLastChar = charIndex === lastRow.length - 1;
    if (lastRow[charIndex] === ' ') {
      currentSize++;
      if (!isLastChar) {
        continue;
      }
    }
    if (isLastChar) {
      currentSize++;
    }
    for (let row = 0; row < inputArr.length - 1; row++) {
      // offset accounts for 1-space padding between cols + next operator
      // (neither is present when processing last number in row, so fudge that one)
      const offset = isLastChar ? 2 : 0;
      currentProblem.numbers.push(
        inputArr[row].substring(charIndex - currentSize - 1 + offset, charIndex - 1 + offset)
      );
    }
    problems.push(currentProblem);
    if (!isLastChar) {
      currentProblem = makeProblem(lastRow[charIndex] as Operation);
      currentSize = 0;
    }
  }
  return problems;
}

export const run: RunFunction<InputData> = () => {
  const totalAnswersHuman = (problems: InputData): number => {
    let total = 0;
    for (const { operation, numbers } of problems) {
      total += eval(numbers.join(operation));
    }
    return total;
  };

  const totalAnswersCephalopod = (problems: InputData): number => {
    let total = 0;
    for (const { operation, numbers } of problems) {
      const cephalopodNumbers: string[] = [];
      for (let charIndex = numbers[0].length - 1; charIndex >= 0; charIndex--) {
        cephalopodNumbers.push(
          numbers
            .map(number => number[charIndex])
            .join('')
            .trim()
        );
      }
      total += eval(cephalopodNumbers.join(operation));
    }
    return total;
  };

  return [formatInput, totalAnswersHuman, totalAnswersCephalopod];
};