Что я узнал за 10 дней Advent Of Code на SQLite

select * from inp;
-- +-------------------------------+
-- |              inp              |
-- +-------------------------------+
-- | sgrrrrwcrxlqqgppfgfnngsgcgngr |
-- +-------------------------------+
with recursive parsed as (
     -- Выбираем первый символ и первый индекс
     select substr(inp, 1, 1) as ch, 1 as index from inp
     union all
     -- Выбираем последующие символы, увеличивая индекс на единицу
     select substr(inp, index+1, 1) as ch,
            index + 1 as index
     from parsed, inp
     -- Чтобы не улететь в бесконечную рекурсию, останавливаемся когда индекс выходит за границы строки
     where index < length(inp)
) select * from parsed
-- +--------+-----+
-- | window | pos |
-- +--------+-----+
-- | s      | 1   |
-- | g      | 2   |
-- | r      | 3   |
-- | r      | 4   |
-- | r      | 5   |
-- | r      | 6   |
-- | w      | 7   |
-- | c      | 8   |
-- | r      | 9   |
-- | x      | 10  |
-- | l      | 11  |
-- | q      | 12  |
-- | q      | 13  |
-- | g      | 14  |
-- | p      | 15  |
-- | p      | 16  |
-- | f      | 17  |
-- | g      | 18  |
-- | f      | 19  |
-- | n      | 20  |
-- | n      | 21  |
-- | g      | 22  |
-- | s      | 23  |
-- | g      | 24  |
-- | c      | 25  |
-- | g      | 26  |
-- | n      | 27  |
-- | g      | 28  |
-- | r      | 29  |
-- +--------+-----+

fun explode(str: String, chars: List<Char> = emptyList()) : List<Char> = when (str.isEmpty) {
    true -> chars
    else -> explode(str.substringAfter(0), chars.plus(str[0]))
}

select * from instructions;
-- +-----------+----+
-- | direction | n  |
-- +-----------+----+
-- | R         | 1  |
-- | U         | 2  |
-- | D         | 3  |
-- | U         | 4  |
-- | R         | 5  |
-- | R         | 6  |
-- | D         | 7  |
-- | D         | 8  |
-- | R         | 9  |
-- | R         | 10 |
-- | D         | 11 |
-- | D         | 12 |
-- | R         | 13 |
-- | U         | 14 |
-- +-----------+----+
solution as(
    -- Задаём начальные позиции как 0,0 и текущий шаг как 1
    select 0 as hi, 0 as hj, 1 as step
    union all
    select
        -- "изменяем" состояние, основываясь на предыдущем шаге
        case direction
            when 'U' then hi + 1
            when 'D' then hi - 1
            else hi
        end as hi,
        case direction
            when 'R' then hj + 1
            when 'L' then hj - 1
            else hj
        end as hj,
        -- инкрементируем шаг
        step + 1 as step
    from solution
    -- джойним нашу таблицу с инструкциями, чтобы знать что делать дальше
    join instructions on n = step
) select * from solution
-- +----+----+------+
-- | hi | hj | step |
-- +----+----+------+
-- | 0  | 0  | 1    |
-- | 0  | 1  | 2    |
-- | 1  | 1  | 3    |
-- | 0  | 1  | 4    |
-- | 1  | 1  | 5    |
-- | 1  | 2  | 6    |
-- | 1  | 3  | 7    |
-- | 0  | 3  | 8    |
-- | -1 | 3  | 9    |
-- | -1 | 4  | 10   |
-- | -1 | 5  | 11   |
-- | -2 | 5  | 12   |
-- | -3 | 5  | 13   |
-- | -3 | 6  | 14   |
-- | -2 | 6  | 15   |
-- +----+----+------+

select count(distinct *) over (order by index between current row and 4 following) from parsed

select * from my_table where row_number() over () % 2 = 0

with temp as(select *, row_number() over () as rn from my_table)
select * from my_table where rn % 2 = 0

select row_number() over w, lead() over w from my_table
window w as (partition by x order by y)