🌟 Advent of Code (AoC) 2024 🌟

from collections import Counter 

l1, l2 = zip(*list(tuple(map(int, l.split())) for l in open("input01.txt", "r").readlines()))
c1, c2 = Counter(l1), Counter(l2)
print(sum(map(lambda x: abs(x[0] - x[1]), zip(sorted(l1), sorted(l2)))),
      sum([k * v * c2.get(k, 0) for k, v in c1.items()]))

file = open("input part 1.txt", "r")
data = file.read()
data_into_list = data.split() 
file.close() 

list1 = []
list2 = []

check = 0

for item in data_into_list:
    if check % 2 == 0:
        list1.append(int(item))
    else:
        list2.append(int(item))
    check +=1
    
list1.sort()
list2.sort()
    
summa = 0

# part 1
for n in range(len(list1)):
    summa= summa+ abs(list1[n]-list2[n])
    
print (summa)

# part2
summa = 0
for n in range(len(list1)):
    check=list1[n]
    for i in range(len(list2)):
        repeats = 0
        if list2[i]==check:
            repeats +=1
        else:
            pass
        
        summa += check*repeats
print (summa)

use ahash::AHashMap;
use std::fs;

const INPUT_FILE: &str = "input.txt";

fn read_number_pair(line: &str) -> (i32, i32) {
    let mut number_pair = line.split_whitespace().map(|s| {
        s.parse::<i32>()
            .expect(&format!("{} should be a number", s))
    });
    (number_pair.next().unwrap(), number_pair.next().unwrap())
}

fn read_to_left_and_right_list(path: &str) -> (Vec<i32>, Vec<i32>) {
    fs::read_to_string(path)
        .expect(&format!("File {} should be present", path))
        .lines()
        .map(|line| read_number_pair(line))
        .unzip()
}

// Part 1
fn sorted(v: &Vec<i32>) -> Vec<i32> {
    let mut v_clone = v.clone();
    v_clone.sort();
    v_clone
}

fn calculate_total_distance(left_list: &Vec<i32>, right_list: &Vec<i32>) -> i32 {
    sorted(left_list)
        .iter()
        .zip(sorted(right_list).iter())
        .map(|(a, b)| (a - b).abs())
        .sum()
}

// Part 2
fn calculate_similarity_score(left_list: &[i32], right_list: &[i32]) -> i32 {
    let mut number_count_right_list = AHashMap::new();

    for &number in right_list {
        *number_count_right_list.entry(number).or_insert(0) += 1;
    }

    left_list.iter().fold(0, |total_score, &number| {
        *number_count_right_list.entry(number).or_default() * number + total_score
    })
}

fn main() {
    let (left_list, right_list) = read_to_left_and_right_list(INPUT_FILE);

    let total_distance = calculate_total_distance(&left_list, &right_list);
    println!("part 1: {}", total_distance);

    let similarity_score = calculate_similarity_score(&left_list, &right_list);
    println!("part 2: {}", similarity_score);
}

namespace AdventOfCode;

public class Puzzle_2024_1 : Puzzle
{
    public override object PartOne(string data)
    {
        var lines = Parse(data);
        return lines.left
            .Order()
            .Zip(lines.right.Order(), (l, r) => Math.Abs(l - r))
            .Sum();
    }

    public override object PartTwo(string data)
    {
        var lines = Parse(data);
        var right = lines.right
            .GroupBy(g => g)
            .Select(grp => new { grp.Key, Count = grp.Count() })
            .ToDictionary(grp => grp.Key, grp => grp.Count);

        return lines.left.Sum(l => !right.TryGetValue(l, out var count) ? 0 : l * count);
    }

    private static (IEnumerable<int> left, IEnumerable<int> right) Parse(string data)
    {
        List<int> left = [];
        List<int> right = [];
        var split = data.Split(Environment.NewLine);
        foreach (var line in split)
        {
            var parts = line.Split(" ", StringSplitOptions.RemoveEmptyEntries);
            left.Add(int.Parse(parts[0]));
            right.Add(int.Parse(parts[1]));
        }

        return (left, right);
    }
}

var lines = File.ReadAllLines("input.txt").Select(x => x.Split("   ")).Select(x => (int.Parse(x[0]), int.Parse(x[1])));
var group = lines.Select(x => x.Item2).GroupBy(i => i).Select(g => new KeyValuePair<int, int>(g.Key, g.Count())).ToDictionary();
Console.WriteLine("Part 1: " + lines.Select(x => x.Item1).Order().Zip(lines.Select(x => x.Item2).Order()).Sum(a => Math.Abs(a.First - a.Second)));
Console.WriteLine("Part 2: " + lines.Sum(x => { group.TryGetValue(x.Item1, out int mult);  return x.Item1 * mult; }));

<?php
// All data which is a tuple of two numbers separated by 3 spaces
$data = "88159   51481
66127   31794
71500   84893
and_so_on..."; // Data from: https://adventofcode.com/2024/day/1/input

// We create a lines array
$lines = explode("\n", $data);

// Now we will extract each number from each line, one number
// is to the left of 3 spaces and the other is to the right
// We also convert the string numbers to integers while we're at it
$leftArr = [];
$rightArr = [];

foreach ($lines as $line) {
    $numbers = explode("   ", $line);
    $leftArr[] = intval($numbers[0]);
    $rightArr[] = intval($numbers[1]);
}

