🌟 Advent of Code (AoC) 2022 🌟

using static System.Console;

WriteLine("--- Day 1: Calorie Counting ---");

#region HandleData 
List<int> elves = new();
int calories = 0;

foreach (var line in File.ReadLines("puzzleInput.txt"))
{
    if (!string.IsNullOrWhiteSpace(line))
    {
        calories += int.Parse(line);        
    }
    else
    {
        elves.Add(calories);
        calories = 0;
    }    
}

if (calories > 0)
{
    elves.Add(calories);
}

int indexOfElve = elves.IndexOf(elves.Max());
#endregion

WriteLine($"Elf nr {indexOfElve + 1} carrying the most calories and has {elves[indexOfElve]} calories");

use itertools::Itertools;
use std::fs;

pub fn run() {
    let data = fs::read_to_string("dec_03.txt").expect("unable to read file");

    println!("Part 1: {}", part1(&data));
    println!("Part 2: {}", part2(&data));
}
fn part1(data: &String) -> i32 {
    let mut sum: i32 = 0;

    for line in data.lines() {
        let (first, second) = line.split_at(line.len() / 2);

        let mut item = ' ';
        for c in first.chars() {
            match second.find(c) {
                Some(0..=99) => item = c,
                _ => {}
            }
        }
        match item.is_ascii_lowercase() {
            true => {
                sum += item as i32 - 96;
            }
            false => {
                sum += item as i32 - 38;
            }
        }
    }

    sum
}

fn part2(data: &String) -> i32 {
    let mut sum = 0;

    for line in &data.lines().chunks(3) {
        let group: Vec<_> = line.collect();
        let mut item = ' ';

        for c in group[0].chars() {
            match group[1].find(c) {
                Some(0..=99) => match group[2].find(c) {
                    Some(0..=99) => {
                        item = c;
                    }
                    _ => {}
                },
                _ => {}
            }
        }
        match item.is_ascii_lowercase() {
            true => {
                sum += item as i32 - 96;
            }
            false => {
                sum += item as i32 - 38;
            }
        }
    }

    sum
}

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DayThree {
	public static void main(String[] args) {
		List<String> rucksack = new ArrayList<>();
		try {  
			File file = new File("C:\\AoC 22\\inputDay3.txt");
			FileReader filereader = new FileReader(file);
			BufferedReader bufferedreader = new BufferedReader(filereader);
			String line;  
			while((line = bufferedreader.readLine()) != null) {  
				rucksack.add(line);
			}
			filereader.close();
		} catch(IOException e) { 
			e.printStackTrace();
		}
		
		String alphabet = "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
				
		int prioritySum = 0;
		for(int i = 0; i < rucksack.size(); i++) {
			String items = rucksack.get(i);

			String tempFirst = items.substring(0, items.length()/2);
			String tempSecond = items.substring(items.length()/2, items.length());
			int counter = 0; 
			
			for(int j = 0; j < tempFirst.length(); j++) {
				for(int k = 0; k < tempSecond.length(); k++) {
					if(tempFirst.charAt(j) == tempSecond.charAt(k)) {
						counter++;
						if(counter == 1)
							prioritySum = prioritySum + alphabet.indexOf(tempFirst.charAt(j));
					}
				}
			}			
		}
		System.out.println("Priority: " + prioritySum);

		int prioritySumNew = 0;
		for(int i = 0; i < rucksack.size(); i = i+3) {
			
			String tempFirst = rucksack.get(i);
			String tempSecond = rucksack.get(i+1);
			String tempThree = rucksack.get(i+2);
			
			int counter = 0; 
			
			for(int j = 0; j < tempFirst.length(); j++) {
				for(int k = 0; k < tempSecond.length(); k++) {
					for(int o = 0; o < tempThree.length(); o++) {
						if(tempFirst.charAt(j) == tempSecond.charAt(k) && tempFirst.charAt(j) == tempThree.charAt(o)) {
							counter++;
							if(counter == 1)
								prioritySumNew = prioritySumNew + alphabet.indexOf(tempFirst.charAt(j));
						}
					}
				}
			}
		}
		System.out.println("Badge Priority: " + prioritySumNew);
	}
}

