Day 1: Calorie Counting

#!/usr/bin/env pypy3

import sys

def main():
    elves = [map(int, elf.split('\n')) for elf in sys.stdin.read()[:-1].split('\n\n')]
    print(max(map(sum, elves)))

if __name__ == '__main__':
    main()

#!/usr/bin/env pypy3

import sys

def main():
    elves = [map(int, elf.split('\n')) for elf in sys.stdin.read()[:-1].split('\n\n')]
    print(sum(sorted(map(sum, elves))[-3:]))

if __name__ == '__main__':
    main()

(define groups (curryr string-split "\n\n"))
(define lines (curryr string-split "\n"))

(define elves (groups (file->string "day01.input")))
(define calories (compose (curry apply +)
                          (curry map string->number)
                          lines))
(define elf-calories (sort (map calories elves) >))

(printf "Part 01: ~a\n" (first elf-calories))
(printf "Part 02: ~a\n" (apply + (take elf-calories 3)))

Once I have a solution, I like to make them as fast as I can.
Here's the 1^st improvement ~20% elapsed time.

(with-input-from-file "day01.input"
   (thunk
    (define elves
      (for/fold ([elves null]
                 [elf 0]
                 #:result (sort elves >))
                ([line (in-lines)])
        (if (string=? line "")
            (values (cons elf elves) 0)
            (values elves (+ elf (string->number line))))))
    (list (first elves) (apply + (take elves 3)))))

import std/strutils
import std/sequtils

proc day1*() = 
  var 
    elves = newSeq[int]()
    currentElf = 0
    topThreeSum = 0 

  for line in lines("inputs/day1.in"):
    if line != "":
      currentElf += parseInt(line)
    else:
      elves.add(currentElf)
      currentElf = 0

  for _ in countup(1,3):
    let idx = elves.maxIndex()
    topThreeSum += elves[idx]
    elves.delete(idx)

  echo(topThreeSum)

#!/usr/bin/env bash

file=day1.dat
part=2
lastline=$(tail -n 1 $file)
if [[ ! -z ${lastline} ]]; then
    echo >> $file
fi

if [[ ${part} -eq 2 ]]; then
# /////////////////////////////////////////////////////////////////////////////
#part 2 0m0.505s
#this solves both parts since we didn't need to store number of elves or number of food items for pt2...
intCals=()
backpack=() #just calorie counts
while read -r line || [[ -n "${line}" ]]; do

#   -- check whether we hit a blank line. If so, sum calories

    if [[ -z ${line} ]]; then
        backpack+=("$(echo "${intCals[@]/%/+}0" | bc)")
        intCals=()
    else
        intCals[${#intCals[@]}]=${line}
    fi
   
done < ${file}

IFS=$'\n' 
sortedBackpack=($(sort --numeric-sort -r <<< "${backpack[*]}"))
unset IFS
echo Anwer to part 1: ${sortedBackpack[0]}
echo Answer to part 2: $(echo "${sortedBackpack[0]/%/+}" "${sortedBackpack[1]/%/+}" "${sortedBackpack[2]/%/+}0" | bc)

# /////////////////////////////////////////////////////////////////////////////
fi

defmodule AdventOfCode.Solution.Year2022.Day01 do
  def part1(input) do
    input
    |> String.split("\n\n", trim: true)
    |> Enum.map(&sum_inventory/1)
    |> Enum.max()
  end

  def part2(input) do
    input
    |> String.split("\n\n", trim: true)
    |> Enum.map(&sum_inventory/1)
    |> Enum.sort(:desc)
    |> Enum.take(3)
    |> Enum.sum()
  end

  defp sum_inventory(s) do
    s
    |> String.split("\n", trim: true)
    |> Enum.map(&String.to_integer/1)
    |> Enum.sum()
  end
end

(defn parse-elves [input]
  (->> (str/split input #"\n\n")
      (map #(str/split-lines %))
      (map #(map parse-long %))
      (map vec)))

(defn sort-elves [elves]
  (->> elves
       (sort-by #(reduce + %))
       (reverse)))

(defn part-1 [input]
  (->> input
       parse-elves
       sort-elves
       first
       (reduce +)))

(defn part-2 [input]
  (let [elves (sort-elves (parse-elves input))
        first (nth elves 0)
        second (nth elves 1)
        third (nth elves 2)]
    (reduce + (concat first second third))))

def part1(input):
    elves = []
    index = 0
    elves.append(0)
    for line in input:
        if line != "\n":
            elves[index] += int(line)
        else:
            index += 1
            elves.append(0)
    print(f"Max Calories: {max(elves)}")
    return elves


def part2(input):
    input.sort()
    print(f"Sum: {sum(input[-3:])}")


def openfile():
    return open("input.txt", "r").readlines()


def main():
    f = openfile()
    elves = part1(f)
    part2(elves)


if __name__ == '__main__':
    main()

I probably could have done it simpler, but my goal isn't to try to find the fanciest solution, just a simple one that would be reasonable to use in a professional setting.

with open("input.txt") as file:
    elves = [0]

    for line in file:
        line = line.strip()
        if line:
            elves[-1] += int(line)
        else:
            elves.append(0)

elves = sorted(elves)
print(elves[-1])  # Part One: 68442
print(sum(elves[-3:]))  # Part Two: 204837

s = File
     .read("input.txt")
     .split("\n\n")
     .map{ _1.split.map(&:to_i).sum }
     .sort
     .reverse

p s.first # Part #1
p s.take(3).sum # Part #2

"use strict";

import * as fs from 'node:fs/promises';

async function main() {
  let elf_number = 0;
  let elf_list = []; 
  elf_list[elf_number] = 0;

  const file = await fs.open("input/input");

  for await (const line of file.readLines()) {
    if (line.length === 0) {
      elf_number++;
      elf_list[elf_number] = 0 
    }   
    else {
      elf_list[elf_number] += parseInt(line);
    }   
  }

  elf_list.sort();
  let max_elf = elf_list.pop();
  console.log("Max Elf Calories: ", max_elf);

  /* Part 2 */
  let top_three = max_elf;
  for (let i = 1; i < 3; i++) {
    top_three += elf_list.pop();
  }
  console.log("Top Three: ", top_three);

}

main();

using Lambda;
using Std;
using StringTools;

class Day1 {
	static public function main() {
		var input = sys.io.File.getContent('input/day1');
		part1(input);
		part2(input);
	}

	static function part1(input: String) {
		var max_calories = input
			.trim()
			// split into groups of calorie counts
			.split("\n\n")
			// calculate calorie count of each group
			.map(group ->
				group.split("\n")
					.map(calories -> calories.parseInt())
					.fold((calories, total) -> calories + total, 0)
			)
			// find the max calorie count
			.fold((calories, max_calories) ->
				if (calories > max_calories)
					calories
				else
					max_calories
			, 0);

		Sys.println('day1 part1: $max_calories');
	}

	static function part2(input: String) {
		var calories = input
			.trim()
			// split into groups of calorie counts
			.split("\n\n")
			// calculate calorie count of each group
			.map(group ->
				group.split("\n")
					.map(calories -> calories.parseInt())
					.fold((calories, total) -> calories + total, 0)
			);

		// sort in reverse order
		calories.sort((a, b) -> b - a);

		// print the sum of the top three calorie counts
		Sys.println('day1 part2: ${calories[0] + calories[1] + calories[2]}');
	}
}

using Common.IterTools;
using Lambda;
using Std;
using StringTools;

class Day1 {
	static public function run(input: String) {
		part1(input);
		part2(input);
	}

	static function part1(input: String) {
		var max_calories = calculateCalories(input).max();

		Sys.println('day1 part2: $max_calories');
	}

	static function part2(input: String) {
		var calories = calculateCalories(input);

		// sort in reverse order
		calories.sort((a, b) -> b - a);

		Sys.println('day1 part2: ${calories[0] + calories[1] + calories[2]}');
	}

	static function calculateCalories(input: String): Array<Int> {
		return input
			.trim()
			// split into groups of calorie counts
			.split("\n\n")
			// calculate calorie count of each group
			.map(group ->
				group.split("\n")
					.fold((calories, total) -> calories.parseInt() + total, 0)
			);
	}
}

import haxe.ds.Option;
using Lambda;

class IterTools {
	public static function sum(it: Iterable<Int>): Int {
		return it.fold((n, acc) -> n + acc, 0);
	}

	public static function sumf(it: Iterable<Float>): Float {
		return it.fold((n, acc) -> n + acc, 0);
	}

	public static function max(it: Iterable<Int>): Int {
		return it.fold((n, max) -> if (n > max) n else max, 0);
	}

	public static function min(it: Iterable<Int>): Int {
		return it.fold((n, min) -> if (n < min) n else min, 0);
	}

	public static function maxf(it: Iterable<Float>): Float {
		return it.fold((n, max) -> if (n > max) n else max, 0);
	}

	public static function minf(it: Iterable<Float>): Float {
		return it.fold((n, min) -> if (n < min) n else min, 0);
	}

	public static function filter_map<A, B>(it: Iterable<A>, f:(item: A) -> Option<B>): Array<B> {
		return it.map(f)
			.filter(item -> switch (item) {
				case Some(_): true;
				case None: false;
			})
			.map(item -> switch (item) {
				case Some(item): item;
				// should never occur
				case None: null;
			});
	}
}

import os
from aoc2022.common import load_file

current_dir = os.path.realpath(os.path.dirname(__file__))
INPUT_FILE = "/".join([current_dir, "input.txt"])
TEST_FILE_1 = "/".join([current_dir, "test1.txt"])
TEST_RESULTS_1 = (24000, 45000)


def parse_elves(lines: list[str]) -> list[list[int]]:
    elves = []
    elf: list[int] = []
    for line in lines:
        if line == "\n":
            elves.append(elf)
            elf = []
        else:
            elf.append(int(line))

    elves.append(elf)

    return elves


def count_calories(elves: list[list[int]]) -> list[int]:
    return [sum(elf) for elf in elves]


def main(filepath: str) -> int:
    lines = load_file.load_lines(filepath)
    elves = parse_elves(lines)

    calorie_totals = count_calories(elves)
    calorie_totals.sort(reverse=True)
    return (calorie_totals[0], sum(calorie_totals[:3]))


if __name__ == "__main__":
    part1, part2 = main(INPUT_FILE)

    print(part1)
    print(part2)

And the common file which will hopefully fill out a bit as time goes on:

def load_lines(filename: str) -> list[str]:
    with open(filename, "r") as fp:
        return fp.readlines()

#!/usr/bin/awk -f
/^$/ { i += 1 }
{ arr[i] += $1 }

END {
	for (i in arr)
		if (arr[i] > max)
			max = arr[i]

	print(max)
}

#!/usr/bin/awk -f
/^$/ { i += 1 }
{ arr[i] += $1 }

END {
	for (i in arr) {
		if (arr[i] > max[0]) {
			max[2] = max[1]
			max[1] = max[0]
			max[0] = arr[i]
		} else if (arr[i] > max[1]) {
			max[2] = max[1]
			max[1] = arr[i]
		} else if (arr[i] > max[2]) {
			max[2] = arr[i]
		}
	}

	print(max[0] + max[1] + max[2])
}

use std::env;
use std::io::{self};

fn solve(input: &str) -> io::Result<()> {
    // Input
    let input_str = std::fs::read_to_string(input).unwrap();
    let input_str = input_str.trim();
    let input: Vec<_> = input_str.split("\n\n").collect();

    // Get each Elf's calories
    let mut elf_snacks: Vec<usize> = input
        .iter()
        .map(|x| x
            .split("\n")
            .map(|y| y.parse::<usize>().unwrap())
        .sum())
        .collect();
    elf_snacks.sort_by(|a, b| b.cmp(a));

    // Calculate answers
    let part1 = elf_snacks.iter().max().unwrap();
    let part2 = elf_snacks.iter().take(3).sum::<usize>();

    println!("Part 1: {}", part1); // 72602
    println!("Part 2: {}", part2); // 207410

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}

print(max([reduce(lambda tot, cal: int(int(tot)+int(cal)), map(int, elv.split('\n'))) for elv in input_str.split('\n\n')]))
print(sum(sorted([reduce(lambda tot, cal: int(int(tot)+int(cal)), map(int, elv.split('\n'))) for elv in input_str.split('\n\n')])[-3:]))

mod parse;
mod part1;
mod part2;

fn main() {
    let _input = include_str!("./input.txt");
    let _structured_input = parse::parse(_input);

    println!("Part One");
    println!("Result: {}", part1::part1(&_structured_input));

    println!("Part Two");
    println!("Result: {}", part2::part2(&_structured_input));
}

#[derive(Debug, PartialEq, Eq)]
pub struct Elf(pub Vec<usize>);

pub fn parse(input: &str) -> Vec<Elf> {
    input
        .trim()
        .split("\n\n")
        .map(|group| {
            Elf(group
                .split('\n')
                .map(|line| line.parse().unwrap())
                .collect())
        })
        .collect::<Vec<Elf>>()
}

use crate::parse;

pub fn part1(input: &[parse::Elf]) -> usize {
    input
        .iter()
        .map(|elf| elf.0.iter().sum::<usize>())
        .max()
        .unwrap()
}

use crate::parse;

pub fn part2(input: &[parse::Elf]) -> usize {
    let mut input = input
        .iter()
        .map(|elf| elf.0.iter().sum::<usize>())
        .collect::<Vec<usize>>();
    input.sort_unstable();
    input[input.len() - 3..].iter().sum()
}

type InputData = number[][];

function formatInput(input: string): InputData {
  return input.split('\n\n').map(e => e.split('\n').map(f => Number(f)));
}

export function run(input: string): string[] {
  const data = formatInput(input);

  const findLargestCalorieTotal = (elves: InputData): number => {
    let largestTotal = 0;
    elves.forEach(elf => {
      const elfTotal = elf.reduce((total, current) => {
        return total + current;
      }, 0);
      if (elfTotal > largestTotal) {
        largestTotal = elfTotal;
      }
    });
    return largestTotal;
  };

  const findTopThreeCalorieTotal = (elves: InputData): number => {
    const topThree = [0, 0, 0] as [number, number, number];

    const addToTopThree = (elfTotal: number): void => {
      topThree.reduce((prevTotal, currentTotal, index) => {
        if (prevTotal > currentTotal) {
          topThree[index] = prevTotal;
          return currentTotal;
        }
        return prevTotal;
      }, elfTotal);
    };

    elves.forEach(elf => {
      const elfTotal = elf.reduce((total, current) => {
        return total + current;
      }, 0);
      addToTopThree(elfTotal);
    });

    return topThree[0] + topThree[1] + topThree[2];
  };

  return [`${findLargestCalorieTotal(data)}`, `${findTopThreeCalorieTotal(data)}`];
}

use std::error::Error;
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn Error>> {
	let mut file = File::open("input_1.txt")?;
	let mut contents = String::new();
	file.read_to_string(&mut contents)?;
	let max_elf: u64 = contents
		.trim()
		.split("\n\n")
		.map(|one_elf|
			one_elf.split('\n')
				.map(|line| u64::from_str_radix(line, 10).unwrap())
				.fold(0, |acc, x| acc + x))
		.max()
		.unwrap();
	println!("{max_elf}");
	Ok(())
}

use std::error::Error;
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn Error>> {
	let mut file = File::open("input_1.txt")?;
	let mut contents = String::new();
	file.read_to_string(&mut contents)?;
	let elves: (u64, u64, u64) = contents
		.trim()
		.split("\n\n")
		.map(|one_elf|
			one_elf.split('\n')
				.map(|line| u64::from_str_radix(line, 10).unwrap())
				.fold(0, |acc, x| acc + x))
		.fold((0, 0, 0), |acc, x| {
			if x > acc.0 {
				(x, acc.0, acc.1)
			} else if x > acc.1 {
				(acc.0, x, acc.1)
			} else if x > acc.2 {
				(acc.0, acc.1, x)
			} else {
				acc
			}
		});
	println!("{}", elves.0 + elves.1 + elves.2);
	Ok(())
}