Anyone planning on solving Advent of Code 2020?

Rainer · 4 December 2020 20:52

Here we go with Erlang Day3
Part 1 was easy, in part 2 i got some troubles skipping the lines…

-module(day3).
-export([run/0]).

run()->
    Lines = load_file("day3input.txt"),
    {part1(Lines), part2(Lines)}.

% Part 1 %
part1(Lines)->
    count_trees(Lines, 0, 0).

count_trees([H | T], Pos, Count)->
    case string:slice(H, Pos, 1) of
        "." -> count_trees(T, (Pos + 3) rem length(H), Count);
        "#" -> count_trees(T, (Pos + 3) rem length(H), Count + 1)
    end;
count_trees([], _, Count) ->
    Count.

% Part 2 %
part2(Lines)->
    C1 = count_trees(Lines, 0, 0, 1, 1),
    C2 = count_trees(Lines, 0, 0, 3, 1),
    C3 = count_trees(Lines, 0, 0, 5, 1),
    C4 = count_trees(Lines, 0, 0, 7, 1),
    C5 = count_trees(Lines, 0, 0, 1, 2),
    {C1, C2, C3, C4, C5, C1*C2*C3*C4*C5}.

count_trees([H | T], Pos, Count, Right, Down)->
    case string:slice(H, Pos, 1) of
        "." -> count_trees(nthtail(Down-1, T), (Pos + Right) rem length(H), Count, Right, Down);
        "#" -> count_trees(nthtail(Down-1, T), (Pos + Right) rem length(H), Count + 1, Right, Down)
    end;
count_trees([], _, Count,_,_) ->
    Count.

nthtail(_, [])->[];
nthtail(N, L)-> lists:nthtail(N, L).