-- The program expects the input on stdin, ie
-- $ ./solve < input
import Data.List (elemIndex)

main = interact solve

solve :: String -> String
solve input = "Problem 1: " ++ show p1 ++ "\n"
           ++ "Problem 2: " ++ show p2 ++ "\n"
    where p1 = foldr ((+).score) 0 (map (head.dupes.halves) (lines input))
          p2 = foldr ((+).score) 0 (findBadges (lines input))

-- Find common character from first 3 lines, continue recursively.
findBadges :: [String] -> String
findBadges (e:f:g:es) = head (dupes (e,(dupes (f,g)))):findBadges es
findBadges _ = ""

-- Find the common characters in two strings.
dupes :: (String, String) -> String
dupes (c1, c2) = filter ((flip elem) c1) c2

-- Split a string in half.
halves :: String -> (String, String)
halves s = splitAt (div (length s) 2) s

-- Score of a character from the problem description.
score :: Char -> Int
score c = case elemIndex c (['a'..'z'] ++ ['A'..'Z']) of
    Just i -> i + 1
    _ -> 0

namespace AOC2022.Puzzles;

internal class Puzzle3 : Puzzle<int>
{
    protected override void Solve(string[] lines)
    {
        One = lines
            .Sum(line => line.Substring(0, line.Length / 2)
                .Intersect(line.Substring(line.Length / 2))
                .Select(GetPriority)
                .Single());
        Two = lines
            .Chunk(3)
            .Sum(group => group
                .Skip(1)
                .Aggregate(group.First(), (a, b) => string.Concat(a.Intersect(b)), x => GetPriority(x.Single())));
    }

    private static int GetPriority(char type) => type - (char.IsUpper(type) ? 38 : 96);
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))

int parseInt(const char *str) {
	char *endptr;
	int ret;

	errno = 0;
	ret = strtol(str, &endptr, 10);

	if (errno != 0) {
		perror("Failed to parse string");
		exit(EXIT_FAILURE);
	}

	if (endptr == str) {
		fprintf(stderr, "No digits were found\n");
		exit(EXIT_FAILURE);
	}

	if (*endptr != '\0')
		printf("Warning: further characters after number: \"%s\"\n", endptr);

	return ret;
}

int main(void) {
	char *line = NULL;
	size_t len = 0;
	ssize_t nread;
	int curSum = 0;
	int top[3] = { 0 };

	FILE *fp = fopen("d1_input.txt", "r");
	if (!fp) {
		perror("Failed to open file");
		exit(EXIT_FAILURE);
	}

	while ((nread = getline(&line, &len, fp)) != -1) {
		if (!strcmp(line, "\n")) {
			for (unsigned int i=0; i<ARRAY_LEN(top); i++) {
				if (top[i] <= curSum) {
					memmove(&top[i+1], &top[i], (ARRAY_LEN(top)-i-1)*sizeof(top[0]));
					top[i] = curSum;
					break;
				}
			}

			curSum = 0;
			continue;
		}
		line[nread-1] = '\0';
		curSum += parseInt(line);
	}

	free(line);
	fclose(fp);

	curSum = 0;
	printf("Max calorie sum:  %d\n", top[0]);
	printf("Top calorie sums:");
	for (unsigned int i=0; i<ARRAY_LEN(top); i++) {
		curSum += top[i];
		printf (" %d", top[i]);
	}
	printf("\n");
	printf("Top total sum: %d\n", curSum);

	exit(EXIT_SUCCESS);
}

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

enum weapon { ROCK = 0, PAPER, SCISSORS };
enum outcome { LOSS = ROCK, TIE = PAPER, WIN = SCISSORS };

