🌟 Advent of Code (AoC) 2022 🌟

import std / [strutils, algorithm, math]

proc getCalories(input: string): seq[int] =
  for elf in input.split("\n\n"):
    var calories: int
    for line in elf.splitLines:
      calories += parseInt(line)
    result.add calories

proc part1(input: string) =
  let cals = getCalories(input)
  echo "Part 1: ", max(cals)


proc part2(input: string) =
  var cals = getCalories(input)
  cals.sort(Descending)
  echo "Part 2: ", sum(cals[0..2])

when isMainModule:
  let input = readFile("input.txt")
  part1(input)
  part2(input)

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func getPartOne(numbers [][]int) int {
	max := 0
	for elf := range numbers {
		sum := getSum(numbers[elf])
		if sum > max {
			max = sum
		}
	}
	return max
}

func getSum(cals []int) int {
	sum := 0
	for cal := range cals {
		sum += cals[cal]
	}
	return sum
}

func getPartTwo(numbers [][]int) int {
	aggregated := make([]int, 0)
	for elf := range numbers {
		sum := getSum(numbers[elf])
		aggregated = append(aggregated, sum)
	}
	sort.IntSlice(aggregated).Sort()
	aggLen := len(aggregated)
	return aggregated[aggLen-1] + aggregated[aggLen-2] + aggregated[aggLen-3]
}

func getNumbers(filename string) [][]int {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	defer file.Close()
	scanner := bufio.NewScanner(file)
	numbers := make([][]int, 1)
	index := 0
	for scanner.Scan() {
		row := scanner.Text()
		val, err := strconv.Atoi(row)
		if err != nil {
			index++
			numbers = append(numbers, make([]int, 0))
			continue
		}
		numbers[index] = append(numbers[index], val)
	}
	return numbers
}

func main() {
	fmt.Println("Part one: ", getPartOne(getNumbers("../input.txt")))
	fmt.Println("Part two: ", getPartTwo(getNumbers("../input.txt")))
}

var elfBackpacks = new List<int>();
var currElf = 0;
input
	.ToLines(removeEmpty: false)
	.ToList()
	.ForEach((val) =>
	{
		if (val == "")
		{
			elfBackpacks.Add((currElf));
			currElf = 0;
		}else
			currElf += Int32.Parse(val);

	});

var partOne = elfBackpacks.Max();
var partTwo = elfBackpacks.OrderDescending().Take(3).Sum();

with open("day1.txt", "r") as file:
    f = file.read()
    f = f.splitlines()

_list = []
count = 0
for number in f:
    if number == "":
        _list.append(count)
        count = 0
    else:
        number = int(number)
        count += number

_list.sort()

tot = _list[-1] + _list[-2] + _list[-3]
print(_list[-1])
print(tot)

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

// Setup
var elves = new List<int>();
var currentElfCalories = 0;

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

if (currentElfCalories > 0)
    elves.Add(currentElfCalories);

// Note: There are better ways to get the top elves than this. But I don't care, this code is simple! I also assume that the input is correctly formatted and that there are always at least three elves.
elves.Sort((a, b) =>
{
    if (a < b)
    {
        return 1;
    }
    
    if (a > b)
    {
        return -1;
    }
    
    return 0;
});

// Part One: Find elf carrying the most
Console.WriteLine($"Part 1: The elf carrying the most calories has {elves[0]} calories");

// Part Two: Find top 3 elves carrying the most
Console.WriteLine($"Part 2: The three elves that are carrying the most calories have {elves[0] + elves[1] + elves[2]} calories total");

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

// Setup
var currentElfCalories = 0;
var gold = 0;
var silver = 0;
var bronze = 0;

foreach (var line in File.ReadLines("input.txt"))
    if (string.IsNullOrWhiteSpace(line))
    {
        // Are we top 3!?
        if (currentElfCalories > bronze)
        {
            // Do we beat gold?
            if (currentElfCalories >= gold)
            {
                bronze = silver;
                silver = gold;
                gold = currentElfCalories;
            }
            // Or do we beat silver?
            else if (currentElfCalories >= silver)
            {
                bronze = silver;
                silver = currentElfCalories;
            }
            else
            {
                bronze = currentElfCalories;
            }
        }
        
        currentElfCalories = 0;
    }
    else
    {
        // Micro-optimization, GOTTA GO FAST!
        // currentElfCalories += int.Parse(line); // Old, super slow code!
        
        var lineValue = 0;
        
        foreach (var c in line)
            lineValue = lineValue * 10 + (c - '0');

        currentElfCalories += lineValue;
    }

// Part One: Find elf carrying the most
Console.WriteLine($"Part 1: The elf carrying the most calories has {gold} calories");

// Part Two: Find top 3 elves carrying the most
Console.WriteLine($"Part 2: The three elves that are carrying the most calories have {gold + silver + bronze} calories total");

