🌟 Advent of Code (AoC) 2022 🌟

using var sr = new StreamReader("input.txt");

int pt1score = 0;
int pt2score = 0;
int i = 1;
string line2 = "";
string line3 = "";

while (!sr.EndOfStream)
{
    var line = sr.ReadLine()!;
    pt1score += line.Substring(0, line.Length / 2).Where(x => line.Substring(line.Length / 2)
        .Contains(x)).Distinct().Sum(x => score_item(x));

    if (i%3 == 0)
    {
        pt2score += line.Where(x => line2.Contains(x) && line3.Contains(x)).Distinct().Sum(x => score_item(x));
    }
    i++;
    line3 = line2;
    line2 = line;
}
Console.WriteLine("Part 1 " + pt1score);
Console.WriteLine("Part 2 " + pt2score);

int score_item(char item)
{
    if (item < 91)
        return item - 38;
    else
        return item - 96;
}

private (int partOne, int partTwo) Solve(string input)
{
	var partOne = input
			.ToLines()
			.Select(s => s.ToCharArray())
			.Select(array =>
				array.Take(array.Length / 2).Join(array.Skip(array.Length / 2)
				, k => k
				, k => k
				, (k, result) => (int)char.ToLower(result) + (char.IsUpper(result) ? -70 : -96)
			)
	   ).Select(grp => grp.ToList())
		.ToList();

	var partTwo = input
		.ToLines()
		.Select(row => row.ToCharArray())
		.Chunk(3)
		.Select(group => group[0]
			.Join(group[1], k => k, k => k, (k, r) => r)
			.Join(group[2], k => k, k => k, (k, r) => r))
		.SelectMany(grp => grp.Select(res => (int)char.ToLower(res) + (char.IsUpper(res) ? -70 : -96))
			.Distinct());

	return (partOne.Select(rugSack => rugSack.Distinct().Single()).Sum()
		, partTwo.Sum());
}

open System.IO
let DuplicatedItem rs =
    rs |> fst |> Set.intersect (rs |> snd) |> Set.toList |> List.head
    
let scoreChar chr = match chr with
 | _ when chr >= 'a' && chr <='z' ->  int(chr) - 96 
 | _ when chr >= 'A' && chr <= 'Z'  -> int(chr) - 38
 
let parseRow (input:string) =
       let r1, r2 = input.ToCharArray() |> List.ofArray |> List.splitAt (input.Length / 2)
       (Set.ofList r1, Set.ofList r2)

let task2:string[] -> int = List.ofArray>> List.map (fun c-> c.ToCharArray() |> Set.ofArray) >> List.chunkBySize 3 >> List.sumBy (Set.intersectMany >> Set.toList >> List.head >> scoreChar)
let input = File.ReadAllLines "input.txt"
printfn "Task 1: %A" (input |> Seq.sumBy (parseRow >> DuplicatedItem >> scoreChar ))
printfn "Test 2: %A" (input |> task2)

	fun Char.priorityValue() = if(this.code > 96) this.code - 96 else this.code -38

	println(input.lines().flatMap { it.substring(0, it.length/2).toSet().intersect(it.substring(it.length/2).toSet()) }
			.sumOf(Char::priorityValue))

	println(input.lines().map { it.toSet() }.chunked(3)
		.flatMap { it[0].intersect(it[1]).intersect(it[2])}
		.sumOf(Char::priorityValue))

#include "../AoCHelper/AoCHelper.h"
#include <vector>

void puzzle_one(std::vector<std::string> input)
{
    std::vector<int> calories{};
    int currentElfCalorie{0};
    for (std::string row : input)
    {
        if (row == "")
        {
            // next elf
            calories.push_back(currentElfCalorie);
            currentElfCalorie = 0;
        }
        else
        {
            currentElfCalorie = currentElfCalorie + std::stoi(row);
        }
    }
    std::sort(calories.begin(), calories.end());
    int answer{calories.back()};
    std::cout << "Puzzle one: " << answer << std::endl;
}

