seq = ["L68", "L30", "R48", "L5", "R60", "L55", "L1", "L99", "R14", "L82"]

function get_passwords(seq::Vector{String}, dial_start::Int = 50, dial_mod::Int = 100)

    dial = dial_start; pass_zeros = 0; end_zeros = 0

    for turn ∈ seq
        direction = turn[begin]; turns = parse(Int, turn[2:end])
        
        if direction == 'R'

            pass_zeros += fld(dial + turns, dial_mod)
            dial += turns

        elseif direction == 'L'

            # we need to catch the case where the dial starts at 0 and not count that first turn
            pass_zeros -= fld(dial - turns - 1, dial_mod) - fld(dial - 1, dial_mod)
            dial -= turns
            
        end

        dial = mod(dial, dial_mod)

        if dial == 0
            end_zeros += 1
        end
    end

    return (end_zeros=end_zeros, pass_zeros=pass_zeros)
end

seq |> get_passwords

product_ids = ["11-22", "95-115", "998-1012", "1188511880-1188511890", "222220-222224",
        "1698522-1698528","446443-446449","38593856-38593862","565653-565659",
        "824824821-824824827","2121212118-2121212124"]

function is_invalid(id::Int; part_1::Bool = false)
    
    id_string = string(id); midpoint = length(id_string) ÷ 2

    if part_1
        return id_string[begin:midpoint] == id_string[midpoint+1:end]
    end

    for pattern_length ∈ 1:midpoint 
    # a pattern more than half the length can't repeat
        if id_string == id_string[begin:pattern_length] ^ (length(id_string) ÷ pattern_length)
        # is the id made *only* of this repeated pattern?
            return true
        end
    end

    return false
end

invalid_ids = Int[]
for id ∈ product_ids

    parts = split(id, "-")
    id_start = parse(Int, parts[begin]); id_end = parse(Int, parts[end])

    for id ∈ id_start:id_end
        if is_invalid(id)
            push!(invalid_ids, id)
        end
    end

end 

invalid_ids |> sum

joltages = [
    "987654321111111"
    "811111111111119"
    "234234234234278"
    "818181911112111"
    ]

function max_joltage_for_bank(bank::String; n_batteries::Int = 2)

    digits = parse.(Int, collect(bank)) 

    max_joltage = []; index = 1

    for k ∈ 1:n_batteries

        digits_needed = n_batteries - k
        search_end = length(digits) - digits_needed

        max_val = -1; max_idx = -1
        for i ∈ index:search_end
            if digits[i] > max_val
                # keep track of the biggest digit in this range and it's index...
                max_val = digits[i]; max_idx = i
            end
        end

        # ...so we can update the new starting point
        index = max_idx + 1
        push!(max_joltage, max_val)
    
    end

    return max_joltage |> join |> x -> parse(Int, x)
end

joltages |> x -> max_joltage_for_bank.(x, n_batteries = 12) |> sum

grid = [
    "..@@.@@@@."
    "@@@.@.@.@@"
    "@@@@@.@.@@"
    "@.@@@@..@."
    "@@.@@@@.@@"
    ".@@@@@@@.@"
    ".@.@.@.@@@"
    "@.@@@.@@@@"
    ".@@@@@@@@."
    "@.@.@@@.@."
    ]

function find_accessible(warehouse::Matrix{Char}; n_aux::Int = 4)

    n_rows, n_cols = size(warehouse); labelled_warehouse = copy(warehouse)
    
    # all 8 directions: (row_offset, col_offset)
    directions = [
        (-1, -1), (-1, 0), (-1, 1),
        ( 0, -1),          ( 0, 1),
        ( 1, -1), ( 1, 0), ( 1, 1)
    ]
    
    for row ∈ 1:n_rows
        for col ∈ 1:n_cols
            
            warehouse[row, col] != '@' && continue # we're only checking the papers
            
            neighbouring_papers = 0
            for (Δr, Δc) ∈ directions
                check_row, check_col = row + Δr, col + Δc
                
                if 1 ≤ check_row ≤ n_rows && 1 ≤ check_col ≤ n_cols # stay in the grid!
                    if warehouse[check_row, check_col] == '@'
                        neighbouring_papers += 1
                    end
                end
            end
            
            if neighbouring_papers < n_aux
                labelled_warehouse[row, col] = 'x'
            end
        end
    end
    
    return labelled_warehouse
