Day 1: Historian Hysteria

import pandas as pd
import numpy as np

def main() -> None:
    df = pd.read_csv("aoc/day1/input_data.txt",sep='   ',names=['left','right'])
    ls = df['left'].sort_values()
    rs = df['right'].sort_values()
    total_distance = 0
    similarity_score = 0
    r_val_counts = rs.value_counts()
    for l,r in zip(ls,rs):
        total_distance = total_distance + np.abs(l-r)
        similarity_score = similarity_score + l*r_val_counts.get(l, default=0)
    
    print(f"total distance:\n\t{total_distance}\nsimilarity:\n\t{similarity_score}")

/* Advent of Code 2024
 * Day 01: Historian Hysteria
 */

#import "Basic";
#import "File";
#import "Hash_Table";
#import "Math";
#import "Sort";
#import "String";

int_compare :: (a: int, b: int) -> int {
    if a > b return 1;
    if a < b return -1;
    return 0;
}

main :: () {
    input, success := read_entire_file("inputs/day_01.txt");

    left_column: [..] int;
    right_column: [..] int;

    for split(input, "\n") {
        numbers := split(it, "   ");
        if numbers.count < 2 {
            break;
        }

        array_add(*left_column, string_to_int(numbers[0]));
        array_add(*right_column, string_to_int(numbers[1]));
    }

    quick_sort(left_column, int_compare);
    quick_sort(right_column, int_compare);

    difference_sum := 0;
    for 0..left_column.count - 1 {
        difference_sum += abs(left_column[it] - right_column[it]);
    }

    print("Part 1: %\n", difference_sum);

    right_column_occurrences: Table(int, int);
    similarity := 0;

    for left_column {
        occurrences, success := table_find(*right_column_occurrences, it);
        if !success {
            occurrences = 0;
            for other: right_column {
                if other == it {
                    occurrences += 1;
                }
            }

            table_set(*right_column_occurrences, it, occurrences);
        }

        similarity += it * occurrences;
    }

    print("Part 2: %\n", similarity);
}

fn get_input(day) {
   let input = open_file(`day${day}.txt`)
       .read_string();
   input.trim();
   input
}

let input = get_input(1);

// PART 1
let list1 = [];
let list2 = [];
for line in input.split("\n") {
    let items = line.split();
    list1.push(items[0].parse_int());
    list2.push(items[1].parse_int());
}

list1.sort();
list2.sort();

let total = 0;
for i in 0..list1.len() {
    total += (list1[i] - list2[i]).abs();
}

print(`part1: ${total}`);

// PART 2
let list2_occurrences = new_int_map();

for location in list2 {
    let prev = list2_occurrences[location] ?? 0;
    list2_occurrences[location] = prev + 1;
}

let total = 0;
for location in list1 {
    let occurrences = list2_occurrences[location] ?? 0;
    total += location * occurrences;
}

print(`part2: ${total}`);

(The SharedParse thing signals to my solution runner that both part1 and part2 can reuse the same value parsed from the input.)

defmodule AdventOfCode.Solution.Year2024.Day01 do
  use AdventOfCode.Solution.SharedParse

  @impl AdventOfCode.Solution.SharedParse
  def parse(input) do
    input
    |> String.split()
    |> Enum.map(&String.to_integer/1)
    |> then(
      &[
        _col_a = Enum.take_every(&1, 2),
        _col_b = Enum.take_every(tl(&1), 2)
      ]
    )
  end

  def part1(cols) do
    cols
    |> Enum.map(&Enum.sort/1)
    |> Enum.zip()
    |> Enum.map(fn {a, b} -> abs(a - b) end)
    |> Enum.sum()
  end

  def part2([col_a, col_b]) do
    a_freq = Enum.frequencies(col_a)
    b_freq = Enum.frequencies(col_b)

    a_freq
    |> Enum.map(fn {n, freq} -> n * freq * Map.get(b_freq, n, 0) end)
    |> Enum.sum()
  end
end

Class {
	#name : 'Day1Solver',
	#superclass : 'Object',
	#instVars : [
		'rawData',
		'leftList',
		'rightList'
	],
	#category : 'AoCDay1',
	#package : 'AoCDay1'
}

Day1Solver class >> newFromFilename: afilename [
	^ self new rawData: afilename asFileReference contents lines; parseRawData
]

Day1Solver class >> newFromString: aString [
	^ self new rawData: aString lines; parseRawData
]

Day1Solver >> parseRawData [
	leftList := rawData collect: [ :s | ((s findTokens: ' ') at: 1) asNumber].
	rightList := rawData collect: [ :s | ((s findTokens: ' ') at: 2) asNumber].
]

Day1Solver >> countRightOccurrences: anInteger [ 
	^ (rightList select: [ :x | x == anInteger ]) size
]

