feat: Implement solution for puzzle 2022/day02

internal/puzzles/solutions/2022/day02/solution.go

@@ -0,0 +1,30 @@
+// Package day02 contains solution for https://adventofcode.com/2022/day/2 puzzle.
+package day02
+
+import (
+	"io"
+
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+)
+
+func init() {
+	puzzles.Register(solution{})
+}
+
+type solution struct{}
+
+func (s solution) Year() string {
+	return puzzles.Year2022.String()
+}
+
+func (s solution) Day() string {
+	return puzzles.Day02.String()
+}
+
+func (s solution) Part1(input io.Reader) (string, error) {
+	return "", puzzles.ErrNotImplemented
+}
+
+func (s solution) Part2(input io.Reader) (string, error) {
+	return "", puzzles.ErrNotImplemented
+}

internal/puzzles/solutions/2022/day02/solution_test.go

@@ -0,0 +1,119 @@
+package day02
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+	"testing/iotest"
+
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_solution_Year(t *testing.T) {
+	var s solution
+
+	want := "2022"
+	got := s.Year()
+
+	assert.Equal(t, want, got)
+}
+
+func Test_solution_Day(t *testing.T) {
+	var s solution
+
+	want := "2"
+	got := s.Day()
+
+	assert.Equal(t, want, got)
+}
+
+func Test_solution_Part1(t *testing.T) {
+	var s solution
+
+	type args struct {
+		input io.Reader
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test example from description",
+			args: args{
+				input: strings.NewReader("A Y\nB X\nC Z"),
+			},
+			want:    "15",
+			wantErr: assert.NoError,
+		},
+		{
+			name: "",
+			args: args{
+				input: iotest.ErrReader(errors.New("custom error")),
+			},
+			want:    "",
+			wantErr: assert.Error,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := s.Part1(tt.args.input)
+			if !tt.wantErr(t, err) {
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_solution_Part2(t *testing.T) {
+	t.Skip(puzzles.ErrNotImplemented)
+
+	var s solution
+
+	type args struct {
+		input io.Reader
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "",
+			args: args{
+				input: strings.NewReader("A Y\nB X\nC Z"),
+			},
+			want:    "",
+			wantErr: assert.NoError,
+		},
+		{
+			name: "",
+			args: args{
+				input: iotest.ErrReader(errors.New("custom error")),
+			},
+			want:    "",
+			wantErr: assert.Error,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := s.Part2(tt.args.input)
+			if !tt.wantErr(t, err) {
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

internal/puzzles/solutions/2022/day02/spec.md

@@ -0,0 +1,45 @@
+# --- Day 2: Rock Paper Scissors ---
+
+## --- Part One ---
+
+The Elves begin to set up camp on the beach. To decide whose tent gets to be closest to the snack storage, 
+a giant [Rock Paper Scissors tournament](https://en.wikipedia.org/wiki/Rock_paper_scissors) is already in progress.
+
+Rock Paper Scissors is a game between two players. Each game contains many rounds; in each round, the players 
+each simultaneously choose one of Rock, Paper, or Scissors using a hand shape. Then, a winner for that round 
+is selected: Rock defeats Scissors, Scissors defeats Paper, and Paper defeats Rock. If both players choose the same 
+shape, the round instead ends in a draw.
+
+Appreciative of your help yesterday, one Elf gives you an encrypted strategy guide (your puzzle input) that they say 
+will be sure to help you win. "The first column is what your opponent is going to play: `A` for Rock, `B` for Paper, 
+and `C` for Scissors. The second column--" Suddenly, the Elf is called away to help with someone's tent.
+
+The second column, you reason, must be what you should play in response: X for Rock, Y for Paper, and Z for Scissors. 
+Winning every time would be suspicious, so the responses must have been carefully chosen.
+
+The winner of the whole tournament is the player with the highest score. Your total score is the sum of your scores 
+for each round. The score for a single round is the score for the shape you selected 
+(1 for Rock, 2 for Paper, and 3 for Scissors) plus the score for the outcome of the round 
+(0 if you lost, 3 if the round was a draw, and 6 if you won).
+
+Since you can't be sure if the Elf is trying to help you or trick you, you should calculate the score you would get 
+if you were to follow the strategy guide.
+
+For example, suppose you were given the following strategy guide:
+
+```text
+A Y
+B X
+C Z
+```
+
+This strategy guide predicts and recommends the following:
+
+- In the first round, your opponent will choose Rock (A), and you should choose Paper (Y). This ends in a win for you 
+  with a score of 8 (2 because you chose Paper + 6 because you won). 
+- In the second round, your opponent will choose Paper (B), and you should choose Rock (X). This ends in a loss for 
+  you with a score of 1 (1 + 0). 
+- The third round is a draw with both players choosing Scissors, giving you a score of 3 + 3 = 6. 
+- In this example, if you were to follow the strategy guide, you would get a total score of 15 (8 + 1 + 6).
+
+What would your total score be if everything goes exactly according to your strategy guide?

internal/puzzles/solutions/register_2022.go

@@ -6,4 +6,6 @@ import (
 	*/
 	// register day01 solution.
 	_ "github.com/obalunenko/advent-of-code/internal/puzzles/solutions/2022/day01"
+	// register day02 solution.
+	_ "github.com/obalunenko/advent-of-code/internal/puzzles/solutions/2022/day02"
 )