end

grid |> 
    lines ->  [lines[r][c] for r ∈ eachindex(lines), c ∈ 1:length(lines[1])] |>
    warehouse -> count(==('x'), find_accessible(warehouse))

function remove_all_reams(grid::Matrix{Char})
    labelled_warehouse = copy(grid)
    while true
        new_labelled_warehouse = find_accessible(labelled_warehouse)
        new_labelled_warehouse == labelled_warehouse && break
        labelled_warehouse = new_labelled_warehouse
    end
    return count(==('x'), labelled_warehouse)
end

ingredients_db = [
    "3-5"
    "10-14"
    "16-20"
    "12-18"

    "1"
    "5"
    "8"
    "11"
    "17"
    "32"
]

fresh_ingredients = Dict{Int, Vector{UnitRange{Int}}}()
for i ∈ ingredients
    for r ∈ ranges
        if i ∈ r
            push!(get!(fresh_ingredients, i, UnitRange{Int}[]), r)
        end
    end
end

fresh_ingredients |> length

sorted_ranges = sort(ranges, by = first)

fresh_ingredients_merged = [sorted_ranges[begin]]
for range ∈ sorted_ranges[2:end]
    # start a new range when the lower value is outside the largest value of the merge
    if last(fresh_ingredients_merged[end]) < first(range)
        push!(fresh_ingredients_merged, range)
    else
    # the start of the new range stays the same, but the end needs to be extended if it's bigger for the new range
    new_max_range = [last(fresh_ingredients_merged[end]), last(range)] |> maximum
    fresh_ingredients_merged[end] = first(fresh_ingredients_merged[end]):new_max_range
    end    
end

[length(x) for x ∈ fresh_ingredients_merged] |> sum

sums = [
    "123 328  51 64 ",
    " 45 64  387 23 ",
    "  6 98  215 314",
    "*   +   *   +  "
]

function solve_sums(lines::Vector{String}; part_2::Bool = false)
    
    n_cols = lines[end] |> length
    # need to break until the next sum when there is a column of spaces
    no_sum = [all(line[c] == ' ' for line ∈ lines) for c ∈ 1:n_cols]

    results = Int[]; col = 1
    while col <= n_cols
        # skip the separator columns that split the sums
        while col <= n_cols && no_sum[col]
            col += 1
        end
        col > n_cols && break
        
        # otherwise we start a new sum
        start_sum = col
        
        # and keep going until the next separator
        while col <= n_cols && !no_sum[col]
            col += 1
        end

        # the operator is always in the first col of each sum, in the last row
        op = lines[end][start_sum]
        
        if part_2
            # pt.2: each column is a number (read top-down)
            numbers = Int[]
            for nums_col ∈ start_sum:col-1
                digits = [line[nums_col] for line ∈ lines[1:end-1] if line[nums_col] != ' ']
                if !isempty(digits)
                    push!(numbers, parse(Int, String(digits)))
                end 
            end
        else
            # pt.1: each row is a number, but they can have leading spaces
            numbers = [parse(Int, strip(line[start_sum:col-1])) for line ∈ lines[1:end-1]]
        end
        
        # an excuse to use Julia metaprogramming :)
        push!(results, op |> Symbol |> eval |> x -> reduce(x, numbers))
    end
        
    return results
end

sums |> solve_sums |> sum

