how do you know to do the bitwise NOT and then AND with 0b111111111111? I thought of negation using the NOT operator but it gives this crazy negative number. What’s that about?
stevensonmt
Aetherus
I noticed that for each bit in the binary numbers, if the majority is 1, then the minority is definitely 0, and vice versa. So if the corresponding bit in gamma is 1, then that bit in epsilon is definitely 0.
1
stevensonmt
No, I get that. I mean, why doesn’t the ~~~ operator work without the &&& 0b111111111111?
0
Aetherus
I added &&& 0b111111111111 just for safety. I don’t know how many bits does an integer contain by default, but probably more than 12 bits.
1
bjorng
Erlang Core Team
The ~~~ operator when given a positive number always returns a negative number. It does that simulate that an integer holds an infinite number of bits. If the number starts with an infinite number of ones, the number is negative. If it starts with an infinite number of zeroes, it is positive.
When I first learned Erlang, it took me a while to figure out why that’s make sense.
Yes, an infinite number of bits. Fortunately the runtime system is smart enough to not store all them explicitly. 
5
josevalim
Creator of Elixir
My solution: https://github.com/josevalim/aoc/blob/main/2021/day-03.livemd
Live streaming: Twitch - we also solved part 1 with Nx and had a bit of fun with Livebook. 
4
stefanluptak
Did you put that <!-- vim: syntax=markdown --> on top of your livemd file manualy or is that some setting in the Livebook?
0
josevalim
Creator of Elixir
stevensonmt
so negation in erlang flips all the infinite preceding zeroes? Is there a practical reason for that? Is it just to avoid the need for distinct sized integer types like u8, u16, i32, etc? Would you always get an accurate answer by masking with ones in all places up to the bitsize you need? Would it be safe to just mask by 4294967295 unless your values exceed u32 max size?
0
jazzyer
Sure we are at Day 4 now and nobody will read it, but still my solution for the Day 3, part one + tests.
Kind of ugly solution, but I was trying to use pattern matching as much as I can and was trying to avoid iteration all the way.
defmodule AOC_2021.Day3 do
@input "input_3.txt"
@initial_list_of_tuples [{"0", 0}, {"1", 0}]
@acc [
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples,
@initial_list_of_tuples
]
def part_one do
@input
|> read_file()
|> find_max_min_occ()
|> to_gamma_epsilon()
|> count()
end
defp find_max_min_occ(list_of_strings) do
Enum.reduce(
list_of_strings,
@acc,
fn <<first::binary-size(1)>> <>
<<second::binary-size(1)>> <>
<<third::binary-size(1)>> <>
<<fourth::binary-size(1)>> <>
<<fifth::binary-size(1)>> <>
<<six::binary-size(1)>> <>
<<seven::binary-size(1)>> <>
<<eight::binary-size(1)>> <>
<<nine::binary-size(1)>> <>
<<ten::binary-size(1)>> <>
<<eleven::binary-size(1)>> <>
<<twelve::binary-size(1)>>,
[
o,
t,
th,
fo,
fi,
si,
se,
ei,
ni,
te,
el,
tw
] ->
[
form_in_order(o, first),
form_in_order(t, second),
form_in_order(th, third),
form_in_order(fo, fourth),
form_in_order(fi, fifth),
form_in_order(si, six),
form_in_order(se, seven),
form_in_order(ei, eight),
form_in_order(ni, nine),
form_in_order(te, ten),
form_in_order(el, eleven),
form_in_order(tw, twelve)
]
end
)
end
defp form_in_order([{k1, v1}, {k2, v2}], item) when k1 == item do
t = [{k1, v1 + 1}, {k2, v2}]
[{k1, v1}, {k2, v2}] = t
if v1 > v2, do: [{k1, v1}, {k2, v2}], else: [{k2, v2}, {k1, v1}]
end
defp form_in_order([{k1, v1}, {k2, v2}], _item), do: [{k1, v1}, {k2, v2 + 1}]
defp to_gamma_epsilon(list_of_maps) do
Enum.reduce(list_of_maps, {"", ""}, fn [{k1, _}, {k2, _}], {gm, ep} ->
{gm <> k1, ep <> k2}
end)
end
defp count({gm, ep}) do
gm = Integer.parse(gm, 2) |> elem(0)
ep = Integer.parse(ep, 2) |> elem(0)
gm * ep
end
defp read_file(input) do
input
|> File.read!()
|> String.trim()
|> String.split(["\n"])
end
end
case System.argv() do
["--test"] ->
ExUnit.start()
defmodule AOC_2021.Day3Test do
use ExUnit.Case
@expected_part_one 3_901_196
test "tests" do
response = fn _ ->
[
AOC_2021.Day3.part_one()
]
end
assert [@expected_part_one] ==
response.(3_901_196)
end
end
["--run"] ->
AOC_2021.Day3.part_one()
|> IO.inspect(label: "\npart_one \n")
_ ->
IO.puts(:stderr, "\nplease specify --run or --test flag")
end
0