🌟 Advent of Code (AoC) 2022 🌟

fun dag1(x: Int) = input.split("\n\n").map { elf -> elf.lines().sumOf { snack -> snack.toInt() } }.sortedDescending().subList(0, x).sum()
println("Del 1: ${dag1(1)} och del 2: ${dag1(3)}")

Imports System.IO

Module Program
    Sub Main(args As String())

        Dim elfs As New List(Of Integer)
        Dim currentElf As Integer = 0
        Using reader As New StreamReader("input.txt")
            While Not reader.EndOfStream
                Dim currentLine As String = reader.ReadLine()
                If Not String.IsNullOrWhiteSpace(currentLine) Then
                    currentElf += Integer.Parse(currentLine)
                Else
                    elfs.Add(currentElf)
                    currentElf = 0
                End If
            End While
        End Using

        elfs.Sort()
        elfs.Reverse()
        Console.WriteLine("Part 1: Most calories: " & elfs(0))
        Console.WriteLine("Part 2: Top 3: " & elfs(0) + elfs(1) + elfs(2))
    End Sub
End Module

#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

//part 1

int main()
{

    string filename{"input.txt"};

    ifstream ifs{filename};

    vector<int> elves{};

    string line{};
    int temp{};
    getline(ifs, line);
    do
    {
        if (line == "")
        {
            elves.push_back(temp);
            temp = 0;
             getline(ifs, line);
        }

        temp += stoi(line);       
    }
    while (getline(ifs,line));

    cout << *max_element(elves.begin(), elves.end()) << endl;

    //part 2

    sort(elves.begin(), elves.end(), greater<int>());

    cout << accumulate(elves.begin(), elves.begin()+3, 0) << '\n';
}

Console.WriteLine("Mickur's Advent of Code 2022 - Day 2!");

// Setup
var points = 0;

const int rockValue = 1;
const int paperValue = 2;
const int scissorValue = 3;

const int lossValue = 0;
const int drawValue = 3;
const int winValue = 6;

// Part One: Second column is what you're going to play
foreach (var line in File.ReadLines("input.txt"))
    switch (line[0])
    {
        // Enemy plays rock
        case 'A':
            switch (line[2])
            {
                // You play rock
                case 'X':
                    points += rockValue + drawValue;
                    break;

                // You play paper
                case 'Y':
                    points += paperValue + winValue;
                    break;

                // You play scissor
                case 'Z':
                    points += scissorValue + lossValue;
                    break;
            }

            break;

        // Enemy plays paper
        case 'B':
            switch (line[2])
            {
                // You play rock
                case 'X':
                    points += rockValue + lossValue;
                    break;

                // You play paper
                case 'Y':
                    points += paperValue + drawValue;
                    break;

                // You play scissor
                case 'Z':
                    points += scissorValue + winValue;
                    break;
            }

            break;

        // Enemy plays scissor
        case 'C':
            switch (line[2])
            {
                // You play rock
                case 'X':
                    points += rockValue + winValue;
                    break;

                // You play paper
                case 'Y':
                    points += paperValue + lossValue;
                    break;

                // You play scissor
                case 'Z':
                    points += scissorValue + drawValue;
                    break;
            }

            break;
    }

Console.WriteLine(points);

// Part Two: Seconds column is the result of the game
points = 0;

foreach (var line in File.ReadLines("input.txt"))
    switch (line[0])
    {
        // Enemy plays rock
        case 'A':
            switch (line[2])
            {
                // You should lose
                case 'X':
                    points += scissorValue + lossValue;
                    break;

                // You should draw
                case 'Y':
                    points += rockValue + drawValue;
                    break;

                // You should win
                case 'Z':
                    points += paperValue + winValue;
                    break;
            }

            break;

        case 'B':
            switch (line[2])
            {
                // You should lose
                case 'X':
                    points += rockValue + lossValue;
                    break;

                // You should draw
                case 'Y':
                    points += paperValue + drawValue;
                    break;

                // You should win
                case 'Z':
                    points += scissorValue + winValue;
                    break;
            }

            break;

        case 'C':
            switch (line[2])
            {
                // You should lose
                case 'X':
                    points += paperValue + lossValue;
                    break;

                // You should draw
                case 'Y':
                    points += scissorValue + drawValue;
                    break;

                // You should win
                case 'Z':
                    points += rockValue + winValue;
                    break;
            }

            break;
    }

Console.WriteLine(points);

import { input } from '../input/day2.js';

const readInput = (input) => input.split('\n');
const rows = readInput(input);

export const solutionA = () => {
  let hash = {
    'A X': 1 + 3, //rock rock 
    'A Y': 2 + 6, //rock paper
    'A Z': 3 + 0, //rock scissor
    'B X': 1 + 0, //paper rock
    'B Y': 2 + 3, //paper paper
    'B Z': 3 + 6, //paper scissor
    'C X': 1 + 6, //scissor rock
    'C Y': 2 + 0, //scissor paper
    'C Z': 3 + 3, //scissor scissor
  }
  let points = 0;
  for (const row of rows) {
    points += hash[row];
  }
  console.log(points);
}