tachyon_manifold = [
    ".......S.......",
    "...............",
    ".......^.......",
    "...............",
    "......^.^......",
    "...............",
    ".....^.^.^.....",
    "...............",
    "....^.^...^....",
    "...............",
    "...^.^...^.^...",
    "...............",
    "..^...^.....^..",
    "...............",
    ".^.^.^.^.^...^.",
    "..............."
]

function analyse_beams(beam_rows::Vector{String})

    n_rows = beam_rows |> length
    n_cols = beam_rows[end] |> length
    grid = [beam_rows[row][col] for row ∈ 1:n_rows, col ∈ 1:n_cols]

    # find starting position
    start_pos = findfirst(==('S'), grid)
    start_row, start_col = start_pos[1], start_pos[2]

    # initialise beams and timelines...
    splits = 0; timelines = Dict(start_col => 1)
    
    for row ∈ (start_row + 1):n_rows
        # ...and then keep track of new ones
        new_timelines = Dict{Int, Int}()
        
        for (col, count) ∈ timelines
            if grid[row, col] == '^'
                # for part 1, we count the splits
                splits += 1 
                # for part 2, we "do" the split and count the timelines (add beams to the left and right - after an in-bounds check)
                col - 1 >= 1 && (new_timelines[col - 1] = get(new_timelines, col - 1, 0) + count)
                col + 1 <= n_cols && (new_timelines[col + 1] = get(new_timelines, col + 1, 0) + count)
            else
                new_timelines[col] = get(new_timelines, col, 0) + count
            end
        end

        timelines = new_timelines

    end

    return ("splits" => splits, "timelines" => timelines)
end

tachyon_manifold |> analyse_beams

junction_boxes = [
    "162,817,812",
    "57,618,57",
    "906,360,560",
    "592,479,940",
    "352,342,300",
    "466,668,158",
    "542,29,236",
    "431,825,988",
    "739,650,466",
    "52,470,668",
    "216,146,977",
    "819,987,18",
    "117,168,530",
    "805,96,715",
    "346,949,466",
    "970,615,88",
    "941,993,340",
    "862,61,35",
    "984,92,344",
    "425,690,689"
]

coords = junction_boxes |>
    boxes -> split.(boxes, ",") |>
    boxes -> [parse.(Int, b) for b ∈ boxes]

# each box starts as its own root
n_boxes = length(coords); parent = collect(1:n_boxes)

# follow the chain upward to find the root
function find_circuit_root(box_index)
    while parent[box_index] != box_index
        box_index = parent[box_index]
    end
    return box_index
end

# connect two circuits by making one root point to the other
function connect_boxes!(box_from, box_to)
    root_from = find_circuit_root(box_from)
    root_to = find_circuit_root(box_to)
    
    # already in same circuit?
    root_from == root_to && return false
    
    # otherwise => merge
    parent[root_from] = root_to
    return true
end

distances = []
for box ∈ 1:n_boxes
    for alt ∈ (box+1):n_boxes  # avoid double-counting pairs
        dist = (coords[box] .- coords[alt]).^2 |> sum |> sqrt
        push!(distances, (dist = dist, from = box, to = alt))
    end
end
sort!(distances, by = first)

function size_circuits(distances; n_attempts::Union{Int, Nothing} = nothing)
    
    # each box starts as is its own circuit
    parent = collect(1:n_boxes)
    last_connection = nothing

    for (attempt, d) ∈ enumerate(distances)
        
        if connect_boxes!(d.from, d.to)
            last_connection = d
        end

        # part 1: stop after N attempts
        if !isnothing(n_attempts) && attempt >= n_attempts
            break
        end
        
        # part 2: stop when everything is connected
        roots = [find_circuit_root(i) for i ∈ 1:n_boxes]
        length(unique(roots)) == 1 && break
    end

    roots = [find_circuit_root(i) for i ∈ 1:n_boxes]
    circuit_sizes = [count(==(r), roots) for r ∈ unique(roots)]
    sort!(circuit_sizes, rev=true)

    return Dict("circuit_sizes" => circuit_sizes, 
                "last_connection" => last_connection)
