function part1(inputText) {
  const [firstArgs, secondArgs, thirdArgs, fourthArgs, operators] = inputText.trim().split('\n').map(line => line.trim().split(/\s+/));
  let totalSum = 0;
  for (let i = 0; i < firstArgs.length; i++) {
    if (operators[i] === '+') {
      totalSum += Number.parseInt(firstArgs[i], 10) + Number.parseInt(secondArgs[i], 10) + Number.parseInt(thirdArgs[i], 10) + Number.parseInt(fourthArgs[i], 10);
    } else if (operators[i] === '*') {
      totalSum += Number.parseInt(firstArgs[i], 10) * Number.parseInt(secondArgs[i], 10) * Number.parseInt(thirdArgs[i], 10) * Number.parseInt(fourthArgs[i], 10);
    }
  }
  return totalSum
}

{
  const start = performance.now();
  const result = part1(document.body.textContent);
  const end = performance.now();
  console.info({
    day: 6,
    part: 1,
    time: end - start,
    result
  })
}

function part2(inputText) {
  const lines = inputText.trimEnd().split('\n');
  const interBlockIndices = [];
  for (let i = 0; i < lines[0].length; i++) {
    let allEmpty = true;
    for (let j = 0; j < lines.length; j++) {
      if (lines[j][i] !== ' ') {
        allEmpty = false;
        break;
      }
    }
    if (allEmpty) {
      interBlockIndices.push(i);
    }
  }
  interBlockIndices.push(lines[0].length);

  let totalSum = 0;
  let blockStart = 0;
  for (const interBlockIndex of interBlockIndices) {
    // compute calculation of block [blockStart, interBlockIndex - 1]
    const operands = [];
    for (let i = interBlockIndex - 1; i >= blockStart; i--) {
      // parse operands
      let operand = 0;
      for (let j = 0; j < lines.length - 1; j++) {
        if (lines[j][i] !== ' ') {
          operand *= 10;
          operand += Number.parseInt(lines[j][i], 10);
        }
      }
      operands.push(operand)
    }
    if (lines.at(-1)[blockStart] === '+') {
      totalSum += operands.reduce((accu, next) => accu + next, 0);
    } else if (lines.at(-1)[blockStart] === '*') {
      totalSum += operands.reduce((accu, next) => accu * next, 1);
    }
    //  console.debug({ totalSum, operands, blockStart, interBlockIndex });
    blockStart = interBlockIndex + 1;
  }
  return totalSum;
}

{
  const example = `123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  
`;
  const start = performance.now();
  const result = part2(document.body.textContent);
  //   const result = part2(example);
  const end = performance.now();
  console.info({
    day: 6,
    part: 2,
    time: end - start,
    result
  })
}

class Day06 : AOCSolution {
    override val year = 2025
    override val day = 6

    override fun part1(inputFile: String): String {
        val worksheet = readResourceLines(inputFile)
        // Arrange the problem in a grid and transpose it, so that the operation is the last element of each row
        val problems = worksheet.map { line -> line.trim().split(spaceSplitRegex) }.toGrid().transposed()

        val grandTotal = problems.rows().sumOf { line ->
            // Map the all but the last element to a number
            val numbers = line.mapToLongArray(0, line.lastIndex - 1, String::toLong)
            // Extract the operation
            val operation = line.last()[0]

            // Call the correct reduction
            // The "else" branch is needed for the compiler
            when (operation) {
                ADD -> numbers.sum()
                MULTIPLY -> numbers.reduce { acc, value -> acc * value }
                else -> 0
            }
        }
        return grandTotal.toString()
    }

