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;
			});
	}
}

with open('01.txt') as input_file:
	contents = input_file.read()

total_calories = list()

elves = contents.split('\n\n')

for elf in elves:
	calories = [int(line) for line in elf.split('\n')]
	total_calories.append(sum(calories))

print(max(total_calories))

--- aoc01a.py   2022-12-01 15:54:12.468426455 -0800
+++ aoc01b.py   2022-12-01 15:54:16.174470842 -0800
@@ -9,5 +9,7 @@
        calories = [int(line) for line in elf.split('\n')]
        total_calories.append(sum(calories))
 
-print(max(total_calories))
+total_calories.sort()
+
+print(sum(total_calories[-3:]))

with this sort of input (newline-delimited, with blank lines separating groups) you can split by \n\n in order to get the groups, and then split each group by \n to get the items.

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(())
}