🦌 Advent Of Code 2020

function day1_part1(input)

    for n ∈ input       

        r = searchsorted(input_day1, 2020 - n)

        if r.start ≤ r.stop

            return n * input[r.start]

        end

    end

end

function day1_part2(input)

    l = length(input)

    for i ∈ 1:l     

        for j ∈ i+1:l

            v = 2020 - input[i] - input[j]

            if v ≤ 0

                break

            end

            r = searchsorted(input_day1, v)

            if r.start ≤ r.stop     

                return input[i] * input[j] * input[r.start]

            end

        end

    end

end

struct Password

    policy_range :: UnitRange

    policy_char :: Char

    p :: String

end 

nb_of_valid_passwords_part2(passwords) =

    count(

        password ->

            (password.p[password.policy_range.start] == password.policy_char) ⊻

            (password.p[password.policy_range.stop] == password.policy_char),

        passwords

    )

function parse_day2(lines)

    line_regexp = r"^(\d+)-(\d+) ([a-z]): ([a-z]+)$"

    function parse_line(line)

        m = match(line_regexp, line)

        Password(

            UnitRange(parse(Int, m.captures[1]), parse(Int, m.captures[2])),

            m.captures[3][1],

            m.captures[4]

        )

    end

    parse_line.(lines)

end

nb_of_valid_passwords_part1(passwords) =

    count(

        password -> count(==(password.policy_char), password.p) ∈ password.policy_range,

        passwords

    )

function parse_day3(lines)  

    map(==("#"), hcat(split.(lines, "")...))'

end

function nb_trees_encountered(area :: AbstractArray{Bool, 2}, moves = [(1, 3)])

    m, n = size(area)

    map(moves) do (di, dj)                  

        foldl(1:di:m, init = (1, 0)) do (j, sum), i

            mod1(j + dj, n), sum + area[i, j]

        end[2]

    end

end

nb_trees_encountered_part2(area) = nb_trees_encountered(area, [(1, 1), (1, 3), (1, 5), (1, 7), (2, 1)])

function parse_day4(lines)

    passports = [Dict{String, String}()]

    for line ∈ lines

        if line == ""

            push!(passports, Dict())

        else

            for value in split(line, ' ')

                key_value = split(value, ':')

                last(passports)[key_value[1]] = key_value[2]

            end

        end

    end

    passports

end

function count_nb_valid_passport(passports :: AbstractArray{Dict{String,String}}, check_fields_integrity = false)

    required_fields = ["byr", "iyr", "eyr", "hgt", "hcl", "ecl", "pid"]

    function check_field(field, value)      

        try

            field == "byr" && 1920 ≤ parse(Int, value) ≤ 2020 ||

            field == "iyr" && 2010 ≤ parse(Int, value) ≤ 2020 ||

            field == "eyr" && 2020 ≤ parse(Int, value) ≤ 2030 ||

            field == "hgt" &&

                ((inches = match(r"(\d+)in", value)) ≠ nothing && 59 ≤ parse(Int, inches.captures[1]) ≤ 76 ||

                 (cm = match(r"(\d+)cm", value)) ≠ nothing && 150 ≤ parse(Int, cm.captures[1]) ≤ 193) ||

            field == "hcl" && occursin(r"^#[0-9a-f]{6}$", value) ||

            field == "ecl" && value ∈ ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"] ||

            field == "pid" && occursin(r"^[0-9]{9}$", value)

        catch

            false

        end

    end

    count(passports) do p

        all(required_fields) do f

            haskey(p, f) && (!check_fields_integrity || check_field(f, p[f]))

        end

    end

end

function parse_day5(lines)

    map(lines) do line      

        row = parse(Int, join(replace(split(line[1:7], ""), "F" => "0", "B" => "1")); base = 2)

        col = parse(Int, join(replace(split(line[8:10], ""), "L" => "0", "R" => "1")); base = 2)

        row * 8 + col

    end

end

function find_missing_id(ids)

    sorted_ids = sort(ids)

    for i ∈ 1:length(sorted_ids)-1

        if sorted_ids[i] + 1 ≠ sorted_ids[i + 1]

            return sorted_ids[i] + 1

        end

    end