    override fun part2(inputFile: String): String {
        val worksheet = readResourceLines(inputFile)

        // In this part the problem is more complicated and dependent on the individual characters.
        val charGrid = worksheet.map(CharSequence::toList).toCharGrid().transposed()

        val numbers = mutableListOf<Long>()
        val sb = StringBuilder(charGrid.width)

        val problems = buildList {
            // Begin with an empty operation
            // Assume the operation will be set to a valid value
            var operation = SPACE
            for (y in 0 until charGrid.height) {
                // Extract each row (transposed column)
                sb.clear().append(charGrid[y])
                // Find the bounds of the number
                val numberOffset = sb.indexNotOf(SPACE)

                if (numberOffset != -1) {
                    // A number was found, parse it and add it to the list.
                    val endIndex = sb.indexOfAny(STOP_CHARACTERS, numberOffset + 1)
                    val number = java.lang.Long.parseLong(sb, numberOffset, endIndex, 10)
                    numbers.add(number)

                    // Check whether there is an operation in the last column.
                    // IF so, that's the next relevant operation
                    val lastColumn = sb[sb.lastIndex]
                    if (lastColumn != SPACE) {
                        operation = lastColumn
                    }
                } else {
                    // No number was found, that's the separator for two calculations.
                    // Finalize the collection and clear the numbers.
                    // `toLongArray` creates a neat copy of the Longs in the list.
                    add(Problem(operation, numbers.toLongArray()))
                    numbers.clear()
                }
            }
            // Add the last remaining problem to the list
            add(Problem(operation, numbers.toLongArray()))
        }

        // Reduce all problems to their solutions and sum them up.
        val grandTotal = problems.sumOf { problem ->
            when (problem.operation) {
                ADD -> problem.numbers.sum()
                MULTIPLY -> problem.numbers.reduce { acc, value -> acc * value }
                else -> 0
            }
        }

        return grandTotal.toString()
    }

    private companion object {
        private const val ADD = '+'
        private const val MULTIPLY = '*'
        private const val SPACE = ' '
        private val STOP_CHARACTERS = charArrayOf(SPACE, ADD, MULTIPLY)

        @JvmRecord
        @Suppress("ArrayInDataClass")
        private data class Problem(val operation: Char, val numbers: LongArray)
    }

$ 123 328  51 64 
$  45 64  387 23 
$   6 98  215 314
$ *   +   *   +  

# &fras "input-6.txt" ◌

Calc ← (
  ↘₂⊛⊂"+*"/◇⊂
  ≡◇⨬(/+|/×)
  /+
)

P₁ ← (
  ⊜(⊜□⊸≠@ )⊸≠@\n
  ⊃⊣↘₋₁
  ⊙(⍉≡₀◇⋕)
  Calc
)

P₂ ← (
  ⊜∘⊸≠@\n
  ⟜⧻
  ⊓⍉(˜↯@ )
  ⊜(⊙(□≡⋕)⍜⍉(⊃(⊢⊣)↘₋₁))¬⤚≡⌟≍
  Calc
)

1_2 [⊃P₁P₂]
≡(&p &pf $"Part _: ")

class Day06 : Puzzle {

    val numsPartOne = mutableListOf<MutableList<Long>>()
    val numsPartTwo = mutableListOf<List<Long>>()
    val ops = mutableListOf<(Long, Long) -> Long>()

    override fun readFile() {
        val input = readInputFromFile("src/main/resources/a2025/day06.txt")
        val lines = input.lines().filter { it.isNotBlank() }

        // parse part1 input
        for (line in lines.dropLast(1)) {
            for ((c, num) in line.trim().split(" +".toRegex()).withIndex()) {
                if (numsPartOne.getOrNull(c) == null) numsPartOne.add(mutableListOf())
                numsPartOne[c].add(num.toLong())
            }
        }

        // parse part2 input
        var numList = mutableListOf<Long>()
        for (c in 0..<lines.maxOf { it.length }) {
            var numStr = ""
            for (r in 0..<lines.size - 1) {
                numStr += lines[r].getOrElse(c) { ' ' }
            }
            if (numStr.isBlank()) {
                numsPartTwo.add(numList)
                numList = mutableListOf()
            } else {
                numList.add(numStr.trim().toLong())
            }
        }
        numsPartTwo.add(numList)

        // parse operators
        ops.addAll(
            lines.last().split(" +".toRegex())
                .map { it.trim()[0] }
                .map {
                    when (it) {
                        '*' -> { a: Long, b: Long -> a * b }
                        '+' -> { a: Long, b: Long -> a + b }
                        else -> throw IllegalArgumentException("Unknown operator: $it")
                    }
                }
        )
    }

    override fun solvePartOne(): String {
        return numsPartOne.mapIndexed { c, list -> list.reduce { a, b -> ops[c](a, b) } }.sum().toString()
    }