end

size_circuits(distances)["last_connection"] |>
    last -> coords[last.from][1] * coords[last.to][1]

red_tiles = [
    "7,1",
    "11,1",
    "11,7",
    "9,7",
    "9,5",
    "2,5",
    "2,3",
    "7,3"
]

# connect sequential red tiles with green tiles
function draw_green_line!(grid, from, to)
    x_min, x_max = minmax(from[1], to[1])
    y_min, y_max = minmax(from[2], to[2])
    
    for x ∈ x_min:x_max
        for y ∈ y_min:y_max
            grid[x, y] == 0 && (grid[x, y] = 2)  # only fill empties
        end
    end
end

# are we inside the shape?
function is_inside(grid, x, y)
    grid[x, y] != 0 && return false  # already filled
    
    crossings = 0
    for check_x ∈ 1:(x-1)
        # counting vertical boundaries
        at_y = grid[check_x, y] ∈ (1, 2)
        above = y > 1 && grid[check_x, y-1] ∈ (1, 2)
        at_y && above && (crossings += 1)
    end
    
    return isodd(crossings)
end

# check rectangle contains only red/green tiles
function is_valid_rectangle(grid, c1, c2)
    x_min, x_max = minmax(c1[1], c2[1])
    y_min, y_max = minmax(c1[2], c2[2])
    
    for x ∈ x_min:x_max
        for y ∈ y_min:y_max
            grid[x, y] == 0 && return false
        end
    end
    return true
end

function max_area(red_tiles_coords::Vector{Vector{Int}}; part_2::Bool = false)
    
    n_tiles = length(red_tiles_coords)
    max_area = 0
    best_pair = nothing

    if part_2
    # coordinate compression
        all_x = sort(unique(c[1] for c ∈ red_tiles_coords))
        all_y = sort(unique(c[2] for c ∈ red_tiles_coords))
        
        # big grid => compressed index
        x_to_idx = Dict(x => i for (i, x) ∈ enumerate(all_x))
        y_to_idx = Dict(y => i for (i, y) ∈ enumerate(all_y))
        
        # Compress all red tile coordinates
        compressed_coords = [[x_to_idx[c[1]], y_to_idx[c[2]]] for c ∈ red_tiles_coords]
        
        # using reduced grid dims...
        max_x = length(all_x)
        max_y = length(all_y)
        grid = zeros(Int, max_x, max_y)
        
        # ...mark red tiles and connect with greens
        for c ∈ compressed_coords
            grid[c[1], c[2]] = 1
        end
        
        for i ∈ 1:n_tiles
            next_i = i == n_tiles ? 1 : i + 1
            draw_green_line!(grid, compressed_coords[i], compressed_coords[next_i])
        end
        
        # and paint the interior green too
        for x ∈ 1:max_x
            for y ∈ 1:max_y
                is_inside(grid, x, y) && (grid[x, y] = 2)
            end
        end
    end

    for i ∈ 1:n_tiles
        for j ∈ (i+1):n_tiles
            
            # part 2: check validity using compressed coords
            if part_2 && !is_valid_rectangle(grid, compressed_coords[i], compressed_coords[j])
                continue
            end

            # ...but then calculate the area on the big grid
            width = abs(red_tiles_coords[i][1] - red_tiles_coords[j][1]) + 1
            height = abs(red_tiles_coords[i][2] - red_tiles_coords[j][2]) + 1
                        
            if width * height > max_area
                max_area = width * height
                best_pair = (i, j)
            end
        end
    end

    return max_area
end

red_tiles |>
    tiles -> split.(tiles, ",") |>
    tiles -> [parse.(Int, t) for t ∈ tiles] |> 
    coords -> max_area(coords, part_2 = true)