Use sum_by and product_by

Author: code-shoily

lib/2015/day_02.ex

@@ -22,17 +22,13 @@ defmodule AdventOfCode.Y2015.Day02 do
   end
 
   defp run_1(input) do
-    input
-    |> Enum.map(fn n -> n |> Enum.map(&String.to_integer/1) |> required_paper() end)
-    |> Enum.sum()
+    Enum.sum_by(input, fn n -> n |> Enum.map(&String.to_integer/1) |> required_paper() end)
   end
 
   defp run_2(input) do
-    input
-    |> Enum.map(fn n ->
-      n |> Enum.map(&String.to_integer/1) |> smallest_perimeter_plus_volume()
+    Enum.sum_by(input, fn n ->
+      Enum.map(n, &String.to_integer/1) |> smallest_perimeter_plus_volume()
     end)
-    |> Enum.reduce(&Kernel.+/2)
   end
 
   @spec required_paper([pos_integer(), ...]) :: pos_integer()

lib/2015/day_12.ex

@@ -45,8 +45,7 @@ defmodule AdventOfCode.Y2015.Day12 do
     parsed
     |> Enum.join()
     |> String.split()
-    |> Enum.map(&String.to_integer/1)
-    |> Enum.sum()
+    |> Enum.sum_by(&String.to_integer/1)
   end
 
   def total(obj) when is_map(obj) do
@@ -56,11 +55,10 @@ defmodule AdventOfCode.Y2015.Day12 do
 
   def total(obj) when is_list(obj) do
     obj
-    |> Enum.map(fn
+    |> Enum.sum_by(fn
       value when is_map(value) or is_list(value) -> total(value)
       value when is_integer(value) -> value
       _ -> 0
     end)
-    |> Enum.sum()
   end
 end

lib/2015/day_15.ex

@@ -76,8 +76,7 @@ defmodule AdventOfCode.Y2015.Day15 do
 
   def total_of(nutrients, type) do
     nutrients
-    |> Enum.map(& &1[type])
-    |> Enum.sum()
+    |> Enum.sum_by(& &1[type])
     |> then(&((&1 < 0 && 0) || &1))
   end
 

lib/2015/day_20.ex

@@ -39,8 +39,7 @@ defmodule AdventOfCode.Y2015.Day20 do
     gifts =
       house
       |> Arithmetics.divisors()
-      |> Enum.map(&(&1 * 10))
-      |> Enum.sum()
+      |> Enum.sum_by(&(&1 * 10))
 
     {house, gifts}
   end
@@ -50,8 +49,7 @@ defmodule AdventOfCode.Y2015.Day20 do
       house
       |> Arithmetics.divisors()
       |> Enum.filter(fn divisor -> div(house, divisor) < 50 end)
-      |> Enum.map(&(&1 * 11))
-      |> Enum.sum()
+      |> Enum.sum_by(&(&1 * 11))
 
     {house, gifts}
   end

lib/2017/day_01.ex

@@ -40,12 +40,10 @@ defmodule AdventOfCode.Y2017.Day01 do
   end
 
   defp matching_pair_sum({a, b}) do
-    a
-    |> Enum.zip(b)
-    |> Enum.map(fn
+    Enum.zip(a, b)
+    |> Enum.sum_by(fn
       {a, a} -> a + a
       _ -> 0
     end)
-    |> Enum.sum()
   end
 end

lib/2017/day_13.ex

@@ -59,7 +59,6 @@ defmodule AdventOfCode.Y2017.Day13 do
   defp severity(detections, input) do
     input
     |> Map.take(detections)
-    |> Enum.map(fn {k, v} -> k * v end)
-    |> Enum.sum()
+    |> Enum.sum_by(fn {k, v} -> k * v end)
   end
 end

lib/2017/day_14.ex

@@ -20,8 +20,7 @@ defmodule AdventOfCode.Y2017.Day14 do
 
   defp run_1(squares) do
     squares
-    |> Enum.map(&Enum.count(&1, fn i -> i == "1" end))
-    |> Enum.sum()
+    |> Enum.sum_by(&Enum.count(&1, fn i -> i == "1" end))
   end
 
   defp run_2(_squares) do

lib/2018/day_06.ex

@@ -95,8 +95,7 @@ defmodule AdventOfCode.Y2018.Day06 do
 
   defp within_distance_threshold(distances, threshold) do
     distances
-    |> Enum.map(&elem(&1, 1))
-    |> Enum.sum()
+    |> Enum.sum_by(&elem(&1, 1))
     |> case do
       n when n < threshold -> 1
       _ -> 0

lib/2019/day_01.ex

@@ -15,18 +15,15 @@ defmodule AdventOfCode.Y2019.Day01 do
   end
 
   def run_1(input) do
-    input
-    |> Enum.map(&fuel_required/1)
-    |> Enum.sum()
+    Enum.sum_by(input, &fuel_required/1)
   end
 
   def run_2(input) do
     input
-    |> Enum.map(fn mass ->
+    |> Enum.sum_by(fn mass ->
       required_fuel = fuel_required(mass)
       refuel(required_fuel, required_fuel)
     end)
-    |> Enum.sum()
   end
 
   def parse(data) do

lib/2020/day_14.ex

@@ -33,7 +33,7 @@ defmodule AdventOfCode.Y2020.Day14 do
     {Map.put(memory, address, (value ||| or_mask) &&& and_mask), masks}
   end
 
-  defp memory_sum({memory, _}), do: memory |> Enum.map(&elem(&1, 1)) |> Enum.sum()
+  defp memory_sum({memory, _}), do: memory |> Enum.sum_by(&elem(&1, 1))
 
   defp instruction_2("mask" <> _ = line, {memory, _}),
     do: {memory, line |> String.split(" = ") |> Enum.at(-1) |> String.graphemes()}

lib/2021/day_15.ex

@@ -23,8 +23,7 @@ defmodule AdventOfCode.Y2021.Day15 do
     |> to_graph()
     |> Graph.dijkstra({0, 0}, get_destination(grid))
     |> tl()
-    |> Enum.map(&Map.get(grid, &1))
-    |> Enum.sum()
+    |> Enum.sum_by(&Map.get(grid, &1))
   end
 
   def run_2(grid) do
@@ -34,8 +33,7 @@ defmodule AdventOfCode.Y2021.Day15 do
     |> to_graph()
     |> Graph.dijkstra({0, 0}, get_destination(grid))
     |> tl()
-    |> Enum.map(&Map.get(grid, &1))
-    |> Enum.sum()
+    |> Enum.sum_by(&Map.get(grid, &1))
   end
 
   def parse(input) do

lib/2022/day_13.ex

@@ -20,8 +20,7 @@ defmodule AdventOfCode.Y2022.Day13 do
     end)
     |> Enum.with_index(1)
     |> Enum.filter(fn {{x, y}, _} -> order(x, y) end)
-    |> Enum.map(&elem(&1, 1))
-    |> Enum.sum()
+    |> Enum.sum_by(&elem(&1, 1))
   end
 
   def run_2(input) do
@@ -33,8 +32,7 @@ defmodule AdventOfCode.Y2022.Day13 do
     |> Enum.sort_by(&Function.identity/1, &order/2)
     |> Enum.with_index(1)
     |> Enum.filter(fn {elem, _} -> elem in [[[2]], [[6]]] end)
-    |> Enum.map(&elem(&1, 1))
-    |> Enum.product()
+    |> Enum.product_by(&elem(&1, 1))
   end
 
   def order([], []), do: nil

lib/2023/day_09.ex

@@ -24,9 +24,7 @@ defmodule AdventOfCode.Y2023.Day09 do
 
   defp forward(data) do
     extrapolate(data, [data], fn acc ->
-      acc
-      |> Enum.map(&List.last/1)
-      |> Enum.sum()
+      Enum.sum_by(acc, &List.last/1)
     end)
   end
 

lib/2023/day_19.ex

@@ -65,12 +65,11 @@ defmodule AdventOfCode.Y2023.Day19 do
 
     Agent.get(agent, fn content ->
       content
-      |> Enum.map(fn steps ->
+      |> Enum.sum_by(fn steps ->
         steps
         |> Enum.reduce(Map.new(~w(x m a s), &{&1, 1..4000}), &range_reducer/2)
         |> Enum.reduce(1, &range_combination/2)
       end)
-      |> Enum.sum()
     end)
   end
 

lib/2023/day_25.ex

@@ -20,8 +20,7 @@ defmodule AdventOfCode.Y2023.Day25 do
     |> Enum.find(fn g1 -> cut_size(g1, input) == 3 end)
     |> Map.keys()
     |> Enum.map(&String.length/1)
-    |> Enum.map(&div(&1, 3))
-    |> Enum.product()
+    |> Enum.product_by(&div(&1, 3))
   end
 
   defp run_2(_), do: "🎉"

lib/2024/day_05.ex

@@ -18,15 +18,13 @@ defmodule AdventOfCode.Y2024.Day05 do
   defp run_1(input) do
     input
     |> Enum.filter(fn {a, b} -> a == b end)
-    |> Enum.map(fn {a, _} -> a |> Enum.at(div(length(a), 2)) end)
-    |> Enum.sum()
+    |> Enum.sum_by(fn {a, _} -> a |> Enum.at(div(length(a), 2)) end)
   end
 
   defp run_2(input) do
     input
     |> Enum.filter(fn {a, b} -> a != b end)
-    |> Enum.map(fn {_, b} -> b |> Enum.at(div(length(b), 2)) end)
-    |> Enum.sum()
+    |> Enum.sum_by(fn {_, b} -> b |> Enum.at(div(length(b), 2)) end)
   end
 
   def parse(data \\ input()) do

lib/algorithms/chinese_remainder.ex

@@ -34,8 +34,7 @@ defmodule AdventOfCode.Algorithms.ChineseRemainder do
           |> Enum.zip(inverses)
           |> Enum.map(&Tuple.product/1)
         )
-        |> Enum.map(&Tuple.product/1)
-        |> Enum.sum()
+        |> Enum.sum_by(&Tuple.product/1)
         |> mod(mod_pi)
     end
   end

lib/helpers/meta.ex

@@ -47,8 +47,7 @@ defmodule AdventOfCode.Helpers.Meta do
 
     stars_completed =
       daywise_summary
-      |> Enum.map(fn {_, %{count: count}} -> count end)
-      |> Enum.sum()
+      |> Enum.sum_by(fn {_, %{count: count}} -> count end)
 
     tag_summary = daywise_summary |> group_by_tags()
     difficulty_summary = daywise_summary |> group_by_difficulty()

lib/helpers/summarizer.ex

@@ -16,7 +16,7 @@ defmodule AdventOfCode.Helpers.Summarizer do
     metadata = Map.new(@year_range, &{&1, Meta.get_info(&1, true)})
 
     stars_completed =
-      Enum.map(metadata, fn {_, %{completed: completed}} -> completed end) |> Enum.sum()
+      Enum.sum_by(metadata, fn {_, %{completed: completed}} -> completed end)
 
     problems_solved = stars_completed / 2