    override fun solvePartTwo(): String {
        return numsPartTwo.mapIndexed { c, list -> list.reduce { a, b -> ops[c](a, b) } }.sum().toString()
    }
}

func part2() {
	// file, _ := os.Open("sample.txt")
	file, _ := os.Open("input.txt")
	defer file.Close()
	scanner := bufio.NewScanner(file)

	chars := [][]rune{}
	for scanner.Scan() {
		chars = append(chars, []rune(scanner.Text()))
	}

	m := len(chars)
	n := len(chars[0])
	var op rune
	nums := []int{}
	total := 0

	for j := range n {
		current := []rune{}
		for i := range m {
			if chars[i][j] == '+' || chars[i][j] == '*' {
				op = chars[i][j]
			} else if chars[i][j] != ' ' {
				current = append(current, chars[i][j])
			}
		}
		if len(current) > 0 {
			x, _ := strconv.Atoi(string(current))
			nums = append(nums, x)
		}
		if len(current) == 0 || j == n-1 {
			result := 0
			if op == '*' {
				result = 1
			}
			for _, x := range nums {
				if op == '+' {
					result = result + x
				} else {
					result = result * x
				}
			}
			total += result
			nums = []int{}
		}
	}

	fmt.Println(total)
}

import re
from operator import add, mul

def part1(data: str):
    # split into row, but do not split into cells yet
    rows = data.splitlines()
    m = len(rows)   # number of rows

    # initialize the result and operator arrays
    # the operators array will store the operator function for each column block
    # the result array will store the initial value for each column block
    operators = []
    res = []
    # using regex to skip variable number of spaces
    for symbol in re.findall(r'\S', rows[-1]):
        if symbol == '+':
            operators.append(add)
            res.append(0)
        elif symbol == '*':
            operators.append(mul)
            res.append(1)

    n = len(res)    # number of columns
    # iterate through each row, except the last one
    for i in range(m-1):
        # use regex to find all numbers in the row
        for j, num in enumerate(map(int, re.findall(r'\d+', rows[i]))):
            # apply the operator to update the result for the appropriate column
            res[j] = operators[j](res[j], num)

    return sum(res)

def part2(data: str):
    # completely split into grid
    grid = [list(line) for line in data.splitlines()]
    m, n = len(grid), len(grid[0])
    
    res = 0
    
    curr = None     # current value of the block
    op = None       # operator for the block
    for j in range(n):
        if curr is None:
            # we just started a new block
            # update the current value and operator based on the symbol
            symbol = grid[-1][j]
            curr = 0 if symbol == '+' else 1
            op = add if symbol == '+' else mul
        
        # read the number from the column
        num = 0
        for i in range(m-1):
            if grid[i][j] != ' ':
                num = num * 10 + int(grid[i][j])
        # if there is no number, we are at the end of a block
        if num == 0:
            # add the block value to the result
            #   and reset the current value and operator
            res += curr
            curr = None
            op = None
            continue
        
        # otherwise, update the current value using the operator
        curr = op(curr, num)
    # finally, don't forget to add the last block value that's being tracked
    res += curr

