Yet another function in Enum I didn’t know 
Aetherus
stevensonmt
In comparison of A1 + A2 + A3 and B1 + B2 + B3 you really only compare A1 and B3 b/c A2 == B1 and A3 == B2. I think that counts as “non brute force”.
6
Aetherus
Nice point. Based on your suggestion, I reimplemented part 2:
#!/usr/bin/env elixir
File.stream!("input.txt")
|> Stream.map(&String.trim/1)
|> Stream.map(&String.to_integer/1)
|> Stream.chunk_every(4, 1, :discard) # <-- Now the window size is 4
|> Enum.count(fn [a, _, _, d] -> a < d end) # <-- and just compare the first and last elements in each window
|> IO.inspect()
No sum at all.
5
code-shoily
Hallski
Hi again, great to see everyone for another year of AoC!
Haven’t been coding Elixir in a while so was a bit rusty but ended up with a similar solution. However I didn’t come to think about using chunk_every for the first chunking and instead did a l |> Enum.zip(Enum.drop(l, 1)), will try to internalise that 
def run1(data) do
parse_input(data)
|> sum_increases()
end
def run2(data) do
parse_input(data)
|> Enum.chunk_every(3, 1, :discard)
|> Enum.map(fn l -> Enum.sum(l) end)
|> sum_increases()
end
defp parse_input(data) do
data
|> String.trim()
|> String.split()
|> Enum.map(&String.to_integer/1)
end
defp sum_increases(numbers) do
numbers
|> Enum.zip(Enum.drop(numbers, 1))
|> Enum.map(fn {last, current} -> if current > last, do: :increased, else: :decreased end)
|> Enum.filter(fn i -> i == :increased end)
|> Enum.count()
end
3
dallagi
Unfortunately it looks like the leaderboard is now full 
Anyway, yet another solution using chunk_every:
defmodule Aoc2021.Day1 do
def part1(input) do
input
|> parse()
|> sliding_windows(2)
|> Enum.count(fn [prev, curr] -> curr > prev end)
end
def part2(input) do
input
|> parse()
|> sliding_windows(3)
|> Enum.map(&Enum.sum/1)
|> sliding_windows(2)
|> Enum.count(fn [prev, curr] -> curr > prev end)
end
defp parse(input) do
input
|> String.split()
|> Enum.map(&String.to_integer/1)
end
defp sliding_windows(enumerable, size), do: Enum.chunk_every(enumerable, size, 1, :discard)
end
1
Aetherus
There’s a private leaderboard at the top of this topic. I don’t know if there’s a member limit on each private leaderboard.
1
bjorng
Erlang Core Team
That private leaderboard has been used for several years and the limit of 200 users has been reached. I have posted the link and code for a new private leaderboard.
2
Aetherus
everte
Hmm, my non-optimal solution. First one here to use Enum.with_index 
. Probably not a good sign!
def parse_input(input) do
input
|> Enum.map(fn x -> String.to_integer(x) end)
|> IO.inspect
end
def find_increased_number_count(numbers) do
Enum.reduce(numbers, {:infinity, 0}, fn x, {prev, count} ->
case x > prev do
true -> {x, count + 1}
false -> {x, count}
end
end)
end
def creaete_sliding_windows(numbers) do
Enum.with_index(numbers)
|> Enum.map(fn {number, index} -> number + Enum.at(numbers, index + 1, 0) + Enum.at(numbers, index + 2, 0) end)
|> IO.inspect
end
1