import AOC
aoc 2023, 4 do
def p1(input) do
input
|> winning_cards()
|> Enum.unzip()
|> elem(1)
|> Enum.map(fn 0 -> 0; n -> 2 ** (n-1) end)
|> Enum.sum()
end
def winning_cards(input) do
process = fn card -> card |> String.split(" ", trim: true) |> Enum.map(&String.to_integer/1) |> MapSet.new end
input
|> String.split("\n", trim: true)
|> Enum.map(
fn line ->
["Card " <> n, cards] = String.split(line, ": ")
card_strs = String.split(cards, "|")
[winning, holding] = card_strs |> Enum.map(process)
{String.to_integer(String.trim(n)), MapSet.intersection(winning, holding) |> Enum.count()}
end
)
end
def p2(input) do
input
|> winning_cards()
|> Enum.map(fn {i, n} -> {i, {1, n}} end)
|> process()
|> Enum.unzip()
|> elem(1)
|> Enum.unzip()
|> elem(0)
|> Enum.sum()
end
def process([]), do: []
def process([{i, {0, n}} = x | xs]), do: [x | process(xs)]
def process([{i, {count, multiplier}} = x | xs]) do
{before, after_} = Enum.split(xs, multiplier)
[x | process(Enum.map(before, fn {i, {c, n}} -> {i, {c + count, n}} end) ++ after_)]
end
end
rugyoga
1
lud
Here it is. It’s fun how we are mostly doing the same thing but nobody writes it the same.
defmodule AdventOfCode.Y23.Day4 do
alias AoC.Input, warn: false
def read_file(file, _part) do
Input.stream!(file, trim: true)
end
def parse_input(input, _part) do
input
|> Enum.map(fn "Card " <> rest ->
rest = String.trim_leading(rest)
{card_id, ": " <> rest} = Integer.parse(rest)
[winnings, playings] = String.split(rest, " | ")
winnings = list_of_ints(winnings)
playings = list_of_ints(playings)
{card_id, winnings, playings}
end)
end
defp list_of_ints(str) do
str |> String.split(" ", trim: true) |> Enum.map(&String.to_integer/1)
end
def part_one(problem) do
problem
|> Enum.map(fn {_, winnings, playings} ->
wins = MapSet.new(winnings)
plays = MapSet.new(playings)
pow = MapSet.size(MapSet.intersection(wins, plays))
trunc(:math.pow(2, pow - 1))
end)
|> Enum.sum()
end
def part_two(problem) do
problem
|> Enum.map_reduce(%{}, fn {card_id, winnings, playings}, acc ->
n_cards = 1 + Map.get(acc, card_id, 0)
wins = MapSet.new(winnings)
plays = MapSet.new(playings)
acc =
case MapSet.size(MapSet.intersection(wins, plays)) do
0 ->
acc
n_wins ->
adds = (card_id + 1)..(card_id + n_wins)
Enum.reduce(adds, acc, fn next_card_id, acc ->
Map.update(acc, next_card_id, n_cards, &(&1 + n_cards))
end)
end
{n_cards, acc}
end)
|> elem(0)
|> Enum.sum()
end
end
@Aetherus I just read your post and indeed there is no need to parse as integers. But with my code it is actually faster when I pay the cost to do it. Probably because it speeds up the matching in Map.get…
2
ChristopheBelpaire
My solution :
defmodule Scratchcards do
import NimbleParsec
defparsec(
:parse_line,
ignore(string("Card") |> repeat(ignore(string(" "))))
|> integer(min: 1, max: 3)
|> ignore(string(":"))
|> ignore(repeat(ignore(string(" "))))
|> tag(repeat(integer(min: 1, max: 2) |> repeat(ignore(string(" ")))), "numbers")
|> ignore(string("|"))
|> repeat(ignore(string(" ")))
|> tag(repeat(integer(min: 1, max: 2) |> repeat(ignore(string(" ")))), "winning")
)
defp points(0), do: 0
defp points(x), do: 2 ** (x - 1)
defp calculate_score(line) do
{:ok, [_, {"numbers", numbers}, {"winning", winning}], _, _, _, _} = parse_line(line)
MapSet.intersection(MapSet.new(numbers), MapSet.new(winning))
|> MapSet.to_list()
|> length()
end
def part1(input) do
input
|> String.split("\n")
|> Enum.map(fn line ->
line
|> calculate_score()
|> points()
end)
|> Enum.sum()
end
defp count(input, pos, total) do
score = Enum.at(input, pos)
if score > 0 do
Enum.reduce((pos + 1)..(pos + score), total, fn(i, total) ->
count(input, i, total + 1)
end)
else
total
end
end
def part2(input) do
scores = input
|> String.split("\n")
|> Enum.map(fn line ->
calculate_score(line)
end)
scores
|> Enum.with_index()
|> Enum.reduce(0, fn({_v, i}, total) ->
total + count(scores, i, 1)
end)
end
end
Scratchcards.part2(input)
2
hauleth
Parsing
cards =
puzzle_input
|> String.split("\n", trim: true)
|> Enum.map(fn "Card" <> rest ->
{id, ": " <> rest} = rest |> String.trim() |> Integer.parse()
[wins, inputs] =
rest
|> String.split(" | ")
|> Enum.map(fn part ->
part
|> String.split()
|> Enum.map(&String.to_integer/1)
end)
{id, wins, inputs}
end)
Part 1
cards
|> Enum.map(fn {_, wins, inputs} ->
matches = length(wins) - length(wins -- inputs)
if matches > 0, do: 2**(matches - 1), else: 0
end)
|> dbg()
|> Enum.sum()
Part 2
cards
|> Enum.reduce(%{}, fn {id, wins, inputs}, acc ->
matches = length(wins) - length(wins -- inputs)
{current, acc} = Map.get_and_update(acc, id, fn v ->
v = (v || 0) + 1
{v, v}
end)
Enum.reduce(1..matches//1, acc, &Map.update(&2, id + &1, current, fn a -> a + current end))
end)
|> Map.values()
|> Enum.sum()
2
Aetherus
trnasistor
My beginner’s solution, Day 4.
I had a lot of fun implementing a function using [tail | head] syntax. Is it idiomatic?
defmodule Day04 do
def part2(input) do
input
|> String.split("\n")
|> Enum.map(&parse_to_map_of_your_and_winning_numbers/1)
|> Enum.map(&amount_of_winning_numbers/1)
|> Enum.reverse
# [0, 0, 1, 2, 2, 4]
|> total_scratchcards
end
def part1(input) do
input
|> String.split("\n")
|> Enum.map(&parse_to_map_of_your_and_winning_numbers/1)
|> Enum.map(&amount_of_winning_numbers/1)
|> Enum.map(&calculate_worth/1)
|> Enum.sum
end
def parse_to_map_of_your_and_winning_numbers(line) do
# "Card 1: 41 48 83 86 17 | 83 86 6 31 17 9 48 53"
line
|> String.split(": ")
|> List.last
|> String.split(" | ")
|> Enum.map(fn x -> x
|> String.split
|> Enum.map(&String.to_integer/1)
end)
|> then(fn [w, y] -> %{your: y, winning: w} end)
# %{ winning: [41, 48, 83, 86, 17],
# your: [83, 86, 6, 31, 17, 9, 48, 53] }
end
def amount_of_winning_numbers(card) do
# %{ winning: [41, 48, 83, 86, 17],
# your: [83, 86, 6, 31, 17, 9, 48, 53] }
for your_number <- card.your do
Enum.member?(card.winning, your_number)
end
|> Enum.count(&(&1))
end
def calculate_worth(0), do: 0
def calculate_worth(n), do: :math.pow(2, n-1) |> round
def total_scratchcards(how_many_wins_list, scratchcards_amount_list \\ [])
def total_scratchcards([], amount_list), do: Enum.sum(amount_list)
def total_scratchcards([head | tail], amount_list) do
amount = amount_list
|> Enum.take(head)
|> Enum.sum
|> Kernel.+(1)
total_scratchcards(tail, [amount] ++ amount_list)
end
end
0
adamu
I was proud of my recursive copy function, until I saw @bjorng’s 
edit: tidied up enough to share. Both parts under a ms.
def part1(input) do
input
|> Enum.map(fn 0 -> 0; num_winners -> 2 ** (num_winners - 1) end)
|> Enum.sum()
end
def part2(input) do
input
|> Enum.map(fn num_winners -> {_num_copies = 1, num_winners} end)
|> copy()
|> Enum.sum()
end
def copy([]), do: []
def copy([{num_copies, num_winners} | rest]) do
{to_copy, left_alone} = Enum.split(rest, num_winners)
copied =
Enum.map(to_copy, fn {child_num_copies, num_winners} ->
{num_copies + child_num_copies, num_winners}
end)
[num_copies | copy(copied ++ left_alone)]
end
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2023/day4.exs
2
pehbehbeh
Solved part 2 with a single for reduce:
https://github.com/pehbehbeh/adventofcode/blob/main/2023/04.livemd
2
pesnk
For me it was the easier this year. quite fun to solve.
https://github.com/pedrosnk/coffee_and_kata/blob/main/aoc_2023/day_04/lib/day04.ex
1
code-shoily
Here is mine, I fell asleep last night, and solved it quite quickly, this should have been day 1 lol.
https://github.com/code-shoily/advent_of_code/blob/master/lib/2023/day_04.ex
Thank you @ChristopheBelpaire I am trying to grok parser combinators and your code cleared some concepts for me.
1