end

function parse_day6(lines) :: Array{Array{Set{Char}}}

    groups = [[]]

    for line ∈ lines

        if line == ""

            push!(groups, [])

        else

            push!(last(groups), Set(line))

        end

    end

    groups

end

function sum_of_group_lengths(groups, f)

    map(groups) do group

        length(reduce(f, group))

    end |> sum  

end

struct Bags

    matrix :: Array{Int, 2}

    names :: Dict{String, Int}

end

function parse_day7(lines)

    l = length(lines)

    m = zeros(Int, l, l)    

    name_indices = Dict{String, Int}()

    get_bag_index(name) = get!(name_indices, name, length(name_indices) + 1)

    for i ∈ 1:l

        line = lines[i]

        bag = match(r"^\w+ \w+", line).match        

        bag_index = get_bag_index(bag)

        for inner_bag ∈ eachmatch(r"(\d+) (\w+ \w+) bag", line)

            n = parse(Int, inner_bag[1])

            m[bag_index, get_bag_index(inner_bag[2])] = n

        end

    end

    Bags(m, name_indices)

end

function bags_that_contain(name, bags)

    visited = falses(length(bags.names))

    to_visit = [bags.names[name]]   

    while !isempty(to_visit)

        current = pop!(to_visit)        

        visited[current] = true

        containing = findall(≠(0), bags.matrix[:, current] .* .!visited)

        append!(to_visit, containing)

    end 

    findall(visited)

end

function nb_bags_contained(name, bags)  

    function nb_bags_contained(bag_index)

        content = bags.matrix[bag_index, :]

        indexes = findall(≠(0), content)

        1 + (isempty(indexes) ? 0 : sum(nb_bags_contained.(indexes) .* filter(≠(0), content)))

    end

    nb_bags_contained(bags.names[name]) - 1

end

struct Instruction

    operator :: Symbol

    argument :: Int

end

function parse_day8(lines)

    map(lines) do line

        splitted = split(line, ' ')

        Instruction(Symbol(splitted[1]), parse(Int, splitted[2]))

    end

end

# The returned boolean is true if the execution has finished correctly or false if there is a infinite loop.

# The returned integer is the accumulator when the inifinite loop is detected or when the execution has finished correctly.

function execute(instructions) :: Tuple{Bool, Int}

    pos = 1

    accumulator = 0

    n = length(instructions)

    visited_positions = falses(n)

    while pos ≤ n && !visited_positions[pos]

        visited_positions[pos] = true

        ins = instructions[pos]

        if ins.operator == :acc

            accumulator += ins.argument

            pos += 1            

        elseif ins.operator == :jmp

            pos += ins.argument

        else # :nop.

            pos += 1

        end

    end

    pos > n, accumulator

end

function fix_to_not_loop(instructions)

    copy = deepcopy(instructions) # To avoid modifying the input.

    function switch(pos)

        if copy[pos].operator == :jmp

            copy[pos] = Instruction(:nop, copy[pos].argument)

            true

        elseif copy[pos].operator == :nop

            copy[pos] = Instruction(:jmp, copy[pos].argument)

            true

        else

            false

        end

    end

    for i ∈ 1:length(copy)

        if switch(i)

            finished, accumulator = execute(copy)

            if finished

                return accumulator

            end

            switch(i)

        end

    end

end

function parse_day9(lines)

    parse.(Int64, lines)

end

function first_number_without_valid_pair(numbers, preamble_size)    

    for i ∈ preamble_size+1:length(numbers)

        previous = numbers[i-preamble_size:i-1]

        n = numbers[i]

        if n ∉ [a + b for a ∈ previous for b ∈ previous if a ≠ b]

            return n

        end

    end

end

function find_encryption_weakness(numbers, target)

    l = length(numbers)

    for i ∈ 1:l

        for j ∈ i+1:l           

            ξ = numbers[i:j]

            s = sum(ξ)

            if s == target 

                return maximum(ξ) + minimum(ξ)

            elseif s > target

                break

            end

        end

    end

end