const int value[3] = { [ROCK] = 1, [PAPER] = 2, [SCISSORS] = 3 };
const int score[3] = { [LOSS] = 0, [TIE] = 3, [WIN] = 6 };

// Outcome score LUT, first dimension: my weapon, second dimension their weapon
const int outcomeScore[3][3] = { [ROCK]     = { [ROCK] = score[TIE],  [PAPER] = score[LOSS], [SCISSORS] = score[WIN]  },
                                 [PAPER]    = { [ROCK] = score[WIN],  [PAPER] = score[TIE],  [SCISSORS] = score[LOSS] },
                                 [SCISSORS] = { [ROCK] = score[LOSS], [PAPER] = score[WIN],  [SCISSORS] = score[TIE]  },
                               };

// My weapon value LUT for certain outcome, first dimension: outcome, second dimension: their weapon
const int valueGivenOutcome[3][3] = { [LOSS] = { [ROCK] = value[SCISSORS], [PAPER] = value[ROCK],     [SCISSORS] = value[PAPER]    },
                                      [TIE]  = { [ROCK] = value[ROCK],     [PAPER] = value[PAPER],    [SCISSORS] = value[SCISSORS] },
                                      [WIN]  = { [ROCK] = value[PAPER],    [PAPER] = value[SCISSORS], [SCISSORS] = value[ROCK]     },
                                    };

int getWeaponOrOutcomeIdx(char chr) {
	switch (chr) {
		case 'A':
		case 'X':
			return ROCK;
		case 'B':
		case 'Y':
			return PAPER;
		case 'C':
		case 'Z':
			return SCISSORS;
		default:
			fprintf(stderr, "Unknown character: %c\n", chr);
			exit(EXIT_FAILURE);
	}
}

int main(void) {
	char *line = NULL;
	size_t len = 0;
	ssize_t nread;
	int totalScoreP1 = 0;
	int totalScoreP2 = 0;

	FILE *fp = fopen("d2_input.txt", "r");
	if (!fp) {
		perror("Failed to open file");
		exit(EXIT_FAILURE);
	}

	while ((nread = getline(&line, &len, fp)) != -1) {
		enum weapon theirIdx, myIdx;
		char *tok = strtok(line, " \n");
		if (!tok) exit(EXIT_FAILURE);
		theirIdx = getWeaponOrOutcomeIdx(tok[0]);

		tok = strtok(NULL, " \n");
		if (!tok) exit(EXIT_FAILURE);
		myIdx = getWeaponOrOutcomeIdx(tok[0]);

		totalScoreP1 += value[myIdx] + outcomeScore[myIdx][theirIdx];
		totalScoreP2 += valueGivenOutcome[myIdx][theirIdx] + score[myIdx];
	}

	free(line);
	fclose(fp);

	printf("totalScoreP1 = %d\n", totalScoreP1);
	printf("totalScoreP2 = %d\n", totalScoreP2);

	exit(EXIT_SUCCESS);
}

#include <errno.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))

int getPriority(uint64_t item) {
	int lcase, ucase;

	lcase = ffs(item >> 32);
	ucase = ffsll((item & 0xffffffff) << 26);

	return lcase + ucase;
}

