jack's advent of code 2022 ramblings

given the sample strategy guide:

A Y
B X
C Z

assuming input is the above as one big string,

input =
  input
  |> String.trim()
  |> String.split("\n")
  |> Enum.map(&String.split(&1, " "))

the usual input trim / split, but this time splitting each line itself by an empty string

[
    ["A", "Y"],
    ["B", "X"],
    ["C", "Z"]
]

leaving us with a list of lists yet again

defmodule RockPaperScissors do
  def score(them, you) do
    choice_score =
      case you do
        :rock -> 1
        :paper -> 2
        :scissors -> 3
      end

    game_score =
      case {you, them} do
        {you, you} -> 3
        {:rock, :paper} -> 0
        {:rock, :scissors} -> 6
        {:paper, :scissors} -> 0
        {:paper, :rock} -> 6
        {:scissors, :rock} -> 0
        {:scissors, :paper} -> 6
      end

    choice_score + game_score
  end

  def pick_then_score(them, wanted_result) do
    case {them, wanted_result} do
      {x, :draw} -> score(them, x)
      {:rock, :win} -> score(them, :paper)
      {:rock, :throw} -> score(them, :scissors)
      {:paper, :win} -> score(them, :scissors)
      {:paper, :throw} -> score(them, :rock)
      {:scissors, :win} -> score(them, :rock)
      {:scissors, :throw} -> score(them, :paper)
    end
  end
end

creating a module for the first time this year, to

• calculate score, using score/2, which takes in a ‘game’ (choice from us, and choice from enemy), and returns the score from that game we receive

score/2

choice_score =
  case you do
    :rock -> 1
    :paper -> 2
    :scissors -> 3
  end

using pattern matching, get the score we get from simply picking an option

game_score =
  case {you, them} do
    {you, you} -> 3
    {:rock, :paper} -> 0
    {:rock, :scissors} -> 6
    {:paper, :scissors} -> 0
    {:paper, :rock} -> 6
    {:scissors, :rock} -> 0
    {:scissors, :paper} -> 6
  end

using pattern matching again, to figure out what we actually from winning / losing, using a sneaky pattern matching trick for handling the draw case

choice_score + game_score

then, returning a value

big stuff

pick_then_score/2

case {them, wanted_result} do
  {x, :draw} -> score(them, x)
  {:rock, :win} -> score(them, :paper)
  {:rock, :throw} -> score(them, :scissors)
  {:paper, :win} -> score(them, :scissors)
  {:paper, :throw} -> score(them, :rock)
  {:scissors, :win} -> score(them, :rock)
  {:scissors, :throw} -> score(them, :paper)
end

for this util, we take in what we know they picked, and the result we wish the game to end up in, and do yet another pattern match, with some more sneaky logic for the draw case, using score/2 to calculate the score of our very legit game

part 1

assumed_guide = %{
  "A" => :rock,
  "B" => :paper,
  "C" => :scissors,
  "X" => :rock,
  "Y" => :paper,
  "Z" => :scissors
}

for part 1, i assume i have the ‘assumed guide’ from the elf, which maps the input from string -> atom, so the rest of my program can use atoms instead of strings

input
|> Enum.map(fn [them, you] ->
  RockPaperScissors.score(
    assumed_guide[them],
    assumed_guide[you]
  )
end)
|> Enum.sum()
# -> 15

map over the already cleaned up input, pluck out the left and right values into variables, and stuff them into score/2

sum that, and boom, answer

part 2

actual_guide = %{
  "A" => :rock,
  "B" => :paper,
  "C" => :scissors,
  "X" => :throw,
  "Y" => :draw,
  "Z" => :win
}

this is a similar map to the one above, but the actual guide from the elf, no silly stuff this time

input
|> Enum.map(fn [them, you] ->
  RockPaperScissors.pick_then_score(
    actual_guide[them],
    actual_guide[you]
  )
end)
|> Enum.sum()
# -> 12

same as above, yet again, but we use pick_then_score, because we are legit rock paper scissor gamers

the full solution can be found [here]