day1 many languages

Author: rene-d

2024/day1/day1.c

@@ -0,0 +1,77 @@
+// cc -o day1 -Wall -O2 day1.c
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <time.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+static int int_cmp(const void *a, const void *b)
+{
+    return *(int *)a - *(int *)b;
+}
+
+int main(int argc, char *argv[])
+{
+    FILE *f;
+    int a, b;
+    int *left = NULL, *right = NULL;
+    size_t size = 0;
+    size_t n = 0;
+
+    if (argc >= 2)
+        f = fopen(argv[1], "r");
+    else
+        f = fopen("input.txt", "r");
+
+    while (fscanf(f, "%d %d", &a, &b) == 2)
+    {
+        if (n >= size)
+        {
+            size += 16;
+            left = (int *)realloc(left, size * sizeof(int));
+            right = (int *)realloc(right, size * sizeof(int));
+        }
+        left[n] = a;
+        right[n] = b;
+        n += 1;
+    }
+
+    qsort(left, n, sizeof(int), int_cmp);
+    qsort(right, n, sizeof(int), int_cmp);
+
+    // part 1
+    int part1 = 0;
+    for (size_t i = 0; i < n; ++i)
+    {
+        part1 += abs(left[i] - right[i]);
+    }
+    printf("%d\n", part1);
+
+    // part 2
+    int part2 = 0;
+    for (size_t i = 0; i < n; ++i)
+    {
+        int a = left[i];
+        for (size_t j = 0; j < n; ++j)
+        {
+            if (right[j] == a)
+            {
+                part2 += a;
+            }
+        }
+    }
+    printf("%d\n", part2);
+
+    free(left);
+    free(right);
+
+    return 0;
+}

2024/day1/day1.cs

@@ -0,0 +1,66 @@
+// [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+class day1
+{
+    static void Main(string[] args)
+    {
+        // Default to "input.txt" if no argument is provided
+        string inputFile = args.Length == 0 ? "input.txt" : args[0];
+
+        // Lists to store the values
+        List<int> left = new List<int>();
+        List<int> right = new List<int>();
+
+        // Read the file and populate the left and right lists
+        foreach (var line in File.ReadLines(inputFile))
+        {
+            // Split the line by any whitespace (spaces or tabs)
+            var parts = line.Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
+
+            // Add the two integers to left and right lists
+            left.Add(int.Parse(parts[0]));
+            right.Add(int.Parse(parts[1]));
+        }
+
+        // Sort both lists
+        left.Sort();
+        right.Sort();
+
+        // Part 1: Calculate the sum of absolute differences
+        int part1Result = 0;
+        for (int i = 0; i < left.Count; i++)
+        {
+            part1Result += Math.Abs(left[i] - right[i]);
+        }
+        Console.WriteLine(part1Result);
+
+        // Part 2: Count occurrences of each element in the right list
+        Dictionary<int, int> rightCounts = new Dictionary<int, int>();
+        foreach (var num in right)
+        {
+            if (rightCounts.ContainsKey(num))
+            {
+                rightCounts[num]++;
+            }
+            else
+            {
+                rightCounts[num] = 1;
+            }
+        }
+
+        // Calculate the weighted sum for part 2
+        int part2Result = 0;
+        foreach (var num in left)
+        {
+            if (rightCounts.ContainsKey(num))
+            {
+                part2Result += num * rightCounts[num];
+            }
+        }
+        Console.WriteLine(part2Result);
+    }
+}

2024/day1/day1.go

@@ -0,0 +1,75 @@
+// [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func main() {
+
+	inputFile := "input.txt"
+	if len(os.Args) >= 2 {
+		inputFile = os.Args[1]
+	}
+
+	file, err := os.Open(inputFile)
+	if err != nil {
+		fmt.Println("error:", err)
+		return
+	}
+	defer file.Close()
+
+	var left, right []int
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.Fields(line)
+		a, _ := strconv.Atoi(parts[0])
+		b, _ := strconv.Atoi(parts[1])
+		left = append(left, a)
+		right = append(right, b)
+	}
+
+	if err := scanner.Err(); err != nil {
+		fmt.Println("error:", err)
+		return
+	}
+
+	// sort the lists
+	sort.Ints(left)
+	sort.Ints(right)
+
+	// part 1
+	part1 := 0
+	for i := 0; i < len(left); i++ {
+		part1 += abs(left[i] - right[i])
+	}
+	fmt.Println(part1)
+
+	// part 2
+	rightCount := make(map[int]int)
+	for _, v := range right {
+		rightCount[v]++
+	}
+
+	part2 := 0
+	for _, a := range left {
+		part2 += a * rightCount[a]
+	}
+	fmt.Println(part2)
+}
+
+// abs returns the absolute value of x.
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

2024/day1/day1.java

