Thanks a lot. I too missed the fact, that I have to recompute the frequency map for each iteration. 
stefanluptak
2
egze
0x76
Here is my solution: https://git.xirion.net/0x76/aoc2021/src/branch/main/lib/day03.ex
I tried my hand at using Nx for part 1 but I didn’t know to effectively use it for the filter part of part 2
1
wasi0013
APB9785
Creator of ECSx
My solution basically revolves around
defp count_ones_per_index(tuple, counts) do
Enum.reduce(0..11, counts, fn idx, acc ->
Map.update!(acc, idx, &(&1 + elem(tuple, idx)))
end)
end
1
Klohto
Livebook again 
I don’t know why I keep working just with anonymous functions but it was kinda fun (pun intended).
Turns out that anonymous functions don’t support recursion but I found José mentioning Elixir will support it in the future (2014). Does anyone know what happened? I hacked around it using by passing fun.
Somehow my Part 2 ended much shorter than Part 1. Mostly thanks to pattern matching and the recursion logic.
As always, just copy the code and you can import it directly into the Livebook 
# Day 2
## Input
<!-- livebook:{"livebook_object":"cell_input","name":"input","type":"text","value":"00100 11110 10110 10111 10101 01111 00111 11100 10000 11001 00010 01010"} -->
```elixir
processed =
IO.gets(:input)
|> String.split(~r{\s}, trim: true)
```
## Part 1
```elixir
# helpers
ind_len = String.length(Enum.at(processed, 0))
convert = fn data_list -> Enum.join(data_list) |> String.to_integer(2) end
###
gamma =
processed
|> Enum.reduce(
List.duplicate(0, ind_len),
fn bits, stats ->
bits
|> String.graphemes()
|> Enum.with_index()
|> Enum.map(fn {c, index} ->
Enum.at(stats, index) + String.to_integer(c)
end)
end
)
|> Enum.map(fn n_ones ->
if n_ones > div(length(processed), 2), do: 1, else: 0
end)
|> convert.()
epsilon =
gamma
|> Bitwise.~~~()
|> Bitwise.&&&(String.duplicate("1", ind_len) |> String.to_integer(2))
gamma * epsilon
```
## Part 2
```elixir
# helpers
convert = fn data -> Enum.join(data) |> String.to_integer(2) end
###
converted_entries =
processed
|> Enum.map(fn bits ->
String.graphemes(bits) |> Enum.map(&String.to_integer/1)
end)
# Expects:
# list -> list of split converted bits eq.: [[0,1,0],[1,0,1]]
# index -> starting index eq.: 0
# sorter -> which value takes precendence when comparing eq.: &>/2
b_reduce = fn list, index, sorter ->
Enum.group_by(list, &Enum.at(&1, index))
|> Enum.max_by(fn {_k, v} -> length(v) end, sorter)
|> elem(1)
end
slvr = fn
[final], _, _, _ -> convert.(final)
list, i, sorter, fun -> b_reduce.(list, i, sorter) |> fun.(i + 1, sorter, fun)
end
slvr.(converted_entries, 0, &>/2, slvr) * slvr.(converted_entries, 0, &<=/2, slvr)
```
1
hauleth
AFAIK Core lost interest in it as the use case for that was mostly the shell and in IEx you can generate modules on the fly, which is not easily doable in Erlang Shell. However if you want to achieve the same thing, then you can use power of macros for that:
defmodule Foo do
defmacro fn_rec(do: body) do
{name, argc, body} =
body
|> Enum.map(fn
{:'->', e1, [[{:when, e2, [{name, _, args}, guard]}], body]} ->
{name, length(args), {:'->', e1, [[{:when, e2, args ++ [guard]}], body]}}
{:'->', e1, [[{name, _, args}], body]} ->
{name, length(args), {:'->', e1, [args, body]}}
end)
|> Enum.reduce(fn {name, argc, body}, {name, argc, acc} ->
{name, argc, List.wrap(acc) ++ [body]}
end)
args = Macro.generate_arguments(argc, __CALLER__.module)
func = {:fn, [], body}
name = {name, [], Elixir}
quote do
tmp =
fn f ->
var!(unquote(name)) = fn unquote_splicing(args) -> f.(f).(unquote_splicing(args)) end
unquote(func)
end
tmp.(tmp)
end
end
def run do
ack =
fn_rec do
a(0, n) -> n + 1
a(m, 0) -> a.(m - 1, 1)
a(m, n) -> a.(m - 1, a.(m, n - 1))
end
ack.(3, 4)
end
end
IO.puts Foo.run
2
epilgrim
And mine.
Part 2 revolves around
def group_by_position(matrix, position) do
Enum.group_by(
matrix,
fn row -> Enum.at(row, position) end
)
end
def find_most_common([row], _, _) do
row
end
def find_most_common(matrix, position, sorter) do
grouped = group_by_position(matrix, position)
{_, max_matrix} = Enum.max_by(grouped, fn {k, v} -> {length(v), k} end, sorter)
find_most_common(max_matrix, position + 1, sorter)
end
and then called as
oxigen_generator_rating =
Support.input()
|> Support.find_most_common(:gte)
|> Support.row_to_number()
co2_scrubber_rating =
Support.input()
|> Support.find_most_common(:lte)
|> Support.row_to_number()
2
kokolegorille
Late to the party…
defmodule Day3 do
def part1 do
frequencies = load_data()
|> reshape()
|> to_frequencies()
gamma_rate = get_rate(frequencies, &most_common_reducer/2)
epsilon_rate = get_rate(frequencies, &least_common_reducer/2)
gamma_rate * epsilon_rate
end
def part2 do
oxygen_generator_rating = filter_and_pop(load_data(), <<>>, :most)
co2_scrubber_rating = filter_and_pop(load_data(), <<>>, :least)
oxygen_generator_rating * co2_scrubber_rating
end
defp filter_and_pop([el], result, _mode) do
String.to_integer(result <> el, 2)
end
defp filter_and_pop(list, result, mode) do
freq = first_position_frequencies(list)
{zero, one} = {freq["0"], freq["1"]}
char = case mode do
:most -> if zero > one, do: "0", else: "1"
:least -> if zero <= one, do: "0", else: "1"
end
popped = list
|> Enum.filter(&String.starts_with?(&1, char))
|> Enum.map(fn <<_::utf8, rest::binary>> -> rest end)
filter_and_pop(popped, result <> char, mode)
end
defp first_position_frequencies(list) do
list
|> Enum.map(&String.first(&1))
|> Enum.frequencies()
end
def load_data do
"input.txt"
|> File.read!()
|> String.split("\n", trim: true)
end
defp reshape([h|_] = list) do
initial = List.duplicate(<<>>, String.length(h))
Enum.reduce(list, initial, fn x, acc ->
record = String.split(x, "", trim: true)
acc
|> Enum.zip(record)
|> Enum.map(fn {full, add} ->
full <> add
end)
end)
end
defp to_frequencies(list) when is_list(list),
do: Enum.map(list, &to_frequency(&1))
defp to_frequency(string) when is_binary(string) do
string
|> String.split("", trim: true)
|> Enum.frequencies()
end
def get_rate(frequencies, reducer) do
frequencies
|> Enum.reduce(<<>>, reducer)
|> String.to_integer(2)
end
defp most_common_reducer(%{"0"=>zero, "1"=>one}, acc),
do: if zero > one, do: acc <> "0", else: acc <> "1"
defp least_common_reducer(%{"0"=>zero, "1"=>one}, acc),
do: if zero < one, do: acc <> "0", else: acc <> "1"
end
1
srowley
I wanted to keep it pipeline-y. I feel like there has to be a way to do something similar in one pass, but I couldn’t figure it out before Day 4.
# Part 1
"day3.txt"
|> File.stream!
|> Enum.map(fn line -> String.split(line, "", trim: true) end)
|> Enum.zip_with(&Enum.frequencies/1)
|> Enum.map(fn counts -> if counts["0"] > counts["1"], do: ["0", "1"], else: ["1", "0"] end)
|> Enum.zip_with(&Enum.join/1)
|> Enum.reduce(1, fn number, product -> String.to_integer(number, 2) * product end)
# Part 2
defmodule Day3 do
def input() do
"day3.txt"
|> File.stream!
|> Enum.map(&String.trim/1)
end
def oxygen([final_value], _position) do
String.to_integer(final_value, 2)
end
def oxygen(data, position) do
data
|> Enum.group_by(fn num -> String.at(num, position) end)
|> Enum.max_by(&number_sorter/1)
|> elem(1)
|> oxygen(position + 1)
end
def carbon([final_value], _position) do
String.to_integer(final_value, 2)
end
def carbon(data, position) do
data
|> Enum.group_by(fn num -> String.at(num, position) end)
|> Enum.min_by(&number_sorter/1)
|> elem(1)
|> carbon(position + 1)
end
defp number_sorter({target_bit, bit_list}) do
length(bit_list) + 0.1 * String.to_integer(target_bit)
end
end
data = Day3.input()
Day3.oxygen(data, 0) * Day3.carbon(data, 0)
1