public static void AdventOfCodeDay1()
        {
            string[] elfAndCalories = input().Split("\r\n\r\n");

            int[] calorieSumPerElf = new int[elfAndCalories.Length];

            int counter = 0;
            foreach (string summingCalories in elfAndCalories)
            {
                string[] tmp = summingCalories.Split("\r\n");
                int sum = 0;
                for (int i = 0; i < tmp.Length; i++)
                {
                    if (tmp[i] != "")
                    {
                        sum += int.Parse(tmp[i]);
                    }
                }
                calorieSumPerElf[counter] = sum;
                counter++;
            }
            int elfWithMostCalories = calorieSumPerElf.Max(x => x);
            Console.WriteLine(elfWithMostCalories);

            Array.Sort(calorieSumPerElf);
            Array.Reverse(calorieSumPerElf);

            int sumTopThree = calorieSumPerElf[0] + calorieSumPerElf[1] + calorieSumPerElf[2];
            Console.WriteLine(sumTopThree);
        }

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

public class Aoc_template {
    public static void main(String[] args) {
        
        List<Integer> cals = new ArrayList<>();
        List<Integer> cals_sorted = new ArrayList<>();

        try  
        {  
            File file=new File("C:/aoc_input/01/input.txt");
            FileReader fr=new FileReader(file);
            BufferedReader br=new BufferedReader(fr);
            StringBuffer sb=new StringBuffer();
            String line;  
            
            // Initiate total_cals
            int total_cals = 0;
            
            while((line=br.readLine())!=null)  
            {  
                // As long as there is no blank lines, fill up total_cals
                if (!"".equals(line)){
                total_cals = (Integer.parseInt(line)) + total_cals;
                }
                
                // If there is a blank line, sum it up and att to cals list!
                // Then reset the counter
                else if ("".equals(line)) {
                    cals.add(total_cals);
                    total_cals = 0;
                }
            }
            fr.close();
        }  
        catch(IOException e)  
        {  
            e.printStackTrace();
        }
        
        // Why not do it the hard way ? #lovelife
        int high_num = 0;
        
        // Lol idk why i did this.
        for (int i = 0; i<cals.size();i++) {
            if (high_num < cals.get(i)) {
                high_num = cals.get(i);
            }
        }
        
        
        // I just got an idea, when i got to second part ............
        Collections.sort(cals);
        
        // Well , it's working on my computer
        
        int top1 = high_num;
        int top2 = cals.get(cals.size() - 2);
        int top3 = cals.get(cals.size() - 3);
        int total_top3 = top1 + top2 + top3;
        
        // And the winner is
        System.out.println("Highest cal is : " + high_num);
        System.out.println("Top 3 carrying: " + total_top3);
    }  
}

private static void Main(string[] args)
{
    List<Elf> elves = GetElvesFromFile();
    Elf elfWithMostCalories = elves.OrderByDescending(x => x.CalorySum).First();
    List<Elf> topThreeElvesWithMostCalories = elves.OrderByDescending(x => x.CalorySum).Take(3).ToList();

    Console.WriteLine($"The elf carrying the most calories is no {elves.IndexOf(elfWithMostCalories) + 1} and he has {elfWithMostCalories.CalorySum} calories.");
    Console.WriteLine($"Top 3 elves with the most calories have together {topThreeElvesWithMostCalories.Sum(x => x.CalorySum)} calories.");
}

private static List<Elf> GetElvesFromFile()
{
    string[] lines = File.ReadAllLines("day1.txt");
    var elves = new List<Elf>();
    var calories = new List<int>();

    foreach (string line in lines)
    {
        if (string.IsNullOrEmpty(line))
        {
            elves.Add(new Elf { BackPack = calories.ToArray() });
            calories = new List<int>();
        }
        else
        {
            calories.Add(int.Parse(line));

            if (line == lines.Last())
                elves.Add(new Elf { BackPack = calories.ToArray() });
        }
    }

    return elves;
}

private class Elf
{
    public int[] BackPack { get; set; }
    public int CalorySum { get { return this.BackPack.Sum(); } }
}

static int Day1()
{
    string[] list = File.ReadAllLines(@Files/list.txt);
    Dictionary<int, int> dict = new();
    int elf = 1;
    for (int i = 0; i < list.Length; i++)
    {
        if (string.IsNullOrEmpty(list[i]))
        {
            elf++;
            continue;
        }
        else if (!dict.ContainsKey(elf))
        {
            dict.Add(elf, 0);
            dict[elf] = int.Parse(list[i]);
            continue;
        }
        else
            dict[elf] += int.Parse(list[i]);
    }
    return dict.Select(x => x.Value).Max(); //part 1
    return dict.OrderByDescending(x => x.Value).Take(3).Sum(x => x.Value); //part 2
}