void puzzle_two(std::vector<std::string> input)
{

    std::vector<int> calories{};
    int currentElfCalorie{0};
    for (std::string row : input)
    {
        if (row == "")
        {
            // next elf
            calories.push_back(currentElfCalorie);
            currentElfCalorie = 0;
        }
        else
        {
            currentElfCalorie = currentElfCalorie + std::stoi(row);
        }
    }
    std::sort(calories.begin(), calories.end(), std::greater<int>());
    int answer{calories.at(0) + calories.at(1) + calories.at(2)};
    std::cout << "Puzzle two: " << answer << std::endl;
}

int main()
{
    std::vector<std::string> exampleInput{"", "", "", "", ""};
    AoCHelper a1{"2022", "1"};
    std::vector<std::string> result = a1.get_input();
    puzzle_one(result);
    puzzle_two(result);
}

#include "../AoCHelper/AoCHelper.h"
#include <vector>

void puzzle_one(std::vector<std::string> input)
{
    int answer{0};
    for (std::string row : input)
    {
        char enemyMove = row[0];
        char playerMove = row[2];
        const int rockBonusPoints = 1;
        const int paperBonusPoints = 2;
        const int scissorBonusPoints = 3;
        int bonusPoints = 0;

        enemyMove == 'A' ? enemyMove = 'R' : enemyMove == 'B' ? enemyMove = 'P'
                                                              : enemyMove = 'S';
        switch (playerMove)
        {
        case 'X':
            playerMove = 'R';
            bonusPoints = rockBonusPoints;
            break;
        case 'Y':
            playerMove = 'P';
            bonusPoints = paperBonusPoints;
            break;
        case 'Z':
            playerMove = 'S';
            bonusPoints = scissorBonusPoints;
            break;
        default:
            break;
        }
        if (enemyMove == playerMove)
        {
            // "Tie"
            answer += 3;
        }
        else if (enemyMove == 'R' && playerMove == 'P' || enemyMove == 'S' && playerMove == 'R' || enemyMove == 'P' && playerMove == 'S')
        {
            // "Player wins"
            answer += 6;
        }
        answer += bonusPoints;
    }

    std::cout << "Puzzle one: " << answer << std::endl;
}

void puzzle_two(std::vector<std::string> input)
{
    int answer{0};
    for (std::string row : input)
    {
        char enemyMove = row[0];
        char outcome = row[2];
        char playerMove{};
        const int rockBonusPoints = 1;
        const int paperBonusPoints = 2;
        const int scissorBonusPoints = 3;
        int bonusPoints = 0;

        enemyMove == 'A' ? enemyMove = 'R' : enemyMove == 'B' ? enemyMove = 'P'
                                                              : enemyMove = 'S';
        switch (outcome)
        {
        case 'X':
            //  need to lose
            playerMove = enemyMove == 'R' ? 'S' : enemyMove == 'P' ? 'R'
                                                                   : 'P';
            break;
        case 'Y':
            // need to draw
            playerMove = enemyMove;
            break;
        case 'Z':
            // need to win
            playerMove = enemyMove == 'R' ? 'P' : enemyMove == 'P' ? 'S'
                                                                   : 'R';
            break;
        default:
            break;
        }
        if (enemyMove == playerMove)
        {
            // "Tie"
            answer += 3;
        }
        else if (enemyMove == 'R' && playerMove == 'P' || enemyMove == 'S' && playerMove == 'R' || enemyMove == 'P' && playerMove == 'S')
        {
            // "Player wins"
            answer += 6;
        }
        bonusPoints = playerMove == 'R' ? rockBonusPoints : playerMove == 'P' ? paperBonusPoints
                                                                              : scissorBonusPoints;
        answer += bonusPoints;
    }
    std::cout << "Puzzle two: " << answer << std::endl;
}

int main()
{
    std::vector<std::string> exampleInput{"A Y", "B X", "C Z"};
    AoCHelper a1{"2022", "2"};
    std::vector<std::string> result = a1.get_input();
    puzzle_one(result);
    puzzle_two(result);
}

#include "../AoCHelper/AoCHelper.h"
#include <vector>

