AOC 2025 - day 06

[guaracy]

First attempt at solving the Advent of Code Day 6 puzzle.
If you think there is a more idiomatic way to solve the puzzle or improve performance, please let me know.
I think the times to solve the puzzle are fine.
Test data: 13 ms
Puzzle data: 21 ms

REBOL [
  title: "Day 6: Trash Compactor"
  file: %day06.r3
  link: https://adventofcode.com/2025/day/6
]

data: {123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  }

data: split-lines data ; test data
; data: read/lines %day06.dat ; puzzle data

op: last data
pos: copy []
rule-operators: [some [to ["+" | "*"] s: (append pos index? s) thru space ] to end]

lines: (length? data) - 1

parse op rule-operators
append pos (length? op) + 2

get-numbers: function[p1 p2][
    numbers: copy []
    part2: copy []
    columns: p2 - p1 - 1
    for ix 1 lines 1 [
        n: copy/part at data/:ix p1 columns
        append numbers n
    ]
    for ix 1 columns 1 [
        t: copy ""
        for iy 1 lines 1 [
            append t numbers/:iy/:ix
        ]
        append part2 t
    ]
    return reduce [map-each w numbers [to integer! w] map-each w part2 [to integer! w]]
]

prod: function[values][
    result: 1
    foreach value values [result: result * value]
    result
]

acc1: acc2: 0
forall  pos [
    if first next pos [
        n: get-numbers first pos first next pos
        switch op/(first pos) [
            #"+" [acc1: acc1 + sum n/1  acc2: acc2 + sum n/2]
            #"*" [acc1: acc1 + prod n/1 acc2: acc2 + prod n/2]
        ]
    ]
]
print ["Part 1:" acc1]
print ["Part 2:" acc2]

[Oldes]

Hi... this is how I would solve it:

;; Load data block containing numbers and operators at the end
data: load {123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  }

;; Split data into numeric part and operator part
parse data [any integer! ops: to end]
ops: take/all ops                      ;; Extract tail of symbols (* + * +)

;; Determine table dimensions
cols:  length? ops                     ;; Number of columns = number of operators
rows: (length? data) / cols            ;; Compute number of rows from total numbers

;; Prepare to store column results
results: copy []

;; Loop through each column index
repeat c cols [
	op: ops/:c                         ;; Operator for this column (* or +)
	result: none                       ;; Result accumulator for current column
	i: c                               ;; Start index of this column
	prin ["Column[" c "] "]

	;; Traverse down this column by stepping every `cols` elements
	while [num: data/:i][
		either result [                ;; If result already initialized
			prin ["" op num]
			result: either op == '+ [  ;; Apply operation
				result + num
			][	result * num ]
		][
			prin num
			result: num                ;; First value initializes result
		]
		i: i + cols                    ;; Jump to next row for current column
	]
	print [" =" result]

	append results result              ;; Store final column result
]

;; Display sum of all column results
print ["The grand total:" as-green sum results]

Column[ 1 ] 123 * 45 * 6 = 33210
Column[ 2 ] 328 + 64 + 98 = 490
Column[ 3 ] 51 * 387 * 215 = 4243455
Column[ 4 ] 64 + 23 + 314 = 401
The grand total: 4277556

[Oldes]

To be honest, your solution looks complicated to me. I probably don't see complete task without being in the game.

What really beats me in your code is first pos, which can be replaced with pos/1 and first next pos, which can be written like pos/2.

[Oldes]

thru space should be replaced with some space (thru space skips just one space)

[Oldes]

Seeing full task, here is my solution:

;; Read input file as lines of text (the number grid)
data: read/lines %input.txt

;; Extract the last line containing operators (* + * +)
ops: take/last data

;; Helper function to compute product of a list of numbers
prod: function[values][
    result: 1
    foreach value values [result: result * value]
    result
]

;; Accumulators for part1 and part2 results
part1: copy []
part2: copy []

;; Parse the operator line to find each operation region
parse ops [
    some [
        ;; Match operator (* or +) followed by any spaces until next operator
        s: set op [#"*" | #"+"] any space e: (
            ;; Calculate start position and width of this operation column
            s:  index? s
            w: (index? e) - s
            
            ;; Extract column data for ALL rows at this position/width
            nums1: clear []
            nums2: clear []
            foreach line data [
                append nums1 copy/part at line s w
            ]
            
            ;; For part2:
            repeat i w [
                n: clear ""
                forall nums1 [
                    append n nums1/1/:i
                ]
                ;; Only accept if it parses as numbers
                unless parse n [some space end][
                    append nums2 to integer! n
                ]
            ]
            
            ;; Convert part1 column data to integers
            forall nums1 [nums1/1: to integer! nums1/1]
            
            ;; Apply operation based on operator type
            either op == #"+" [
                append part1 sum nums1
                append part2 sum nums2
            ][
                append part1 prod nums1
                append part2 prod nums2
            ]
        )
    ]
]

;; Display results
? part1
? part2
print ["The grand total part1:" as-green sum part1]
print ["The grand total part2:" as-green sum part2]

[guaracy]

Thanks a lot for the coding tips!