// We will now sort each array in ascending order
sort($leftArr);
sort($rightArr);

// We will now loop through both arrays at the same time and
// add the difference between the two numbers to a sum
$sumOfDifferenceBetweenTheTwoArrays = 0;

// Using "abs" we can find the absolute value of the difference
for ($i = 0; $i < count($leftArr); $i++) {
    $sumOfDifferenceBetweenTheTwoArrays += abs($leftArr[$i] - $rightArr[$i]);
}

// Output the sum of the differences between the two arrays
echo $sumOfDifferenceBetweenTheTwoArrays;
?>

<?php
// All data which is a tuple of two numbers separated by 3 spaces
$data = "88159   51481
66127   31794
and_so_on..."; // Source: https://adventofcode.com/2024/day/1/input
// We create a lines array
$lines = explode("\n", $data);

// Now we will extract each number from each line, one number
// is to the left of 3 spaces and the other is to the right
// We also convert the string numbers to integers while we're at it
$leftArr = [];
$rightArr = [];
$leftArr2 = [];
$rightArr2 = [];

foreach ($lines as $line) {
    $numbers = explode("   ", $line);
    $leftArr[] = intval($numbers[0]);
    $rightArr[] = intval($numbers[1]);
}

// Also store in a separate array for later Part 2
$leftArr2 = $leftArr;
$rightArr2 = $rightArr;

// We will now sort each array in ascending order
sort($leftArr);
sort($rightArr);

// We will now loop through both arrays at the same time and
// add the difference between the two numbers to a sum
$sumOfDifferenceBetweenTheTwoArrays = 0;

// Using "abs" we can find the absolute value of the difference
for ($i = 0; $i < count($leftArr); $i++) {
    $sumOfDifferenceBetweenTheTwoArrays += abs($leftArr[$i] - $rightArr[$i]);
}

// Output the sum of the differences between the two arrays
echo $sumOfDifferenceBetweenTheTwoArrays;

// Here in Part 2 we will use the two arrays again. We begin by
// counting the values in right array by using array_count_values.
// We will then loop through the left array and if we find its value
// as a key in the righytArrayCount array then we will check if it
// exists in the foundKeysFromRightArr array. If it does not exist
// then we will add it and we will multiply the found key with the
// corresponding key in the rightArrayCount array (it's value) and
// add that to the $similarityScore. After looping through all the
// values in the left array we will output the $similarityScore.
$rightArrCount = array_count_values($rightArr2);
$foundKeysFromRightArr = [];
$similarityScore = 0;
$length = count($leftArr2); // Jag la till $length för att inte plåga sönder for-loopen! :P

for ($i = 0; $i < $length; $i++) {
    if (array_key_exists($leftArr2[$i], $rightArrCount)) {
        if (!in_array($leftArr2[$i], $foundKeysFromRightArr)) {
            $foundKeysFromRightArr[] = $leftArr2[$i];
            $similarityScore += $leftArr2[$i] * $rightArrCount[$leftArr2[$i]];
        }
        // The "else" is when key has already been added, then we only need to add the value
        // that is already in the foundKeysFromRightArr array
        else {
            $similarityScore += $leftArr2[$i];
        }
    }
}

echo "\n" . $similarityScore;
?>

$content = Get-Content day1.txt

$leftPart = @()
$rightPart = @()
$leftAndRight = 0
$similarityScore = 0

$content | ForEach-Object {
    $pos = ($PSItem -replace ('   ',';')).IndexOf(';')
    $leftPart += $PSItem.Substring(0, $pos)
    $rightPart += $PSItem.Substring($pos+3)
}

$leftPart = $leftPart | Sort-Object
$rightPart = $rightPart | Sort-Object

0..$($rightPart.count - 1) | ForEach-Object{
    $leftAndRight = $leftAndRight + [int]$($($leftPart[$PSItem] - $rightPart[$PSItem]) -replace '-','')
}

$leftPart | ForEach-Object {
    $similarityScore = $similarityScore + $($(([regex]::Matches($rightPart, $PSItem)).count) * $PSItem)
}

Write-Host "Part 1: $leftAndRight"
Write-Host "Part 2: $similarityScore"

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

int comp(const void *e1, const void *e2)
{
     return *(int*)e1 - *(int*)e2;
}

int main(int argc, char *argv[])
{
    FILE *fp;
    int a[1000], b[1000];
    int i = 0, j = 0;
    int diff = 0, sim = 0, mult;

    fp = fopen("input.txt", "r");
    while (fscanf(fp, "%d   %d", &a[i], &b[i]) == 2) {
        i++;
    }
    fclose(fp);

    qsort(a, sizeof(a)/sizeof(*a), sizeof(*a), comp);
    qsort(b, sizeof(b)/sizeof(*b), sizeof(*b), comp);

    for (i = 0; i < 1000; i++) {
        // part 1
        diff += abs(a[i] - b[i]);

        //part 2
        mult = 0;
        for (; j < 1000; j++) {
            if (a[i] < b[j]) {
                sim += (a[i] * mult);
                break;
            } else if (a[i] == b[j]) {
                mult++;
            }
        }
    }

    printf("diff = %d\n", diff);
    printf("sim = %d\n", sim);

    return 0;
}