    return res

sample = """123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  """
assert part1(sample) == 4277556
assert part2(sample) == 3263827

package main

import (
	"aoc/utils"
	"fmt"
	"regexp"
	"slices"
	"strconv"
	"strings"
)

type operation int

func (o operation) compute(values []int) int {
	switch o {
	case add:
		sum := 0
		for _, val := range values {
			sum += val
		}
		return sum
	case mul:
		product := 1
		for _, val := range values {
			product *= val
		}
		return product
	}

	return 0
}

const (
	add operation = iota
	mul
)

var allOperationSymbols = []string{"+", "*"}

func operationFromSymbol(sym string) operation {
	switch sym {
	case "+":
		return add
	case "*":
		return mul
	default:
		panic(fmt.Sprintf("wtf is a %s?", sym))
	}
}

type problems struct {
	values     [][]int
	operations []operation
}

func (p *problems) feed(column string) {
	last := string(column[len(column)-1])
	done := false

	if slices.Contains(allOperationSymbols, last) {
		p.operations = append(p.operations, operationFromSymbol(last))
		column = column[:len(column)-1]
		done = true
	}

	val, _ := strconv.Atoi(strings.TrimSpace(column))
	idx := len(p.values) - 1
	p.values[idx] = append(p.values[idx], val)

	if done {
		p.values = append(p.values, []int{})
	}
}

func (p *problems) addLine(line string) (done bool) {
	parts := strings.Split(line, " ")
	parts = slices.DeleteFunc(parts, func(elem string) bool {
		return elem == ""
	})

	if slices.Contains(allOperationSymbols, parts[0]) {
		p.operations = make([]operation, len(parts))
		for idx, sym := range parts {
			p.operations[idx] = operationFromSymbol(sym)
		}
		done = true
	} else {
		if len(p.values) == 0 {
			lenparts := len(parts)
			p.values = make([][]int, lenparts)
			for idx := range lenparts {
				p.values[idx] = []int{}
			}
		}

		for idx, part := range parts {
			num, _ := strconv.Atoi(part)
			p.values[idx] = append(p.values[idx], num)
		}
		done = false
	}

	return done
}

func (p problems) solve() []int {
	solutions := make([]int, len(p.values))

	for idx, values := range p.values {
		op := p.operations[idx]
		solutions[idx] = op.compute(values)
	}

	return solutions
}

func stepOne(input chan string) (int, error) {
	modernProblems := problems{}
	for line := range input {
		done := modernProblems.addLine(line)
		if done {
			break
		}
	}

	modernSolutions := modernProblems.solve()
	sum := 0
	for _, solution := range modernSolutions {
		sum += solution
	}

	return sum, nil
}

func transposeInputChan(input chan string) []string {
	lines := [][]rune{}
	for line := range input {
		lines = append(lines, []rune(line))
	}

	linecount := len(lines)
	columncount := len(lines[0])
	transposed := make([][]rune, columncount)

	for idx := range transposed {
		transposed[idx] = make([]rune, linecount)
	}

	for row, line := range lines {
		for col, char := range line {
			transposed[col][row] = char
		}
	}

	columns := make([]string, len(transposed))
	for idx, col := range transposed {
		columns[idx] = string(col)
	}

	return columns
}

func stepTwo(input chan string) (int, error) {
	transposedInput := transposeInputChan(input)
	slices.Reverse(transposedInput)

	// problem-set with one empty problem.
	modernProblems := problems{
		values: [][]int{[]int{}},
	}

	for _, column := range transposedInput {
		if matched, _ := regexp.MatchString("^\\s*$", column); matched {
			continue
		}

		modernProblems.feed(column)
	}

	// Remove last useless empty problem.
	modernProblems.values = modernProblems.values[:len(modernProblems.values)-1]

	modernSolutions := modernProblems.solve()
	sum := 0
	for _, solution := range modernSolutions {
		sum += solution
	}

	return sum, nil
}

func main() {
	inputFile := utils.FilePath("day06.txt")
	utils.RunStep(utils.ONE, inputFile, stepOne)
	utils.RunStep(utils.TWO, inputFile, stepTwo)
}

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <ctype.h>
#include <assert.h>
#include <sys/mman.h>
#include <unistd.h>
#include <err.h>

#define GH	5

int
main()
{
	char *data, *g[GH], *p;
	uint64_t p1=0,p2=0, acc;
	int len, h=0, i, x,y, val;
	char op;

	if ((len = (int)lseek(0, 0, SEEK_END)) == -1)
		err(1, "<stdin>");
	if (!(data = mmap(NULL, len, PROT_READ, MAP_SHARED, 0, 0)))
		err(1, "<stdin>");
	for (i=0; i<len; i++)
		if (!i || data[i-1]=='\n') {
			assert(h < GH);
			g[h++] = data+i;
		}

	for (x=0; g[h-1]+x < data+len; x++) {
		if ((op = g[h-1][x]) != '+' && op != '*')
			continue;

		for (acc = op=='*', y=0; y<h-1; y++) {
			val = atoi(&g[y][x]);
			acc = op=='+' ? acc+val : acc*val;
		}

		p1 += acc;

		for (acc = op=='*', i=0; ; i++) {
			for (val=0, y=0; y<h-1; y++) {
				p = &g[y][x+i];
				if (p < g[y+1] && isdigit(*p))
					val = val*10 + *p-'0';
			}
			if (!val)
				break;
			acc = op=='+' ? acc+val : acc*val;
		}

		p2 += acc;
	}

	printf("06: %"PRIu64" %"PRIu64"\n", p1, p2);
}