Day1Solver >> solvePart1 [
	leftList sort.
	rightList sort.
	^ (leftList with: rightList collect: [ :l :r | (l - r) abs ]) sum
]

Day1Solver >> solvePart2 [
	^ (leftList collect: [ :x | x * (self countRightOccurrences: x) ]) sum
]

(require 'uiop)

(defun contentful-file-lines (filename)
  (let* (
         (content (uiop:read-file-lines filename))
         (lines-without-empties
           (remove-if
             (lambda (str) (string= "" str))
             content)))
    lines-without-empties))

(defun space-split (str)
  (uiop:split-string str :separator " "))

(defun file-lists (filename)
  (let* (
         (lines (contentful-file-lines filename))
         (split-lines (mapcar #'space-split lines))
         (lists (apply #'mapcar #'list split-lines)))
    lists))

(defun lr-lists (filename)
  (let ((lists (file-lists filename)))
    (list (first lists) (first (last lists)))))

(defun to-integers (strings)
  (mapcar #'parse-integer strings))

(defun lists-to-integers (lists)
  (mapcar #'to-integers lists))

(defun numerical-lr-lists (filename)
  (lists-to-integers (lr-lists filename)))

(defun sort-lists (lists)
  (mapcar
    (lambda (l) (sort l #'<))
    lists))

(defun sorted-lr-lists (filename)
  (sort-lists (numerical-lr-lists filename)))

(defun list-differences (lists)
  (apply
    #'mapcar
    (lambda (i1 i2) (abs (- i1 i2)))
    lists))

(defun sum (numbers)
  (reduce #'+ numbers))

(defun part1 (filename)
  (let* (
         (lr (sorted-lr-lists filename))
         (differences (list-differences lr))
         (total (sum differences)))
    total))

(defun digit-counts (integers)
  (let ((counts (make-hash-table)))
    (progn
      (loop for digit in integers
            do (if (gethash digit counts)
                 (setf (gethash digit counts) (+ (gethash digit counts) 1))
                 (setf (gethash digit counts) 1))))
    counts))

(defun score-list (lr)
  (let* (
         (counts (digit-counts (second lr)))
         (scores (mapcar
                   (lambda
                     (num) (* (gethash num counts 0) num))
                   (first lr))))
    scores))

(defun part2 (filename)
  (let* (
         (lr (numerical-lr-lists filename))
         (scores (score-list lr))
         (total (sum scores)))
    total))

#! /usr/bin/env racket
#lang racket

(require math/base rackunit)

(define (line-pairs in)
  (map (lambda (lst)
         (list (string->number (list-ref lst 0))(string->number (list-ref lst 1))))
       (map (lambda (lst)
              (list (list-ref lst 0) (list-ref lst 1)))
            (for/list ([l (in-lines in)])
              (string-split l "   ")))))

(define (left-list pair-lst)
  (let ([lst (for/list ([lst (in-list pair-lst)])
               (car lst))])
    (sort lst <)))

(define (right-list pair-lst)
  (let ([lst (for/list ([lst (in-list pair-lst)])
               (list-ref lst 1))])
    (sort lst <)))

(define (distances left-lst right-lst)
  (for/list ([i (in-range (length left-lst))])
    (abs (- (list-ref left-lst i) (list-ref right-lst i)))))

; score := (sum (for i (in-list left)
;               (* left (length (filter (equal?=left))))))
(define (similarity-score left-lst right-lst)
  (sum (for/list ([i (in-list left-lst)])
         (* i (length (filter (lambda (x) (equal? i x)) right-lst))))))

(define (run-part01 in)
  (let* ([pairs (line-pairs in)]
         [left (left-list pairs)]
         [right (right-list pairs)])
    (sum (distances left right))))

(define (run-part02 in)
  (let* ([pairs (line-pairs in)]
         [left (left-list pairs)]
         [right (right-list pairs)])
    (similarity-score left right)))

(let ([input (open-input-file "inputs/day01.in")])
  (display (run-part01 input)))
(newline)
(let ([input (open-input-file "inputs/day01.in")])
  (display (run-part02 input)))
(newline)

(check-equal? (run-part01 (open-input-file "examples/day01.in")) 11 "Test part 1")
(check-equal? (run-part02 (open-input-file "examples/day01.in")) 31 "Test part 2")

def compute_p1(input)
  pairs = input.lines.map { |line|
    line.split(/\s+/).map(&:to_i)
  }
  list_a = pairs.map(&:first).sort
  list_b = pairs.map(&:last).sort
  list_a.zip(list_b).map { |x| x.sort.reverse.inject(:-) }.sum
end

def compute_p2(input)
  pairs = input.lines.map { |line|
    line.split(/\s+/).map(&:to_i)
  }
  list_a = pairs.map(&:first).sort
  list_b = pairs.map(&:last).sort

  list_a.reduce(0) { |sum, x|
    sum + (x * list_b.count(x))
  }
end