int getPriorityLevel(char item)
{
    if (item >= 'a' && item <= 'z')
    {
        return int(item - 'a' + 1);
    }
    else if (item >= 'A' && item <= 'Z')
    {
        return int(item - 'A' + 27);
    }
    return 0;
}

void puzzle_one(std::vector<std::string> input)
{
    int answer{};
    for (std::string row : input)
    {
        std::vector<char> firstCompartment;
        std::vector<char> secondCompartment;
        for (int i = 0; i < row.size() / 2; i++)
        {
            firstCompartment.push_back(row[i]);
        }
        for (int i = row.size() / 2; i < row.size(); i++)
        {
            secondCompartment.push_back(row[i]);
        }
        for (int i = 0; i < firstCompartment.size(); i++)
        {
            if (std::any_of(secondCompartment.begin(), secondCompartment.end(), [&](char secondCompartmentItem)
                            { return secondCompartmentItem == firstCompartment[i]; }))
            {
                answer += getPriorityLevel(firstCompartment[i]);
                break; // Only one item can be duplicate.
            };
        }
    }

    std::cout << "Puzzle one: " << answer << std::endl;
}

void puzzle_two(std::vector<std::string> input)
{
    int answer{};

    for (int i = 0; i < input.size(); i += 3)
    {
        std::vector<char> firstElf;
        std::vector<char> secondElf;
        std::vector<char> thirdElf;
        for (int j = 0; j < input[i].size(); j++)
        {
            firstElf.push_back(input[i][j]);
        }
        for (int j = 0; j < input[i + 1].size(); j++)
        {
            secondElf.push_back(input[i + 1][j]);
        }
        for (int j = 0; j < input[i + 2].size(); j++)
        {
            thirdElf.push_back(input[i + 2][j]);
        }
        auto sameItem = std::find_if(firstElf.begin(), firstElf.end(), [&](char firstElfItem)
                                     { return std::any_of(secondElf.begin(), secondElf.end(), [&](char secondElfItem)
                                                          { return secondElfItem == firstElfItem; }) &&
                                              std::any_of(thirdElf.begin(), thirdElf.end(), [&](char thirdElfItem)
                                                          { return thirdElfItem == firstElfItem; }); });
        if (sameItem != firstElf.end())
        {
            answer += getPriorityLevel(*sameItem);
        }
    }

    std::cout << "Puzzle two: " << answer << std::endl;
}

int main()
{
    std::vector<std::string> exampleInput{"vJrwpWtwJgWrhcsFMMfFFhFp",
                                          "jqHRNqRjqzjGDLGLrsFMfFZSrLrFZsSL",
                                          "PmmdzqPrVvPwwTWBwg",
                                          "wMqvLMZHhHMvwLHjbvcjnnSBnvTQFn",
                                          "ttgJtRGJQctTZtZT",
                                          "CrZsJsPPZsGzwwsLwLmpwMDw"};
    AoCHelper a1{"2022", "3"};
    std::vector<std::string> result = a1.get_input();
    puzzle_one(result);
    puzzle_two(result);
}

var filePath = "src/main/resources/day3.txt";
var input = Files.readAllLines(Path.of(filePath));
var sum = 0;

for (String backpack : input) {
    var backpackHalf = backpack.length() / 2;
    var first = backpack.substring(0, backpackHalf);
    var second = backpack.substring(backpackHalf);

    var set1 = first.chars()
                    .mapToObj(e -> (char) e)
                    .collect(toSet());

    var set2 = second.chars()
                    .mapToObj(e -> (char) e)
                    .collect(toSet());

    set1.retainAll(set2);

    for (char c : set1) {
        sum += Character.isUpperCase(c) ? (int) c - 38 : (int) c - 96;
    }

}

System.out.println("Part 1 answer: " + sum);

var sum2 = 0;
var counter = 0;
Set<Character> commonSet = new HashSet<>();
for (String backpack : input) {
    if (commonSet.size() == 0) {
        commonSet = backpack.chars()
                            .mapToObj(e -> (char) e)
                            .collect(toSet());
    } else {
        commonSet.retainAll(backpack.chars()
                            .mapToObj(e -> (char) e)
                            .collect(toSet()));
    }

    if (counter++ == 2) {
        for (char c : commonSet) {
            sum2 += Character.isUpperCase(c) ? (int) c - 38 : (int) c - 96;
        }
        commonSet.clear();
        counter = 0;
    }
}

