Advent of Code 2022 - Day 1, in Kotlin - Calorie Counting • Todd Ginsberg

It’s December 1st and that can only mean one thing - Advent of Code is back! Like the last few years, I will be attempting to solve each puzzle in Kotlin and writing a blog post about it each day. I will attempt to provide clear, idiomatic solutions. When solving the puzzles I will almost always trade clarity for speed. Since I only run the puzzle solution code once (ideally), I’m happy to have things run a bit slower than is strictly possible if the code is clearer and easier to understand.

As in past years, I will put my solutions in a GitHub Repository .

Let’s get started!

Puzzle Input

Each day we’ll have a class named after the day number (Day01 in our case today) which will have an input parameter that represents the puzzle input. In our case, this input comes from the unit test that runs the actual puzzle and tests the solution for correctness. The type of input may change from day to day. Today, for example, it is a single large String representing the entire puzzle input. Other days it might be a List<String> or List<Int>, depending on how we’ll use it when writing the solution. The work of loading the daily input file and possibly turning it into a List is done by a helper class class called Resources . which I’ve used in the past.

Before we start in on parsing our input, let’s decide how we want to store it. Part One of the puzzles asks us to find the largest amount of calories carried by one of the elves. This means we could store either the total sum of calories carried by each elf, or store the calorie amount of each food item carried by each elf (which looks like the problem input). Since I’ve already solved Part Two, and know we’ll only need to know the total-per-elf there as well, we’ll store our input as a List<Int> which represents the total calories carried by each elf.

To do this work, we’ll write a function called parseInput, which will be what we call this sort of thing in each puzzle (if we need one).

class Day01(input: String) {

    private val calories = parseInput(input)

    private fun parseInput(input: String): List<Int> =
        input
            .trim()
            .split("\n\n")
            .map { it.lines().sumOf(String::toInt) }
            .sortedDescending()
}

I don’t know about your input but mine ended with a blank line which I am using trim() to remove to make the rest of this easier. If yours didn’t end with a blank line, this won’t cause any harm as there will be nothing to trim() off. The trim() function is very handy when parsing inputs and manipulating strings - it removes leading and trailing whitespace characters from a String (a newline in our case).

Once that is done, we’ll turn our single String into a List<String> by splitting the input on the presence of two newlines (\n\n). This will put each elf’s calorie counts into a single String, with the individual values still separated by newlines (\n).

In order to turn each String into a total calorie count for a specific elf, we’ll need to map each String to an Int. In Kotlin (and many other languages), map means “convert” or “transform”. In this specific case we have a String but want it to represent an Int, so we map the String to an Int. We do this by getting each line of the String input which represents a single food item carried by a single elf. We can call sumOf and hand it a function reference that helps us do the String to Int conversion called String::toInt.

At this point we have a List<Int> that represents the total number of calories carried by each elf, in the order they appeared in the input. Because both parts of the puzzle ask us to find the highest values in this list, we’ll go ahead and sort it from highest to lowest by using sortDescending(). I’ll note here that if we wanted lowest to highest, we would have used sort().

Finally, calories represents the total number of calories carried by each elf, in descending order.

⭐ Day 1, Part 1

The puzzle text can be found here.

Since most of the real work was done in the input parsing section, we can jump right to a solution by finding the maximum value in the calories list. Because we sorted the list descending, the largest value is the first element in the list, which we can get with first() (or using [0] if you find the index accessor clearer, I like using first() or last() when I can).

// In Day01

fun solvePart1(): Int =
    calories.first()

Star earned! Onward!

⭐ Day 1, Part 2

The puzzle text can be found here.

Because we sorted our calorie list during input parsing, the largest counts will be the fist three elements of the calories list. We can get the first three elements by calling take(3) and then calling sum() on the resulting list to add them together.

// In Day01

fun solvePart2(): Int =
    calories.take(3).sum()

Running this gives us our second star!

I hope you enjoyed this puzzle as much as I did. See you tomorrow!

⭐ Day 1, Part 1

⭐ Day 1, Part 2

Further Reading