SQL HowTo: математика вдоль и поперек (Advent of Code 2025, Day 6: Trash Compactor)

Осторожно, спойлеры! Не читайте, пока хотите решить задачу самостоятельно.

В этой челлендж-серии статей, начатой с прошлогоднего эвента, попробуем использовать PostgreSQL как среду для решения задач Advent of Code 2025.

Возможно, SQL не самый подходящий для этого язык, зато мы рассмотрим его различные возможности, о которых вы могли и не подозревать.

• Решение Day 1: Secret Entrance (немного математики)

• Решение Day 2: Gift Shop (генерируем строкочисла)

• Решение Day 3: Lobby (от частностей к рекурсии)

• Решение Day 4: Printing Department ("запекаем" шаг рекурсии)

• Решение Day 5: Cafeteria (проверяем и объединяем диапазоны)

• Решение Day 6: Trash Compactor (математика вдоль и поперек)

• Решение Day 7: Laboratories (трассировка и подсчет путей)

Оригинальная постановка задачи и ее перевод:

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

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

Часть 1

Решим предлагаемые задачи "в три действия".

Во-первых, распознаем и пронумеруем те элементы (числа и знаки операций), которые у нас есть на листе. Параллельно определим общее количество столбцов - оно равно общему количеству знаков операций:

WITH elem AS (
  SELECT
    i - 1 i -- номер элемента, начиная с 0
  , elem[1] -- элемент задачи - число или знак операции
  , count(*) FILTER(WHERE elem[1] IN ('+', '*')) OVER() cols -- общее кол-во столбцов
  FROM
    regexp_matches($$
123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  
    $$, '(\d+|\+|\*)', 'g')
      WITH ORDINALITY T(elem, i)
)

 i | elem | cols
 0 | 123  |    4
 1 | 328  |    4
 2 | 51   |    4
 3 | 64   |    4
 4 | 45   |    4
 5 | 64   |    4
 6 | 387  |    4
 7 | 23   |    4
 8 | 6    |    4
 9 | 98   |    4
10 | 215  |    4
11 | 314  |    4
12 | *    |    4
13 | +    |    4
14 | *    |    4
15 | +    |    4

Заметим, что все элементы, относящиеся к одной задаче, имеют один и тот же остаток от деления на количество столбцов - сгруппируем их, сразу вычисляя агрегат, соответствующий операции:

SELECT
  CASE min(elem) FILTER(WHERE elem IN ('+', '*')) -- оператор
    WHEN '+' THEN
      sum(elem::bigint) FILTER(WHERE elem NOT IN ('+', '*')) -- сумма чисел
    WHEN '*' THEN
      exp(sum(ln(elem::bigint)) FILTER(WHERE elem NOT IN ('+', '*')))::bigint -- произведение чисел
  END res
FROM
  elem
GROUP BY
  i % cols

Здесь мы использовали агрегатную функцию min для определения "первого и единственного" в столбце подходящего под FILTER-условия оператора.

А для вычисления произведения набора чисел, агрегатной функции для которого нет, выразим его через сумму логарифмов:

Осталось лишь просуммировать все полученные по задачам ответы:

WITH elem AS (
  SELECT
    i - 1 i -- номер элемента, начиная с 0
  , elem[1] -- элемент задачи - число или знак операции
  , count(*) FILTER(WHERE elem[1] IN ('+', '*')) OVER() cols -- общее кол-во столбцов
  FROM
    regexp_matches($$
123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  
    $$, '(\d+|\+|\*)', 'g')
      WITH ORDINALITY T(elem, i)
)
SELECT
  sum(res)
FROM
  (
    SELECT
      CASE min(elem) FILTER(WHERE elem IN ('+', '*')) -- оператор
        WHEN '+' THEN
          sum(elem::bigint) FILTER(WHERE elem NOT IN ('+', '*')) -- сумма чисел
        WHEN '*' THEN
          exp(sum(ln(elem::bigint)) FILTER(WHERE elem NOT IN ('+', '*')))::bigint -- произведение чисел
      END res
    FROM
      elem
    GROUP BY
      i % cols
  ) T;

Часть 2

Во второй части нас просят читать числа с листа не по строкам, а по столбцам.

"Пересоберем" числа, сначала разбив текст на строки, строки - на символы, а символы с помощью string_agg скомпонуем уже по столбцам:

WITH elem AS(
  SELECT
    col -- номер столбца
  , string_agg(c, '' ORDER BY row) FILTER(WHERE c ~ '\d')::bigint num -- это число
  , min(c) FILTER(WHERE c IN ('+', '*')) op                           -- это оператор
  FROM
    regexp_split_to_table($$
123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  
    $$, '[\r\n]+')
      WITH ORDINALITY line(line, row) -- разбиение по строками
  , regexp_split_to_table(line, '')
      WITH ORDINALITY char(c, col)    -- разбиение по символам (столбцам)
  WHERE
    line <> '' -- сразу пропускаем пустые строки
  GROUP BY
    col
)

col | num | op
  1 |   1 | *
  2 |  24 |
  3 | 356 |
  4 |     |
  5 | 369 | +
  6 | 248 |
  7 |   8 |
  8 |     |
  9 |  32 | *
 10 | 581 |
 11 | 175 |
 12 |     |
 13 | 623 | +
 14 | 431 |
 15 |   4 |

Теперь нам необходимо определить, к какой из задач относятся конкретные операторы и числа - для этого пронумеруем их по количеству встретившихся нам выше по выборке операторов с помощью оконной функции count:

, task AS (
  SELECT
    count(op <> '') OVER(ORDER BY col) task -- номер задачи - количество операторов перед строкой
  , num
  , op
  FROM
    elem
  WHERE
    num IS NOT NULL -- пропускаем пустые строки
)

task | num | op
   1 |   1 | *
   1 |  24 |
   1 | 356 |
   2 | 369 | +
   2 | 248 |
   2 |   8 |
   3 |  32 | *
   3 | 581 |
   3 | 175 |
   4 | 623 | +
   4 | 431 |
   4 |   4 |

Ну а дальше - задача сведена к предыдущей! Разве что преобразовывать строки в числа и вычислять номер задачи нам больше не требуется:

WITH elem AS(
  SELECT
    col -- номер столбца
  , string_agg(c, '' ORDER BY row) FILTER(WHERE c ~ '\d')::bigint num -- это число
  , min(c) FILTER(WHERE c IN ('+', '*')) op                           -- это оператор
  FROM
    regexp_split_to_table($$
123 328  51 64 
 45 64  387 23 
  6 98  215 314
*   +   *   +  
    $$, '[\r\n]+')
      WITH ORDINALITY line(line, row) -- разбиение по строками
  , regexp_split_to_table(line, '')
      WITH ORDINALITY char(c, col)    -- разбиение по символам (столбцам)
  WHERE
    line <> '' -- сразу пропускаем пустые строки
  GROUP BY
    col
)
, task AS (
  SELECT
    count(op <> '') OVER(ORDER BY col) task -- номер задачи - количество операторов перед строкой
  , num
  , op
  FROM
    elem
  WHERE
    num IS NOT NULL -- пропускаем пустые строки
)
SELECT
  sum(res)
FROM
  (
    SELECT
      CASE min(op) FILTER(WHERE op IN ('+', '*')) -- оператор
        WHEN '+' THEN
          sum(num) -- сумма чисел
        WHEN '*' THEN
          exp(sum(ln(num)))::bigint -- произведение чисел
      END res
    FROM
      task
    GROUP BY
      task
  ) T;