Like others, I pre-computed the value for each combination
https://github.com/ed-flanagan/advent-of-code-solutions-elixir/blob/main/lib/advent/y2022/d02.ex
deadbeef
stefanluptak
I am still trying to go with the least amount of premature optimization.
1
adamu
I went for “be very explicit” on this one 
defp play({:rock, :rock}), do: @rock + @draw
defp play({:paper, :rock}), do: @rock + @lose
defp play({:scissors, :rock}), do: @rock + @win
defp play({:rock, :paper}), do: @paper + @win
defp play({:paper, :paper}), do: @paper + @draw
defp play({:scissors, :paper}), do: @paper + @lose
defp play({:rock, :scissors}), do: @scissors + @lose
defp play({:paper, :scissors}), do: @scissors + @win
defp play({:scissors, :scissors}), do: @scissors + @draw
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2022/day2.exs
4
Aetherus
Seems we all take a similar path, so I won’t post my full code here. There’s something interesting though.
- For each round I get a score from 1 to 9.
- For each score, there’s exactly one case that I can get that score.
I feel there has to be something mathematical, just that I can’t find. I tried rearanging the cases, like this:
# A = Rock = 1
# B = Paper = 2
# C = Scissors = 3
# X = Rock = 1
# Y = Paper = 2
# Z = Scissors = 3
defp score1("B X"), do: 1
defp score1("C Y"), do: 2
defp score1("A Z"), do: 3
defp score1("A X"), do: 4
defp score1("B Y"), do: 5
defp score1("C Z"), do: 6
defp score1("C X"), do: 7
defp score1("A Y"), do: 8
defp score1("B Z"), do: 9
# A = Rock = 1
# B = Paper = 2
# C = Scissors = 3
# X = Lose = 0
# Y = Draw = 3
# Z = Win = 6
defp score2("B X"), do: 1
defp score2("C X"), do: 2
defp score2("A X"), do: 3
defp score2("A Y"), do: 4
defp score2("B Y"), do: 5
defp score2("C Y"), do: 6
defp score2("C Z"), do: 7
defp score2("A Z"), do: 8
defp score2("B Z"), do: 9
yet I still can’t find anything.
2
kwando
One of my colleagues came up with something completely different which I thought was interesting:
(This is translated from python to elixir)
File.stream!("/Users/kwando/projects/AoC2022/02/input.txt")
|> Stream.map(fn line -> String.trim(line) |> String.to_charlist() end)
|> Enum.reduce(0, fn [elf, _, you], score ->
shape_score = you - ?X + 1
case {elf - ?A, you - ?X} do
{any, any} ->
score + 3 + shape_score
{elf, you} when rem(you + 2, 3) == elf ->
score + 6 + shape_score
{_, _} ->
score + shape_score
end
end)
https://github.com/nilskj/AdventOfCode2022/blob/master/day02a.py
6
weeksseth
Nice! I suspected you could use modulo arithmetic for the cycle, but my brain was basically mush at midnight. Thanks for sharing!
3
hst337
Day 2 is nice for binary matching too
defmodule AOC do
def traverse(string, score \\ 0) do
case string do
<<his, " ", result, "\n", tail :: binary>> ->
his = his - ?A + 1
result = result - ?X + 1
traverse(tail, score + win_score(his, result))
"" ->
score
<<_, tail :: binary>> ->
traverse(tail, score)
end
end
def win_score(his, 2), do: 3 + his
def win_score(1, 1), do: 3
def win_score(2, 1), do: 1
def win_score(3, 1), do: 2
def win_score(1, 3), do: 2 + 6
def win_score(2, 3), do: 3 + 6
def win_score(3, 3), do: 1 + 6
end
IO.inspect AOC.traverse IO.read :eof
2
bmitc
Here’s my solution in a Livebook notebook: advent-of-code/2022/elixir/advent_of_code_2022.livemd at main · bmitc/advent-of-code · GitHub
I go full-on domain-driven design with custom types, typespecs, documentation, and even tests, so I’m only posting part two of day 2.
defmodule Day2.PartTwo do
@moduledoc """
Solution to Day 2 Part Two
"""
@typedoc """
Represents a move in the game of rock, paper, scissors
"""
@type move() :: :rock | :paper | :scissors
@typedoc """
Represents the result of a single round of rock, paper, scissors
"""
@type result() :: :win | :lose | :draw
@typedoc """
Represents a single round of the game rock, paper, scissors
"""
@type round() :: %{
opponent: move(),
response: move()
}
@typedoc """
Represents a strategy for a single round of the game rock, paper, scissors
"""
@type round_strategy() :: %{
opponent: move(),
expected_result: result()
}
@doc """
Parses a move consisting of "A", "B", "C", "X", "Y", "Z" into the corresponding
move of `:rock`, `:paper`, or `:scissors`
"""
@spec parse_move(String.t()) :: move()
def parse_move(move) do
case move do
"A" -> :rock
"B" -> :paper
"C" -> :scissors
end
end
@doc """
Parses an expected result consisting of "X", "Y", or "Z" into the corresponding
result of `:win`, `:lose`, or `:draw`
"""
@spec parse_expected_result(String.t()) :: result()
def parse_expected_result(move) do
case move do
"X" -> :lose
"Y" -> :draw
"Z" -> :win
end
end
@doc """
List of all round stategies
"""
@spec round_strategies() :: [round_strategy()]
def round_strategies() do
Utilities.readDataStream(2)
|> Stream.map(fn <<opponent::bytes-size(1)>> <> " " <> expected_result ->
%{
opponent: parse_move(opponent),
expected_result: parse_expected_result(expected_result)
}
end)
|> Enum.to_list()
end
@doc """
Judge the given round to determine if it is a win, loss, or draw for the player
"""
@spec judge_round(round()) :: result()
def judge_round(%{opponent: opponent, response: response}) do
case {opponent, response} do
{:rock, :rock} -> :draw
{:rock, :paper} -> :win
{:rock, :scissors} -> :lose
{:paper, :rock} -> :lose
{:paper, :paper} -> :draw
{:paper, :scissors} -> :win
{:scissors, :rock} -> :win
{:scissors, :paper} -> :lose
{:scissors, :scissors} -> :draw
end
end
@doc """
Score the round according to the given rubric that calculates a score based upon the
reponse alone plus a score from the round's result
"""
@spec score_round(round()) :: pos_integer()
def score_round(%{opponent: _, response: response} = round) do
response_score =
case response do
:rock -> 1
:paper -> 2
:scissors -> 3
end
outcome_score =
case judge_round(round) do
:win -> 6
:lose -> 0
:draw -> 3
end
response_score + outcome_score
end
@doc """
Convert a strategy to a round by computing which move is required to respond to
the opponent to guarantee the expected result
"""
@spec convert_strategy_to_round(round_strategy()) :: round()
def convert_strategy_to_round(round_strategy) do
response =
case {round_strategy.opponent, round_strategy.expected_result} do
{:rock, :win} -> :paper
{:rock, :lose} -> :scissors
{:paper, :win} -> :scissors
{:paper, :lose} -> :rock
{:scissors, :win} -> :rock
{:scissors, :lose} -> :paper
{move, :draw} -> move
end
%{opponent: round_strategy.opponent, response: response}
end
@doc """
A list of all the rounds' scores
"""
@spec scored_rounds_with_strategy() :: [pos_integer()]
def scored_rounds_with_strategy() do
round_strategies()
|> Enum.map(&convert_strategy_to_round/1)
|> Enum.map(&score_round/1)
end
def solution(), do: scored_rounds_with_strategy() |> Enum.sum()
end
2
srowley
I kind of wish there was an Enum.sum/2 that took a function and accumulated the totals from applying that function in one pass. Obviously you can just reduce instead to accomplish that, but it is less readable.
I say this because today and yesterday I made an effort to sum in one pass just to practice, and it saddens me when I see how much cleaner the alternative is.
2
adolfont
Lots of good answers. Nothing special here pensandoemelixir/adventofcode/2022/day02_2022/day2.exs at main · adolfont/pensandoemelixir · GitHub
0