int main(void) {
	char *line = NULL;
	size_t len = 0;
	ssize_t nread;
	uint32_t totalPrio = 0;
	uint32_t totalBadgePrio = 0;

	FILE *fp = fopen("d3_input.txt", "r");
	if (!fp) {
		perror("Failed to open file");
		exit(EXIT_FAILURE);
	}

	while ((nread = getline(&line, &len, fp)) != -1) {
		uint64_t compartment[2] = { 0 };
		uint64_t overlap;
		static uint64_t rucksack[3];
		static int rucksack_cnt = 0;
		nread--;

		for (int i=0; i<nread>>1; i++)
			compartment[0] |= UINT64_C(1)<<(line[i]-'A');

		for (int i=nread>>1; i<nread; i++)
			compartment[1] |= UINT64_C(1)<<(line[i]-'A');

		overlap = compartment[0] & compartment[1];
		totalPrio += getPriority(overlap);

		// Part 2:
		rucksack[rucksack_cnt++] = compartment[0] | compartment[1];
		if (rucksack_cnt == ARRAY_LEN(rucksack)) {
			uint64_t badge = UINT64_MAX;
			for (unsigned int i=0; i<ARRAY_LEN(rucksack); i++)
				badge &= rucksack[i];
			rucksack_cnt = 0;
			totalBadgePrio += getPriority(badge);
		}
	}

	free(line);
	fclose(fp);

	printf("Total prio: %"PRIu32"\n", totalPrio);
	printf("Total badge prio: %"PRIu32"\n", totalBadgePrio);

	exit(EXIT_SUCCESS);
}

    string[] rucksack = File.ReadAllLines(@Files/day3.txt);
    int prioritiesSum = 0;
    for (int i = 0; i < rucksack.Length; i++)
    {
        var compOne = rucksack[i].Substring(0, (rucksack[i].Length / 2));
        var compTwo = rucksack[i].Substring((rucksack[i].Length / 2), (rucksack[i].Length / 2));
        var match = Regex.Match(compOne, @$"[{compTwo}]");
        if (match.Success)
        {
            if (match.Value == match.Value.ToUpper())
            {
                byte[] ascii = Encoding.ASCII.GetBytes(match.Value);
                prioritiesSum += (ascii[0] - 38);
            }
            else
            {
                byte[] ascii = Encoding.ASCII.GetBytes(match.Value);
                prioritiesSum += (ascii[0] - 96);
            }
        }
    }
    Console.WriteLine(prioritiesSum);

    string[] rucksack = File.ReadAllLines(@Files/day3.txt);
    int keysumtotal = 0;
    for (int i = 0; i < rucksack.Length; i += 3)
    {
        var elf1 = rucksack[i];
        var elf2 = rucksack[i + 1];
        var elf3 = rucksack[i + 2];
        string commonkey = string.Empty;
        int keysumgroup = 0;
        foreach (char c in elf1)
        {
            if (Regex.Count(c.ToString(), @$"[{elf2}]") > 0 && Regex.Count(c.ToString(), @$"[{elf3}]") > 0)
                commonkey = c.ToString();
        }
        if (commonkey == commonkey.ToUpper())
        {
            byte ascii = Encoding.ASCII.GetBytes(commonkey)[0];
            keysumgroup += (ascii - 38);
        }
        else
        {
            byte ascii = Encoding.ASCII.GetBytes(commonkey)[0];
            keysumgroup += (ascii - 96);
        }
        keysumtotal += keysumgroup;
    }
    Console.WriteLine(keysumtotal);

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);

import string

with open('Day3/data.txt') as file:
    data = file.readlines()


# Create Priority dict
items = string.ascii_lowercase[:26] + string.ascii_lowercase[:26].upper()
priorities  = {}

for n, item in enumerate(items):
    priorities[item] = n+1