@@ -0,0 +1,50 @@
+// [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+// javac day1.java
+// java day1 [input.txt]
+
+import java.io.*;
+import java.nio.file.*;
+import java.util.*;
+
+class day1 {
+    public static void main(String[] args) throws IOException {
+        // Default to "input.txt" if no arguments are passed
+        String inputFile = args.length == 0 ? "input.txt" : args[0];
+
+        // Read the file into two lists: left and right
+        List<Integer> left = new ArrayList<>();
+        List<Integer> right = new ArrayList<>();
+
+        // Read the file and split the numbers
+        Files.lines(Paths.get(inputFile)).forEach(line -> {
+            String[] parts = line.split("\\s+");
+            left.add(Integer.parseInt(parts[0]));
+            right.add(Integer.parseInt(parts[1]));
+        });
+
+        // Sort both lists
+        Collections.sort(left);
+        Collections.sort(right);
+
+        // Part 1: Calculate the sum of absolute differences
+        int part1 = 0;
+        for (int i = 0; i < left.size(); i++) {
+            part1 += Math.abs(left.get(i) - right.get(i));
+        }
+        System.out.println(part1);
+
+        // Part 2: Count the occurrences of each number in the right list
+        Map<Integer, Integer> rightCounts = new HashMap<>();
+        for (int num : right) {
+            rightCounts.put(num, rightCounts.getOrDefault(num, 0) + 1);
+        }
+
+        // Calculate the weighted sum of left elements based on right counts
+        int part2 = 0;
+        for (int num : left) {
+            part2 += num * rightCounts.getOrDefault(num, 0);
+        }
+        System.out.println(part2);
+    }
+}

2024/day1/day1.js

@@ -0,0 +1,50 @@
+// [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+const fs = require('fs');
+
+// Main function to handle file reading and calculations
+async function main() {
+    // Default input file or the one provided as a command line argument
+    const inputFile = process.argv.length === 3 ? process.argv[2] : 'input.txt';
+
+    let left = [];
+    let right = [];
+
+    try {
+        const data = await fs.promises.readFile(inputFile, 'utf-8');
+        const lines = data.split('\n');
+
+        // Reading lines and populating left and right arrays
+        for (const line of lines) {
+            // Split by one or more spaces (whitespace characters)
+            const [a, b] = line.trim().split(/\s+/).map(Number);
+            if (!isNaN(a) && !isNaN(b)) {
+                left.push(a);
+                right.push(b);
+            }
+        }
+
+        // Sorting both arrays
+        left.sort();
+        right.sort();
+
+        // Part 1: Calculate the sum of absolute differences
+        const part1 = left.reduce((sum, a, index) => sum + Math.abs(a - right[index]), 0);
+        console.log(part1);
+
+        // Part 2: Count occurrences of each number in the right array
+        const rightCounts = {};
+        for (const b of right) {
+            rightCounts[b] = (rightCounts[b] || 0) + 1;
+        }
+
+        // Calculate the weighted sum based on left array and counts in right array
+        const part2 = left.reduce((sum, a) => sum + a * (rightCounts[a] || 0), 0);
+        console.log(part2);
+
+    } catch (err) {
+        console.error('Error reading file:', err);
+    }
+}
+
+main();

2024/day1/day1.lua

@@ -0,0 +1,36 @@
+-- [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+input_file = arg[1] or "input.txt"
+
+local left = {}
+local right = {}
+
+for line in io.lines(input_file) do
+    local a, b = line:match("(%d+)%s*(%d+)")
+    table.insert(left, tonumber(a))
+    table.insert(right, tonumber(b))
+end
+
+-- Sort both lists
+table.sort(left)
+table.sort(right)
+
+-- Part 1: Calculate the sum of absolute differences
+local part1 = 0
+for i = 1, #left do
+    part1 = part1 + math.abs(left[i] - right[i])
+end
+print(part1)
+
+-- Part 2: Count occurrences of each element in the right list
+local right_counts = {}
+for _, num in ipairs(right) do
+    right_counts[num] = (right_counts[num] or 0) + 1
+end
+
+-- Calculate the weighted sum for part 2
+local part2 = 0
+for _, num in ipairs(left) do
+    part2 = part2 + num * (right_counts[num] or 0)
+end
+print(part2)

2024/day1/day1.rb

@@ -0,0 +1,24 @@
+# [Day 1: Historian Hysteria](https://adventofcode.com/2024/day/1)
+
+input_file = ARGV.length == 0 ? "input.txt" : ARGV[0]
+
+left = []
+right = []
+
+File.open(input_file, "r") do |file|
+  file.each_line do |line|
+    a, b = line.split.map(&:to_i)
+    left << a
+    right << b
+  end
+end
+
+left.sort!
+right.sort!
+
+# part 1
+puts left.zip(right).map { |a, b| (a - b).abs }.sum
+
+# part 2
+right_counts = right.tally
+puts left.sum { |a| a * right_counts[a].to_i }

2024/day1/day1.rs

@@ -31,7 +31,7 @@ impl Puzzle {
             }
         }
 
-        // sort the both vectors
+        // Sort both arrays
         self.left.sort();
         self.right.sort();
     }