export const solutionB = () => {
  let hash = {
    'A X': 3 + 0, //rock scissor
    'A Y': 1 + 3, //rock rock
    'A Z': 2 + 6, //rock paper
    'B X': 1 + 0, //paper rock
    'B Y': 2 + 3, //paper paper
    'B Z': 3 + 6, //paper scissor
    'C X': 2 + 0, //scissor paper
    'C Y': 3 + 3, //scissor scissor
    'C Z': 1 + 6, //scissor rock
  }
  let points = 0;
  for (const row of rows) {
    points += hash[row];
  }
  console.log(points);
}

namespace Day2;

internal class Program
{
    static void Main(string[] args)
    {
        using var sr = new StreamReader("input.txt");

        int pt1score = 0;
        int pt2score = 0;
        while (!sr.EndOfStream)
        {
            var line = sr.ReadLine()!.Split(' ');
            pt1score += pt1_calc(line);
            pt2score += pt2_calc(line);
        }
        Console.WriteLine($"Part 1 = {pt1score}");
        Console.WriteLine($"Part 2 = {pt2score}");

        int pt1_calc(string[] strings)
        {
            return strings[0] switch
            {
                "A" => strings[1] switch { "X" => 1 + 3, "Y" => 2 + 6, "Z" => 3 + 0, _ => 0 },
                "B" => strings[1] switch { "X" => 1 + 0, "Y" => 2 + 3, "Z" => 3 + 6, _ => 0 },
                "C" => strings[1] switch { "X" => 1 + 6, "Y" => 2 + 0, "Z" => 3 + 3, _ => 0 },
                _ => 0
            };
        }

        int pt2_calc(string[] strings)
        {
            return strings[0] switch
            {
                "A" => strings[1] switch { "X" => 3 + 0, "Y" => 1 + 3, "Z" => 2 + 6, _ => 0 },
                "B" => strings[1] switch { "X" => 1 + 0, "Y" => 2 + 3, "Z" => 3 + 6, _ => 0 },
                "C" => strings[1] switch { "X" => 2 + 0, "Y" => 3 + 3, "Z" => 1 + 6, _ => 0 },
                _ => 0
            };
        }

    }
}

open System.IO

type Shape =
    | Rock
    | Paper
    | Scissor
    
type Outcome =
     | Win
     | Lose
     | Draw

let scoreHand hand1 hand2 =
    match (hand1,hand2) with
    | Rock, Paper -> Win
    | Rock, Scissor -> Lose
    | Paper, Rock -> Lose
    | Paper, Scissor -> Win
    | Scissor, Rock -> Win
    | Scissor, Paper -> Lose
    | _ -> Draw
    
let getHand hand outcome =
    match (hand, outcome) with
    | x, Draw -> x
    | Rock, Win -> Paper
    | Rock, Lose -> Scissor
    | Paper, Win -> Scissor
    | Paper, Lose -> Rock
    | Scissor, Win -> Rock
    | Scissor, Lose -> Paper

let scoreOutcome result =
    match result with
    | Win -> 6
    | Draw -> 3
    | Lose -> 0
let scoreShape shape = match shape with
                             | Rock -> 1
                             | Paper -> 2
                             | Scissor -> 3

let parseShape r =
    match r with
    | "A" -> Rock
    | "B" -> Paper
    | "C" -> Scissor
    | "X" -> Rock
    | "Y" -> Paper
    | "Z" -> Scissor
         
let parseOutcome r =
    match r with
    | "X" -> Lose
    | "Y" -> Draw
    | "Z" -> Win
let task' parser1 parser2 = File.ReadAllLines "input.txt" |> Seq.map (fun s ->
    let parts = s.Split(" ")
    (parser1 parts[0], parser2 parts[1]))

    
let task1 = task' parseShape parseShape |> Seq.map(fun (h1,h2) -> scoreShape h2 + (scoreHand h1 h2 |> scoreOutcome)) |> Seq.sum
let task2 = task' parseShape parseOutcome  |> Seq.map(fun (h,o) -> ((getHand h o |> scoreShape) + scoreOutcome o)) |> Seq.sum

printfn $"Task 1: %i{task1}"
printfn $"Task 2: %i{task2}"

fun part2Day2(lines: List<String>): Int {
	var score = 0
	for (line in lines) {

		score += when (line[2]) {
			'Z' -> 6
			'Y' -> 3
			else -> 0
		}

		val shift = when (line[2]) {
			'X' -> -1
			'Y' -> 0
			else  -> 1
		}

		score += when (line[0]) {
			'A' -> (300 + shift) % 3 + 1
			'B' -> (301 + shift) % 3 + 1
			else -> (302 + shift) % 3 + 1
		}
	}
	return score
}