System.out.println("Part 2 answer: " + sum2);

with open("3.txt") as f:
    data = f.read().splitlines()

data = [ord(({*a} & {*b} & {*c}).pop()) for a, b, c in zip(*[data[n::3] for n in [0, 1, 2]])]

sum(s - (96 if s > 96 else 38) for s in data)

import {  data, testData } from "../input/day3.js"

function intersect(arr1, arr2) {
  const setA = new Set(arr1);
  const setB = new Set(arr2);

  let interSectResult = [];

  for (const c of setB) {
    if (setA.has(c)) interSectResult.push(c)
  }

  return interSectResult;
}

function intersectFor3Arrays(arr1, arr2, arr3) {
  const setA = new Set(arr1);
  const setB = new Set(arr2);
  const setC = new Set(arr3);

  let interSectResult = [];

  for (const c of setC) {
    if (setA.has(c) && setB.has(c)) interSectResult.push(c);
  }

  return interSectResult;
}

function flatten(arr) {
  return [].concat.apply([], arr);
}

const priority = '-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');

export const solutionA = () => {
  let items = [];

  for (let row of data.split('\n')) {
    const [compA, compB] = [row.substring(0, row.length / 2), row.substring(row.length / 2)];
    items.push(intersect(compA, compB));
  }
  items = flatten(items);
  const sumOfPrios = items.map(n => priority.indexOf(n)).reduce((a, b) => a + b, 0);
  console.log(sumOfPrios)
}

export const solutionB = () => {
  const rows = data.split('\n');
  let items = [];
  for (let i = 0; i < rows.length; i+=3) {
    let compA = rows[i], compB = rows[i+1], compC = rows[i+2];
    items.push(intersectFor3Arrays(compA, compB, compC));
  }
  items = flatten(items);
  const sumOfPrios = items.map(n => priority.indexOf(n)).reduce((a, b) => a + b, 0);

  console.log(sumOfPrios);
}

function start-day3_prioCalc {
    param(
        [parameter(mandatory=$true)]$letter
    )
    switch ( $letter ){
        { $PSItem -cmatch "[A-Z]"}       { $isUpperCase = $true }
        { $PSItem -cmatch "[a-z]"}       { $isUpperCase = $false }
        default                          { Write-Host "Bad matching char!"; Break }
    }
    if ( $isUpperCase ) {
        $prioNum = ([int][char]$letter - (64-26))
    } else {
        $prioNum = ([int][char]$letter - 96)
    }
    return $prioNum
}
function start-day3 {
    $day3InputData = @(Get-Content -Path "day_03_input.txt" -Delimiter "`n")
    # START Part 1
    $prioResultSumPart1 = 0
    $prioResultSumPart2 = 0
    $groupCounter = 0
    $day3InputData | ForEach-Object {
        #Check if length is div with 2
        $stringCharCount = $PSItem.Length
        $stringInputWhole = $PSItem
        if( $stringCharCount.ToString().ToCharArray()[-1] -match "1|3|5|7|9" ) { 
            write-host "String is uneaven lenght ($($stringCharCount[-1]))"
            Break
        }
        $spitStringCharArrayPart1 = ($stringInputWhole.Substring(0,($stringCharCount/2))).ToCharArray()
        $spitStringCharArrayPart2 = ($stringInputWhole.Substring($stringCharCount - ($stringCharCount/2))).ToCharArray()

        $matchingChar = $null
        $matchingChar = $spitStringCharArrayPart1 | ForEach-Object {
            #Write-Host ($spitStringCharArrayPart2 -cmatch $PSItem) 
            return ($spitStringCharArrayPart2 -cmatch $PSItem) 
        }
        $matchingChar = $matchingChar | Select-Object -First 1
        $prioPart1 = start-day3_prioCalc -letter $matchingChar

        $prioResultSumPart1 = $prioResultSumPart1 + $prioPart1
        
    }
    # END Part 1
    # START Part 2
    $prioResultSumPart2 = 0
    $groupCounter = 0
    1..(($day3InputData.Length)/3) | ForEach-Object {
        $badgeMatchingChar = $day3InputData[$groupCounter].ToString().ToCharArray() | ForEach-Object {
            $currentChar = $null
            $currentChar = $PSItem
            if( ($day3InputData[$groupCounter+1] -cmatch $currentChar) -and ($day3InputData[$groupCounter+2] -cmatch $currentChar) ){
                return $currentChar
            } else { }
        }
        $prioPart2 = start-day3_prioCalc -letter ($badgeMatchingChar | Select-Object -First 1)
        $prioResultSumPart2 = $prioResultSumPart2 + $prioPart2
        $groupCounter = $groupCounter+3
    }
    # END Part 2
    Write-Host "Day 3a: $prioResultSumPart1"
    Write-Host "Day 3b: $prioResultSumPart2"
}