% Helper %
load_file(Filename)->
    {ok, Binary} = file:read_file(Filename),
    StringContent = unicode:characters_to_list(Binary),
    [ Line || Line <- string:tokens(StringContent, "\n")].```

mafinar · 5 December 2020 06:56

Your code makes me want to try to solve them in Erlang. Also, looks so clean!! Is there a repository you have them all posted? I would very much like to consult these when I am moderately familiar wiht Erlang

mafinar · 5 December 2020 06:58

Today’s solution. Today’s solution was fun to make. Also, was lurking in ElixirForum and found a very interesting solution to this. Not to spoil anything but it’d be interesting to see if anyone here come up with that “exploit”

github.com

code-shoily/advent_of_code/blob/master/lib/2020/day_5.ex

defmodule AdventOfCode.Y2020.Day5 do
  @moduledoc """
  Problem Link: https://adventofcode.com/2020/day/5
  """
  use AdventOfCode.Helpers.InputReader, year: 2020, day: 5

  def run_1, do: input!() |> process() |> Enum.max()
  def run_2, do: input!() |> process() |> my_id()
  def run, do: {run_1(), run_2()}

  def process(input), do: String.split(input, "\n") |> ids()

  def walk("F" <> pass, lo, hi), do: walk(pass, lo, mid(lo, hi))
  def walk("B" <> pass, lo, hi), do: walk(pass, mid(lo, hi) + 1, hi)
  def walk(pass, row, row) when pass != "", do: {row, walk(pass, 0, 7)}

  def walk("L" <> pass, lo, hi), do: walk(pass, lo, mid(lo, hi))
  def walk("R" <> pass, lo, hi), do: walk(pass, mid(lo, hi) + 1, hi)
  def walk("", column, column), do: column

This file has been truncated. show original

Rainer · 5 December 2020 19:20

Not yet, but I can put them on GitHub later.
As I’m new to Erlang, I have no Idea how “good” my solutions are, with every day i learned something new

Rainer · 5 December 2020 22:00

For Day 4 I wasted a lot of time with the parsing, so i just did part 1 until now:

-module(day4).
-export([run/0]).

run()->
    Lines = load_file("day4input.txt"),
    Passports = lists:map(fun(Line) -> parse_line(Line) end, Lines),
    part1(Passports).

parse_line(Line) ->
    Tokens = string:tokens(Line, " "),
    lists:map(fun(T) -> list_to_tuple(string:tokens(T, ":")) end, Tokens).

part1(Passports)->
    length([ P || P <- Passports, is_valid(P)]).

is_valid(Passport)->
    lists:keymember("byr", 1, Passport) and
    lists:keymember("iyr", 1, Passport) and
    lists:keymember("eyr", 1, Passport) and
    lists:keymember("hgt", 1, Passport) and
    lists:keymember("hcl", 1, Passport) and
    lists:keymember("ecl", 1, Passport) and
    lists:keymember("pid", 1, Passport).

load_file(Filename)->
    {ok, Binary} = file:read_file(Filename),
    StringContent = unicode:characters_to_list(Binary),
    [ string:join(string:replace(Line, "\n", " ", all), "") || Line <- string:split(StringContent, "\n\n", all)].

I’m missing Elixirs pipe operator.

Rainer · 5 December 2020 23:25

Ok, couldn’t stop
All the validating isn’t fun, so I ran out of motivation and the code isn’t pretty, but still, it worked.
Day 4 with part 2:

-module(day4).
-export([run/0]).

run()->
    Lines = load_file("day4input.txt"),
    Passports = lists:map(fun(Line) -> parse_line(Line) end, Lines),
    { part1(Passports), part2(Passports) }.

parse_line(Line) ->
    Tokens = string:tokens(Line, " "),
    lists:map(fun(T) -> list_to_tuple(string:tokens(T, ":")) end, Tokens).

part1(Passports)->
    length([ P || P <- Passports, is_valid(P)]).

is_valid(Passport)->
    lists:keymember("byr", 1, Passport) and
    lists:keymember("iyr", 1, Passport) and
    lists:keymember("eyr", 1, Passport) and
    lists:keymember("hgt", 1, Passport) and
    lists:keymember("hcl", 1, Passport) and
    lists:keymember("ecl", 1, Passport) and
    lists:keymember("pid", 1, Passport).

part2(Passports)->
    P = [ lists:map(fun(X) -> is_valid2(X) end, P) || P <- Passports, is_valid(P)],
    length([X || X <-P, lists:all(fun(Elem)-> Elem =:= true end, X)]).

is_valid2({"byr", Value})->
    {Int, _} = string:to_integer(Value),
    (Int >= 1920) and (Int =< 2002);
is_valid2({"iyr", Value})->
    {Int, _} = string:to_integer(Value),
    (Int >= 2010) and (Int =< 2020);
is_valid2({"eyr", Value})->
    {Int, _} = string:to_integer(Value),
    (Int >= 2020) and (Int =< 2030);
is_valid2({"hgt", Value})->
    case string:to_integer(Value) of
        {Cm, "cm"} -> (Cm >= 150) and (Cm =< 193);
        {In, "in"} -> (In >= 59) and (In =< 76);
        _ -> false
    end;
is_valid2({"hcl", Value})->
    {ok, MP} = re:compile("^#[0-9a-f]{6}$"),
    case re:run(Value, MP) of
        {match, _} -> true;
        _ -> false
    end;
is_valid2({"ecl", Value})->
    lists:member(Value, ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"]);
is_valid2({"pid", Value})->
    {ok, MP} = re:compile("^[0-9]{9}$"),
    case re:run(Value, MP) of
        {match, _} -> true;
        _ -> false
    end;
is_valid2({"cid",_}) -> true;
is_valid2(_)->false.


load_file(Filename)->
    {ok, Binary} = file:read_file(Filename),
    StringContent = unicode:characters_to_list(Binary),
    [ string:join(string:replace(Line, "\n", " ", all), "") || Line <- string:split(StringContent, "\n\n", all)].

mafinar · 6 December 2020 05:56

Today’s one was easiest so far.

github.com

code-shoily/advent_of_code/blob/master/lib/2020/day_6.ex

defmodule AdventOfCode.Y2020.Day6 do
  @moduledoc """
  Problem Link: https://adventofcode.com/2020/day/6
  """
  use AdventOfCode.Helpers.InputReader, year: 2020, day: 6

  def run_1, do: input!() |> process() |> Enum.map(&answers/1) |> Enum.sum()
  def run_2, do: input!() |> process() |> Enum.map(&unanimous_answers/1) |> Enum.sum()
  def run, do: {run_1(), run_2()}

  def process(input) do
    input
    |> String.split("\n")
    |> Enum.chunk_by(&(&1 == ""))
    |> Enum.reject(&(&1 == [""]))
  end

  defp answers(group) do
    group
    |> Enum.flat_map(&String.graphemes/1)

This file has been truncated. show original

Rainer · 6 December 2020 19:38

@mafinar
I put my solutions here:

I made some small changes to my solution of day 4 for better readability.
Still, overall it’s not in a state I’d show to public usually

Have to do some cleanup…
But I’m already 2 days behind, can’t keep up the pace.

mafinar · 7 December 2020 00:18

Thank you so much @Rainer

I was tempted to do yesterday’s one with Erlang. I am on chapter 7 on the Erlang book and soon will be able to participate in the book club with y’all. I will use your code to help with my Erlang learning because the AoC problems are fresh in my mind now, so right after I am done with a chapter, I’ll spend some time with your code. So again, thank you for this

jaeyson · 7 December 2020 03:00

Can we actually solve previous year’s AoC right? i havent started it since it’s first release. Are those the same challenges every year?

mafinar · 7 December 2020 05:00

Different years have different challenges, often based on a common theme, last year it was on a “virtual machine” implementation, this year, it seems to be all things air travel. I do solve problems from past years from time to time, but these 25 days are really more festive and making friends for me

Rainer · 7 December 2020 06:22

Day 5 was fun indeed
What was the “exploit” you mentioned?

I converted the code to a bitstring which can be converted to a number directly:

calc_seatid(SeatCode)->
    Bits = lists:map(fun(X) -> get_bit(X) end, SeatCode),
    list_to_integer(Bits, 2).

get_bit($F) -> $0;
get_bit($B) -> $1;
get_bit($L) -> $0;
get_bit($R) -> $1.

Full code:

github.com

raerkeer/AdventOfCode_2020_Erlang/blob/main/day5.erl

-module(day5).
-export([run/0]).

run()->
    SeatCodes = load_file("day5input.txt"),
    SeatIds = lists:map(fun(SeatCode) -> calc_seatid(SeatCode) end, SeatCodes),
    {part1(SeatIds), part2(SeatIds)}.

part1(SeatIds)->
    lists:max(SeatIds).

part2(SeatIds)->
    SortedIds = lists:sort(SeatIds),
    my_seat(SortedIds).

my_seat([X, Y | T])->
    case Y-X of
        1 -> my_seat([Y|T]);
        _ -> X+1
    end.

This file has been truncated. show original

/e: I noticed that I did one unnecessary step and updated my solution

mafinar · 7 December 2020 08:57

The “01” replacement thing, looks like you got it too. I did the recursion way, that did not occur to me at all! I should have got it when they talked about multiplication by 8 lol.

mafinar · 7 December 2020 08:59

Today’s one, the second part, took a long time for me, I kept on getting lost in pattern matching and recursion. Did a lot of trial and error on the sample inputs to get it right! (Had two iteration, each worked in one of the sample inputs but not the other :O)… also, I used :digraph

github.com

code-shoily/advent_of_code/blob/master/lib/2020/day_7.ex

defmodule AdventOfCode.Y2020.Day7 do
  @moduledoc """
  Problem Link: https://adventofcode.com/2020/day/7
  """
  use AdventOfCode.Helpers.InputReader, year: 2020, day: 7

  @mybag "shiny gold"

  def run_1, do: process() |> build_graph() |> sources()
  def run_2, do: bags(process(), @mybag) - 1
  def run, do: {run_1(), run_2()}

  def process(input \\ input!()) do
    input
    |> String.split("\n")
    |> Enum.map(&parse/1)
    |> Enum.into(%{})
  end

  defp parse(sentence) do

This file has been truncated. show original

Rainer · 7 December 2020 11:25

In my first solution I just parsed the file and split the seatcode directly into row- and column code, calculated each value, and then did row * 8 + col
Had to sleep until I got the idea that this step was completely unneeded

Rainer · 7 December 2020 20:32

Day 6 part 1 was indeed done very fast, I struggled a bit with part 2 because I didn’t know the functions I can use

github.com

raerkeer/AdventOfCode_2020_Erlang/blob/main/day6.erl

-module(day6).
-export([run/0]).

run()->
    Groups = load_file("day6input.txt"),
    {part1(Groups), part2(Groups)}.

part1(Groups) -> 
    GroupAnswers = lists:map(fun(Group) -> string:join(string:replace(Group, "\n", "", all), "") end, Groups),
    lists:sum(lists:map(fun(Group) -> sets:size(sets:from_list(Group)) end, GroupAnswers)).

part2(Groups)-> 
    L = lists:map(fun(Group) -> process_group(Group) end, Groups),
    lists:sum(L).

process_group(Group)->
    L1 = string:split(Group, "\n", all),
    L2 = lists:map(fun(PersonAnswer) -> sets:from_list(PersonAnswer) end, L1),
    sets:size(sets:intersection(L2)).

This file has been truncated. show original

Super short code, but still I’m missing the pipe operator |>

mafinar · 7 December 2020 20:49

How accustomed do you think you are with Erlang now? Was 6/1 faster because it was easy or you think you’re getting more comfortable with Erlang?

mafinar · 8 December 2020 06:49

Here’s the one from today. Used brute force for part 2 (let me know if you come up with a none brute force one).

github.com

code-shoily/advent_of_code/blob/master/lib/2020/day_8.ex

defmodule AdventOfCode.Y2020.Day8 do
  @moduledoc """
  Problem Link: https://adventofcode.com/2020/day/8
  """
  use AdventOfCode.Helpers.InputReader, year: 2020, day: 8

  def run_1, do: input!() |> process() |> exec() |> elem(1)
  def run_2, do: input!() |> process() |> fix()
  def run, do: {run_1(), run_2()}

  def process(input), do: Enum.map(String.split(input, "\n"), &parse/1)

  defp exec(prog), do: exec(prog, 0, 0, %{})
  defp exec(_, cur, acc, hist) when is_map_key(hist, cur), do: {:cont, acc}
  defp exec(prog, cur, acc, _) when cur >= length(prog), do: {:halt, acc}

  defp exec(prog, cur, acc, hist) do
    case Enum.at(prog, cur) do
      {:acc, val} -> exec(prog, cur + 1, acc + val, Map.put(hist, cur, true))
      {:nop, _} -> exec(prog, cur + 1, acc, Map.put(hist, cur, true))

This file has been truncated. show original

Rainer · 8 December 2020 07:28

It was quite easy as I knew instantly how I wantet to solve it, and of course I’m getting more used to Erlang, so I don’t have to look up everything. I really like Erlang so far I’m not experienced with Elixir, I just did some small hobby projects with Phoenix, and already it’s easier for me to read/write Erlang, just because of the time i spent with it.

I solved todays one by changing one instruction, test the code, then changing next instruction and test again, so quite brute force. No idea for some other solution.
Code’ll follow, wanna do some clean up first

Rainer · 8 December 2020 08:39

Today was fun

github.com

raerkeer/AdventOfCode_2020_Erlang/blob/main/day8.erl

-module(day8).
-export([run/0]).

run()->
    Instructions = load_file("day8input.txt"),
    {part1(Instructions, [], 0, 1), part2(Instructions, 1)}.

part1(Instructions, PositionsVisited, Acc, Pos)->
    case lists:member(Pos, PositionsVisited) of
        true -> {infiniteloop, Acc};
        false ->
            {Instr, Val} = lists:nth(Pos, Instructions),
            case Instr of
                "nop" -> part1(Instructions, [Pos | PositionsVisited], Acc, Pos + 1);
                "acc" -> part1(Instructions, [Pos | PositionsVisited], Acc + Val, Pos + 1);
                "jmp" -> part1(Instructions, [Pos | PositionsVisited], Acc, Pos + Val);
                endofcode -> {finished, Acc}
            end
        end.

This file has been truncated. show original