Post

# Advent of Code 2022, Day 1 - Part One

## Preface

Now that we have the following data structure from our previous post, we start implementing the business logic to retrieve the highest combined number of calories.

```1 2 3 4 5 6 7 [ [ 1000, 2000, 3000 ], // Elve one [ 4000 ], // Elve two [ 5000, 6000 ], // Elve three [ 7000, 8000, 9000 ], // Elve four [ 10000 ] // Elve five ] ```

## Design

The objective of the first part of the assignment is to retrieve the highest amount of combined calories a single elve is carrying. So we need to sum up all the calories in each list from our data structure and get the biggest number.

``````flowchart LR
subgraph eone["Elve one"]
direction TB
ae1["1000"]
be1["2000"]
ce1["3000"]

ae1 ~~~ be1
be1 ~~~ ce1
end

subgraph eonetotal["Elve one"]
te1["Total: 5000"]
end

eone -- "Count calories" --- eonetotal

subgraph etwo["Elve two"]
ae2["4000"]
end

subgraph etwototal["Elve two"]
te2["Total: 4000"]
end

etwo -- "Count calories" --- etwototal

subgraph ethree["Elve three"]
direction TB
ae3["5000"]
be3["6000"]

ae3 ~~~ be3
end

subgraph ethreetotal["Elve three"]
te3["Total: 11000"]
end

ethree -- "Count calories" --- ethreetotal

subgraph efour["Elve four"]
direction TB
ae4["7000"]
be4["8000"]
ce4["9000"]

ae4 ~~~ be4
be4 ~~~ ce4
end

subgraph efourtotal["Elve four"]
te4["Total: 24000"]
end

efour -- "Count calories" --- efourtotal

subgraph efive["Elve five"]
ae5["10000"]
end

subgraph efivetotal["Elve five"]
te5["Total: 10000"]
end

efive -- "Count calories" --- efivetotal

max["Max()"]
biggest["Biggest number: <b>24000</b>"]

eonetotal --> max
etwototal --> max
ethreetotal --> max
efourtotal --> max
efivetotal --> max

max --> biggest
``````

## Implementation

Now we know what we want our code to do, let’s start implementing it in our `PartOne` class.

```1 2 3 4 5 6 7 8 9 10 11 class PartOne( private val sanitizer: Sanitizer ) { fun getResult(): Int { val data = sanitizer.getItems() val totalCalories = data?.map { it.sum() } // 1 val mostCalories = totalCalories?.maxOrNull() // 2 return mostCalories ?: -1 // 3 } } ```

What our code does is, it creates a new list based on the input in step 1. This new list will contain the summed up values of the calories for each elve. This data structure looks like this

```1 2 3 4 5 6 7 [ 5000, 4000, 11000, 24000, 10000 ] ```

Next, in step 2 we get the biggest number from the list, which will be `24000`. And in step 3 we return that value, or `-1` if the input data was null.

### Test case

Because we know that we have a list of calories for each elve, we know that we can sum each list to get the total amount of calories for that elve. Once we have the combined calories for each elve we can return the biggest number of combined calories. As you can see in our design diagram, elve four carries the most calories with a combined total of 24000.

So we can write a test case that validates our test input to the outcome of 24000. Right now we can update the `PartOneTest` class with the following contents.

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class PartOneTest { @Test fun testGetResult() { // Arrange val resource = {}::class.java.getResource("/input.txt") val sanitizer = Sanitizer(resource) val sut = PartOne(sanitizer) val expectedCalories = 24000 // Act val result = sut.getResult() // Assert assertEquals(expectedCalories, result) } } ```