func main() {

	lines, err := helpers.ReadLines(os.Args[1])
	sum := 0
	for _, line := range lines {
		s1, s2 := line[0:len(line)/2], line[len(line)/2:]
		sum += findDuplicate(s1, s2)
	}

	fmt.Println((sum))

	sum = 0
	for i := 0; i < len(lines)-1; i += 3 {
		sum += findTriple(lines[i], lines[i+1], lines[i+2])
	}

	fmt.Println((sum))

	if err != nil {
		panic(err)
	}
}

func findDuplicate(s1, s2 string) int {
	seen := make(map[rune]struct{})

	for _, char := range s1 {
		seen[char] = struct{}{}
	}

	for _, char := range s2 {
		if _, ok := seen[char]; ok {
			if unicode.IsUpper(char) {
				return int(char) - 38
			} else {
				return int(char) - 96
			}
		}
	}
	return -1
}

func findTriple(s1, s2, s3 string) int {

	seen := make(map[rune]int)

	for _, char := range s1 {
		seen[char] = 1
	}

	for _, char := range s2 {
		if val, ok := seen[char]; ok && val == 1 {
			seen[char]++
		}
	}

	for _, char := range s3 {
		if val, ok := seen[char]; ok && val == 2 {
			if unicode.IsUpper(char) {
				return int(char) - 38
			} else {
				return int(char) - 96
			}
		}
	}
	return -1
}

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

// Setup
var input = File.ReadAllLines("input.txt");

var counter1 = 0;
var counter2 = 0;

foreach (var line in input)
{
    var split1 = line.Split(',');

    // Elf 1
    var elf1Split = split1[0].Split('-');
    
    var elf1Start = AoCUtils.Parsing.FastIntParse(elf1Split[0]);
    var elf1Stop = AoCUtils.Parsing.FastIntParse(elf1Split[1]);

    // Elf 2
    var elf2Split = split1[1].Split('-');
    
    var elf2Start = AoCUtils.Parsing.FastIntParse(elf2Split[0]);
    var elf2Stop = AoCUtils.Parsing.FastIntParse(elf2Split[1]);

    // Part One: ...
    var elfOneCompletelyInTwo = elf2Start <= elf1Start && elf2Stop >= elf1Stop;
    var elfTwoCompletelyInOne = elf1Start <= elf2Start && elf1Stop >= elf2Stop;
    
    if (elfOneCompletelyInTwo || elfTwoCompletelyInOne)
    {
        counter1++;
    }

    // Part Two: ...
    var elfOnePartlyInTwo =
        (elf1Start >= elf2Start && elf1Start <= elf2Stop) ||
        (elf1Stop >= elf2Start && elf1Stop <= elf2Stop);

    var elfTwoPartlyInOne =
        (elf2Start >= elf1Start && elf2Start <= elf1Stop) ||
        (elf2Stop >= elf1Start && elf2Stop <= elf1Stop);

    if (elfOnePartlyInTwo || elfTwoPartlyInOne)
    {
        counter2++;
    }
}
Console.WriteLine(counter1);
Console.WriteLine(counter2);