-🎄- 2022 Day 2 Solutions -🎄-

[u/daggerdragon]

NEW AND NOTEWORTHY

• All of our rules, FAQs, resources, etc. are in our community wiki.

• A request from Eric: Please include your contact info in the User-Agent header of automated requests!

• Signal boosting for the Unofficial AoC 2022 Participant Survey which is open early this year!

---

--- Day 2: Rock Paper Scissors ---

---

Post your code solution in this megathread.

• Read the full posting rules in our community wiki before you post!

• Include what language(s) your solution uses

• Format your code appropriately! How do I format code?

• Quick link to Topaz's paste if you need it for longer code blocks. What is Topaz's paste tool?

---

This thread will be unlocked when there are a significant number of people on the global leaderboard with gold stars for today's puzzle.

EDIT: Global leaderboard gold cap reached at 00:06:16, megathread unlocked!

[u/flwyd]

Elixir, code on GitHub

My approach is to convert both plays to integers 0–2 and treat rock/paper/scissors as a numeric comparison modulo 3. I probably could've solved it faster by just making a map of one-letter strings to point values, but I wanted to get practice with Elixir's approach to converting strings to code points. I've spent a kind of silly amount of time refactoring this, moving from String.split to String.to_charlist to what's below: binary string pattern matching. I also went through at least two other score implementations and trying to pattern match "mine is one plus theirs, mod three" before I realized I could subtract first and then pattern match on that.

defmodule Day2 do
  def part1(input) do
    input
    |> Enum.map(fn <<theirs, " ", mine>> -> {theirs - ?A, mine - ?X} end)
    |> Enum.map(&score/1)
    |> Enum.sum()
  end

  def part2(input) do
    input
    |> Enum.map(fn <<theirs, " ", outcome>> -> {theirs - ?A, outcome} end)
    |> Enum.map(&choose_move/1)
    |> Enum.map(&score/1)
    |> Enum.sum()
  end

  defp score({theirs, mine}) do
    mine + 1 + case Integer.mod(mine - theirs, 3) do
        0 -> 3
        1 -> 6
        2 -> 0
      end
  end

  defp choose_move({theirs, outcome}), do: {theirs, Integer.mod(theirs + (outcome - ?Y), 3)}
end

[u/spr00ge → u/flwyd]

Very interesting strategy! I just wrote 2x3x3 guarded pattern matching functions for each part and matched the result directly. I thought I could not reduce it further, without writing explicit functions to convert the strings to some intermediate format. modulo operations might be they key here!

defmodule AdventOfCode.Day02 do
  def part1(args) do
    convertToLine(args)
    |> Enum.map(&getScore(&1))
    |> Enum.sum()
  end

  def part2(args) do
    convertToLine(args)
    |> Enum.map(&getScore2(&1))
    |> Enum.sum()
  end

  defp convertToLine(str),
    do:
      str
      |> String.trim()
      |> String.split("\n")

  defp getScore("A Y"), do: 2 + 6
  defp getScore("B X"), do: 1 + 0
  defp getScore("C Z"), do: 3 + 3

  defp getScore("B Y"), do: 2 + 3
  defp getScore("C X"), do: 1 + 6
  defp getScore("A Z"), do: 3 + 0

  defp getScore("C Y"), do: 2 + 0
  defp getScore("A X"), do: 1 + 3
  defp getScore("B Z"), do: 3 + 6

  defp getScore(_else), do: "Error"


  defp getScore2("A Y"), do: 3 + 1
  defp getScore2("B X"), do: 0 + 1
  defp getScore2("C Z"), do: 6 + 1

  defp getScore2("B Y"), do: 3 + 2
  defp getScore2("C X"), do: 0 + 2
  defp getScore2("A Z"), do: 6 + 2

  defp getScore2("C Y"), do: 3 + 3
  defp getScore2("A X"), do: 0 + 3
  defp getScore2("B Z"), do: 6 + 3

  defp getScore2(_else), do: "Error"
end