def find_dup(items):
    item_count = (len(items))
    first_comp= items[0:(item_count//2)]
    second_comp = items[(item_count//2):item_count]

    for item in first_comp:
        if item in second_comp:
            return item
            break


backpacks_prio = []

for backpack in data:
    dup = find_dup(backpack.strip())
    backpacks_prio.append(priorities[dup])


print(sum(backpacks_prio))

# Part 2
groups = []
all_packs = data
while len(all_packs) > 0:
    groups.append(data[0:3])
    for _ in range(3):
        all_packs.pop(0)


def find_badge(packs):
    for item in packs[0]:
        if item in packs[1]:
            if item in packs[2]:
                return item
                break

badges_prio = []
for group in groups:
    badge = find_badge(group)
    print(badge)
    badges_prio.append(priorities[badge])

print(badges_prio)
print(sum(badges_prio))

#include <stdio.h>
#include <stdlib.h>

#define ROW_LEN_MAX 8

__uint32_t solve_day_01(const int numElves)
{
   FILE* inputFile;
    char lineBuf[ROW_LEN_MAX];
    __uint32_t currentElf = 0;
    __uint32_t *topElves = malloc(numElves*sizeof(__uint32_t));
    __uint8_t firstElfToGo = 0;
    __uint32_t heavyElvesSum = 0;

    for (int i = 0; i < numElves; i++)
    {
        topElves[i] = 0;
    }

    inputFile = fopen("input/day_01.txt", "r");
    
    while(fgets(lineBuf, ROW_LEN_MAX, inputFile))
    { 
        if (lineBuf[0] == '\n')
        {
            if (currentElf > topElves[firstElfToGo])
            {
                heavyElvesSum = heavyElvesSum + currentElf - topElves[firstElfToGo];
                topElves[firstElfToGo] = currentElf;
                __uint32_t min = currentElf; 
                for (int i = 0; i < numElves; i++)
                {
                    if (topElves[i] < min)
                    {
                        min = topElves[i];
                        firstElfToGo = i;
                    }
                }
            }
            currentElf = 0;
        }
        else
        {
            currentElf += atoi(lineBuf);
        }
    }

    fclose(inputFile);
    free(topElves);
    return heavyElvesSum;
}

int main(void)
{
    __uint32_t part1 = solve_day_01(1);
    __uint32_t part2 = solve_day_01(3);

    printf("**AoC-2022 day 1 part 1: %d **\n", part1);
    printf("**AoC-2022 day 1 part 2: %d **\n", part2);
}

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;

public class day3 {
    public static void main(String[] args) throws IOException {

        ArrayList<String> compartmentOne = new ArrayList<>();
        ArrayList<String> compartmentTwo = new ArrayList<>();
        ArrayList<String> backPack = new ArrayList<>();
        ArrayList<Character> duplicates = new ArrayList<>();
        ArrayList<Character> duplicates2 = new ArrayList<>();

        Path filePath = Path.of("src/input03.txt");
        String day3Content = Files.readString(filePath);

        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < day3Content.length(); i++) {
            if (day3Content.charAt(i) != ('\n')) {
                builder.append(day3Content.charAt(i));
            }
            else {
                backPack.add(builder.toString());
                builder = new StringBuilder();
            }
        }

        StringBuilder builder1 = new StringBuilder();
        StringBuilder builder2 = new StringBuilder();
        for (String s : backPack) {
            int halfSize = s.length() / 2;
            for (int j = 0; j < s.length(); j++) {
                if (j < halfSize)
                    builder1.append(s.charAt(j));
                else
                    builder2.append(s.charAt(j));
            }
            compartmentOne.add(builder1.toString());
            builder1.setLength(0);
            compartmentTwo.add(builder2.toString());
            builder2.setLength(0);
        }

        Character duplicate = null;
        for (int i = 0; i < backPack.size(); i++) {
            for (int j = 0; j < compartmentOne.get(i).length(); j++) {
                for (int k = 0; k < compartmentOne.get(i).length(); k++) {
                    if (compartmentOne.get(i).charAt(j) == compartmentTwo.get(i).charAt(k))
                        duplicate = compartmentOne.get(i).charAt(j);
                }
            }
            duplicates.add(duplicate);
        }

        char[] duplicates3 = new char[duplicates.size()/3];
        for (int i = 0; i < backPack.size()-2; i++) {
            for (int j = 0; j < backPack.get(i).length(); j++) {
                for (int k = 0; k <backPack.get(i+1).length() ; k++) {
                    for (int l = 0; l <backPack.get(i+2).length(); l++) {
                        if(backPack.get(i).charAt(j) == backPack.get(i+1).charAt(k)){
                            if(backPack.get(i).charAt(j) == backPack.get(i+2).charAt(l)){
                                char badge = backPack.get(i+2).charAt(l);
                                duplicates3[(i+2)/3] = badge;
                            }
                        }
                    }
                }
            }
        }
        for (int i = 0; i < duplicates3.length; i++) {
            duplicates2.add(duplicates3[i]);
        }

        System.out.println(sumList(duplicates));
        System.out.println(sumList(duplicates2));
    }

    private static int sumList(ArrayList<Character> duplicates) {
        String alphabet = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        int sum = 0;
        for (int i = 0; i < alphabet.length(); i++) {
            for (Character duplicate : duplicates) {
                if (alphabet.charAt(i) == duplicate)
                    sum += i;
            }
        }
        return sum;
    }
}

package aoc_template;
import java.io.*;
import java.util.*;

public class Aoc_template {
    public static void main(String[] args) {
        
        List<String> all_items = new ArrayList<>();
        List<Character> complete_list = new ArrayList<>();
        int total_prio = 0;
  
        try  
        {  
            File file=new File("C:/aoc_input/03/input.txt");
            FileReader fr=new FileReader(file);
            BufferedReader br=new BufferedReader(fr);
            StringBuffer sb=new StringBuffer();
            String line;  
            
            while((line=br.readLine())!=null)  
            {  
                all_items.add(line); 
            }
            fr.close();
        }  
        catch(IOException e)  
        {  
            e.printStackTrace();
        }

        for (int i = 0; i<all_items.size();i++) {
            String original = all_items.get(i);
            String firsthalf = "";
            String secondhalf = "";
        
            if(original.length()%2 == 0)
            {
                firsthalf =original.substring(0, original.length()/2);
                secondhalf = original.substring(original.length()/2);
                char[] first_half = firsthalf.toCharArray();
                char[] second_half = secondhalf.toCharArray();
                boolean found = false;
                
                for (int j = 0; j<first_half.length;j++) {
                    for (int k = 0; k<second_half.length;k++) {                        
                        if (second_half[k] == first_half[j] && found == false) {
                            complete_list.add(first_half[j]);
                            found = true;
                        }
                    }
                }
            }
        }
        
        for (int i = 0; i<complete_list.size();i++) {
            char val = complete_list.get(i);
            if (Character.isLowerCase(val)) {
                total_prio = total_prio + (complete_list.get(i).charValue() - 96);
            }
            else{
                total_prio = total_prio + (complete_list.get(i).charValue() - 38);                    
            }             
        }
        
        System.out.println("Total part 1 : " + total_prio);
        
        // End of part 1
        
        
        // Start of part 2
        String[] temp1 = new String[1];
        String[] temp2 = new String[1];
        String[] temp3 = new String[1];
        int total_score = 0;
        boolean reached_three = false;
        int counter = 0;
        boolean found = false;

        for (int a = 0;a<all_items.size();a++) {
                if (a % 3 == 0){
                found = false;
                temp1[0] = all_items.get(a);
                temp2[0] = all_items.get(a + 1);
                temp3[0] = all_items.get(a + 2);

                char[] temp1_char = temp1[0].toCharArray();
                char[] temp2_char = temp2[0].toCharArray();
                char[] temp3_char = temp3[0].toCharArray();
                
                for (char c : temp1_char) {
                    for (char d : temp2_char) {
                        for (char e : temp3_char) {
                            if (d == c) {
                                if (e == d && found == false) {
                                    char val = e;
                                    int test = e;
                                    if (Character.isLowerCase(val)) {
                                        total_score = total_score + test - 96;
                                        reached_three = false;
                                        found = true;
                                        break;
                                    }
                                    else{
                                        total_score = total_score + test - 38;
                                        reached_three = false;
                                        found = true;
                                        break;
                                    }    
                                }
                            }
                        }
                    }
                }  
            }
        }
        
        System.out.println("Total part 2 : " + total_score);
    }
}

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);