fun part1Day2(lines: List<String>): Int {
	var score = 0
	for (line in lines) {
		score += when (line[0] - line[2] + 23) {
			0 -> 3
			-1, 2 -> 6
			else -> 0
		}

		score += when (line[2]) {
			'X' -> 1
			'Y' -> 2
			'Z' -> 3
			else -> 0
		}
	}
	return score
}

def day2():
    input_list = open("data\\day2.txt").read().split("\n")
    part1_score = 0
    part2_score = 0
    win = 6
    draw = 3
    loss = 0
    rock = 1
    paper = 2
    scissors = 3

    for game_round in input_list:
        match game_round:
            case "A X":
                part1_score += draw + rock
                part2_score += loss + scissors
            case "A Y":
                part1_score += win + paper
                part2_score += draw + rock
            case "A Z":
                part1_score += loss + scissors
                part2_score += win + paper
            case "B X":
                part1_score += loss + rock
                part2_score += loss + rock
            case "B Y":
                part1_score += draw + paper
                part2_score += draw + paper
            case "B Z":
                part1_score += win + scissors
                part2_score += win + scissors
            case "C X":
                part1_score += win + rock
                part2_score += loss + paper
            case "C Y":
                part1_score += loss + paper
                part2_score += draw + scissors
            case "C Z":
                part1_score += draw + scissors
                part2_score += win + rock

    print(part1_score)
    print(part2_score)

    #Execution time (ms): 0.5049000028520823

print([sum([(lambda x,y,f: "XYZXY"["BCA".find(x):].find(f(x, y)) * 3
                           + " XYZ".find(f(x, y)))(*e, f)
            for e in [p.split() for p in open("input02").read().split('\n')]])
       for f in [ lambda x, y: y,
                  lambda x, y: "XYZXY"["BCA".find(x) + "XYZ".find(y)]]])

fn calculate_score1(opponent: char, you: char) -> usize {
   return if you == 'X' { 1 + if opponent == 'A' { 3 } else if opponent == 'C' { 6 } else { 0 }}
     else if you == 'Y' { 2 + if opponent == 'A' { 6 } else if opponent == 'B' { 3 } else { 0 }}
     else if you == 'Z' { 3 + if opponent == 'B' { 6 } else if opponent == 'C' { 3 } else { 0 }}
     else { 0 };
}

fn calculate_score2(opponent: char, result: char) -> usize {
    return if result == 'Z' { 6 + if opponent == 'A' { 2 } else if opponent == 'B' { 3 } else if opponent == 'C' { 1 } else { 0 }}
      else if result == 'Y' { 3 + if opponent == 'A' { 1 } else if opponent == 'B' { 2 } else if opponent == 'C' { 3 } else { 0 }}
      else if result == 'X' { 0 + if opponent == 'A' { 3 } else if opponent == 'B' { 1 } else if opponent == 'C' { 2 } else { 0 }}
      else { 0 };
}

fn main() {
    let input = include_str!("./input.txt");
    let mut total_score1 = 0;
    let mut total_score2 = 0;

    for line in input.lines() {
        total_score1 +=
            calculate_score1(line.chars().nth(0).unwrap(), line.chars().nth(2).unwrap());
        total_score2 +=
            calculate_score2(line.chars().nth(0).unwrap(), line.chars().nth(2).unwrap());
    }

    println!("Total Score 1 {}", total_score1);
    println!("Total Score 2 {}", total_score2);
}
}

private (int partOne, int partTwo) Solve(string input)
	{
        (int playerOnePoints, int playerTwoPoints) GetPoints(char p1, char p2, bool forceOutcome = false)
        {
            int p1a = (int)p1 - 64; // 1,2,3
            int p2a = (int)p2 - 87; // 1,2,3

            if (forceOutcome) // part two
            {
                p2a = p2a switch
                {
                    1 => p1a switch { 1 => 3, 2 => 1, 3 => 2, _ => 0 }, /*loss*/
                    2 => p1a, /* draw */
                    3 => p1a switch { 1 => 2, 2 => 3, 3 => 1, _ => 0 }, /*win*/
                    _ => 0
                };
            }

            switch (p1a - p2a)
            {
                case 1:
                case -2:/*win p1*/
                    return (p1a + 6, p2a + 0);
                case -1:
                case 2: /*win p2*/
                    return (p1a + 0, p2a + 6);
                default:
                case 0: /*draw*/
                    return (p1a + 3, p2a + 3);
            }

        }

        var collectionOfPoints = input
            .ToLines()
            .Select( line =>
                 /* tuple with partOne, partTwo points */
                 (GetPoints(line[0], line[2]).playerTwoPoints, GetPoints(line[0], line[2], forceOutcome: true).playerTwoPoints)
        ).ToList();

        var result_1 = collectionOfPoints.Select(players => players.Item1).Sum();
        var result_2 = collectionOfPoints.Select(players => players.Item2).Sum();

        return (result_1, result_2);
	}