My solution which uses the fact that searching for a + b + c == 2020 is the same as searching for b + c == 2020 - a and the fact that a + b == b + a and a * b == b * a, which mean that [a, …, b] will return the same result as [b, …, a] (in other words, if we didn’t found the solution for earlier elements in list, we never need to look at them anymore):
defmodule Solution do
def read_input(path) do
path
|> File.stream!()
|> Stream.map(&String.to_integer(String.trim(&1)))
|> Enum.to_list()
end
def run([], _, _), do: nil
def run(_, _, sum) when sum < 0, do: nil
def run([a | _], 1, a), do: [a]
def run([a | rest], n, sum) do
case run(rest, n - 1, sum - a) do
nil -> run(rest, n, sum)
nums when is_list(nums) -> [a | nums]
end
end
end
list = Solution.read_input("input.txt")
list
|> Solution.run(2, 2020)
|> Enum.reduce(&*/2)
|> IO.inspect(label: "task 1")
list
|> Solution.run(3, 2020)
|> Enum.reduce(&*/2)
|> IO.inspect(label: "task 2")
Oh, this is also generic solution for any amount of elements that need to sum to given value.
I have benched against @LostKobrakai code and this is result:
Operating System: macOS
CPU Information: Intel(R) Core(TM) i5-1038NG7 CPU @ 2.00GHz
Number of Available Cores: 8
Available memory: 32 GB
Elixir 1.11.2
Erlang 22.3
Benchmark suite executing with the following configuration:
warmup: 2 s
time: 5 s
memory time: 0 ns
parallel: 1
inputs: none specified
Estimated total run time: 21 s
Benchmarking first solution...
Benchmarking mine...
Benchmarking optimized...
Name ips average deviation median 99th %
mine 3.92 K 254.84 μs ±7.99% 251.98 μs 348.98 μs
optimized 3.68 K 271.99 μs ±10.21% 266.98 μs 397.98 μs
first solution 0.0200 K 49956.44 μs ±12.46% 48000.98 μs 70571.10 μs
Comparison:
mine 3.92 K
optimized 3.68 K - 1.07x slower +17.15 μs
first solution 0.0200 K - 196.03x slower +49701.60 μs
