# Advent of Code 2023: Days 1 and Day 2

*An example of what we’ll be doing in this article*

Yes, it’s this time of the year again! While we’re all enjoying a few weeks of festive activities and a bit of well-deserved quality time with our loved ones, some of us are deliberately choosing to spend this time solving some random programming challenges.

Now if you ask me, what I really like about **Advent of Code**, is the creative and fun ways that some programmers approach each new puzzle. See, for people like me who couldn’t care less about competition and leaderboards, each new season of **Advent of Code** is an opportunity to discover new and challenging ways to stimulate my limited problem-solving skills. Simply head over to **YouTube**, search for `advent of code + [year] + [whatever language you can think of]`

and you’ll quickly find yourself watching videos of people trying to solve coding puzzles in absolutely every single programming language that you can think of. As someone who’s much more interested in the creative and fun aspects of the whole exercise, seeing people breeze through each new exercise using **COBOL**, **Zig**, or **Haskell** is an absolutely mesmerising experience.

Now if you’ve been following me for a little while, you’re then probably aware that I started learning **TypeScript** about a year or so ago. The reasons why I decided to embark on this journey are quite simple: I love **JavaScript**, and I’m comfortable with static typing. I remember that it simply felt like a logical thing to do back when I started in late 2021. Over a year later, I have to say that though I unfortunately don’t get to utilise **TypeScript** as often as I’d want to, getting to learn this language is a decision I haven’t regretted even for a second. It is fun, the *types* system is much complex than I ever imagined it would be, and I’ve discovered some really interesting ways to play around with *types* definitions. For instance, I recently stumbled upon this **StackOverflow post** that shows how to define a *decorator* that enforces an *interface* on *static members*. We’re literally talking about a function that works exclusively on types, and I have to admit that after reading through that post I still don’t even know why and how it works.

Anyway, as we’re approaching the end of the year, I too thought that it’d be pretty fun to put my new and still feeble skills to the test, by taking on the yearly *Advent of Code* challenge entirely in **TypeSript**.

Without further ado, let’s get started!

# Day 1: Elves write some weird stuff

One quick note before we start: each exercise on the *Advent of Code* website comes in the form of a simple *.txt* file. However, as I’m using an online **TypeScript** playground named **Playcode.io**, there isn’t an easy way for me to upload a *.txt* file onto that coding environment. We’ll therefore be using the examples provided with each exercise to test and validate our code. That shouldn’t really affect the logic of what we’re trying to achieve today though.

With this out of the way, here’s our first problem:

The […] document consists of lines of text; each line originally contained a specific […] value that the Elves now need to recover. On each line, the calibration value can be found by combining the first digit and the last digit (in that order) to form a single two-digit number. For example:

```
1abc2
pqr3stu8vwx
a1b2c3d4e5f
treb7uchet
```

In this example, the calibration values of these four lines are 12, 38, 15, and 77. Adding these together produces 142. Consider your entire calibration document. What is the sum of all of the calibration values?

Well this sounds pretty straightforward to me. What we need to do here, is extract the first and last *integer* contained within each line, or extract the same *integer* twice if there’s only one. Then we’ll simply store these values somewhere, and sum them.

Now here’s how I think we should approach this exercise:

- We create an
*Object*where each unique*key*maps to a row number. The value associated with each of these*keys*is an*array*that contains all the*integers*found within each individual row - We loop through each row, then through each unique character within that row
- If this character happens to be an
*integer*, we push it to the aforementioned*array*

If we consider the example provided earlier, we’d eventually end up with something like this:

```
{
0: [1,2],
1: [3,8],
2: [1,2,3,4,5],
3: [7]
}
```

- We then loop (again!) through that
*Object*, take the*integers*located at index`[0]`

and`[-1]`

from each*array*, and store them in a separate*array* - We sum the
*integers*within that*array*

Easier said than done? Let’s see! If you remember, here’s what the data we’ll be using to validate our code looks like:

```
const text: string[] = [
"1abc2",
"pqr3stu8vwx",
"a1b2c3d4e5f",
"treb7uchet"
];
```

Remember earlier, when we said we’d need an *object* to store the row numbers as *keys*, and the *integers* we find as *values*? We can define it as follows:

```
type Result = {
[key: number]: number[];
};
```

Our next step is to create three separate functions.

A first one that loops through each individual character, uses regular expressions to assert whether that character could be parsed into an *integer* or not, and stores these character if they pass our simple test:

```
const getAllIntegers = (data: string[]): Result => {
let result: Result = {};
for (let i = 0; i < data.length; i++) {
result[i] = [];
for (let char of data[i]) {
let temp_char: any = new RegExp(/^[0-9]/);
if (temp_char.test(char)) {
result[i].push(parseInt(char));
}
}
}
return result;
}
console.log(getAllIntegers(text));
```

Then a second function, that takes the first and last *integers* within each row (and the same value twice if there’s only one *integer* stored in an *array*). We could arguably have embedded this step within the previous function, but for the sake of clarity I just just thought that we might as well keep everything separated:

```
const getSelectedIntegers = (data: Result): number[] => {
let result: number[] = [];
for (let d in data) {
let first_integer: number = data[d][0];
let last_integer: number = data[d].slice(-1)[0];
result.push(first_integer);
result.push(last_integer);
}
return result;
};
const first: Result = getAllIntegers(text);
const second: number[] = getSelectedIntegers(first)
second.forEach(i => console.log(i))
```

We get this nice *array* and all the *integers* that we had to extract, that we can just sum through our third and last function:

```
const getFinalResults = (data: number[]): number => {
let result: number = 0;
data.forEach(nums => {result += nums});
console.log(`The answer for puzzle 1 is:\n\n\t${result}\n`);
return result;
};
const first: Result = getAllIntegers(text);
const second: number[] = getSelectedIntegers(first)
getFinalResults(second);
```

Seems like we successfully completed the first exercise!

# Day 2: Elves seem to also be into gambling

As can be expected, the puzzle for Day 2 is slightly more difficult than the one we just went through. Actually, allow me to rephrase this: it’s not that the logic involved is particularly complex, but going through this new exercise will definitely involve a few more steps.

Anyway, here’s what the challenge looks like this time:

[…] the Elf shows you a small bag and some cubes which are either red, green, or blue. Each time you play this game, he will hide a secret number of cubes of each color in the bag. […] You play several games and record the information from each game. […] The record of a few games might look like this:

```
Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue
Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red
Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red
Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green
```

In the example above, games 1, 2, and 5 would have been possible. […] However, game 3 would have been impossible […], game 4 would also have been impossible. […] If you add up the IDs of the games that would have been possible, you get 8.

Determine which games would have been possible if the bag had been loaded with only 12 red cubes, 13 green cubes, and 14 blue cubes. What is the sum of the IDs of those games?

From the get go, and as mentioned earlier, this is probably going to require some more advanced *string* parsing techniques:

- We create an
*object*where the*integers*contained after the term*“Game”*in each row are the*keys* - We create a series of nested
*objects*within our first*object*, where the terms*“red”, “green”, and “blue”*are the*keys*and their corresponding*values*an*array*of*integers* - We split each row by white space, loop through this
*array*, look for the terms*“red”, “green”, and “blue”*and push the elements at position`[-1]`

to the*array*of*integers*in our aforementioned nested*object*. So that our main*object*now looks like this:

```
{
1: {
red: [4,1],
green: [2,2],
blue: [3,6],
},
2: {
red: [1],
green: [2,3,1],
blue: [1,4,1],
},
etc..
```

- We set up thresholds for each colour (in this case 12, 13, and 14)
- A simple loop through each
*array*checks if the values are above their corresponding thresholds and returns a*boolean* - We now know which game has some values above the thresholds, and we can exclude them
- All that’s left to do is sum the
*keys*of the remaining games

Our approach might seem a little bit convoluted, but I’m sure it will do the job!

Let’s get started:

```
const puzzle: string[] = [
"Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green",
"Game 2: 1 blue, 2 green; 3 green, 4 blue, 1 red; 1 green, 1 blue",
"Game 3: 8 green, 6 blue, 20 red; 5 blue, 4 red, 13 green; 5 green, 1 red",
"Game 4: 1 green, 3 red, 6 blue; 3 green, 6 red; 3 green, 15 blue, 14 red",
"Game 5: 6 red, 1 blue, 3 green; 2 blue, 1 red, 2 green"
];
```

We first need to define the *types* for our two main *objects*:

```
type All_Games = {
[key: string]: {[key: string]: number[]}
;}
type Possible_Games = {
[key: number]: boolean[]
};
```

Which leads us onto our first function. As discussed earlier, the `game`

variable will serve to store each game ID as *keys* within our `result`

*object*. Once we’ve splitted each row, we look for the terms *“red”, “green”, and “blue”* and parse each element at position `[-1]`

as an *integer* before pushing them into an *array* of *type* `number[]`

.

```
const getAllGames = (data: string[]): All_Games => {
let result: All_Games = {};
for (let d of data) {
let game: string = d.split(":")[0].split(" ")[1];
let cubes: string = d.split(":")[1];
let cube: string[] = cubes.split(" ");
result[game] = {};
result[game]["red"] = [];
result[game]["green"] = [];
result[game]["blue"] = [];
for (let i = 0; i < cube.length; i++) {
if (cube[i].includes("red")) {
result[game]["red"].push(parseInt(cube[i-1]));
}
else if (cube[i].includes("green")) {
result[game]["green"].push(parseInt(cube[i-1]));
}
else if (cube[i].includes("blue")) {
result[game]["blue"].push(parseInt(cube[i-1]));
}
}
}
return result;
};
const all_games: All_Games = getAllGames(puzzle);
console.log(all_games);
```

Alright, that worked, but we’re far from done! Our next function loops through our *arrays* of *integers* and checks whether each element is lower than the corresponding values stored in the `thresholds`

variable or not. The `.some()`

method returns a *boolean* value, which is pushed into an *array* defined by the *type* `Possible_Games`

.

```
const getPossibleGames = (data: All_Games): Possible_Games => {
let possible_games: Possible_Games = {};
const thresholds: number[] = [12,13,14];
for (let game in data) {
possible_games[parseInt(game)] = [];
for (let g in data[game]) {
let cubes: number[] = data[game][g];
if (g == "red") {
possible_games[parseInt(game)].push(cubes.some(c => c > thresholds[0]));
}
else if (g == "green") {
possible_games[parseInt(game)].push(cubes.some(c => c > thresholds[1]));
}
else if (g == "blue") {
possible_games[parseInt(game)].push(cubes.some(c => c > thresholds[2]));
}
}
}
return possible_games;
};
const all_games: All_Games = getAllGames(puzzle);
const all_possible_games: Possible_Games = getPossibleGames(all_games);
console.log(all_possible_games);
```

Almost there. All that’s left to do at this point is detect the presence of the *boolean* value `true`

within each *array*. Each *key* whose corresponding *values* matches our detector gets pushed into a new *array* named `result`

:

```
const getWinningGames = (data: Possible_Games): number[] => {
let result: number[] = [];
for (let game in data) {
//console.log(data[game]);
if (!data[game].includes(true)) {
result.push(parseInt(game));
}
}
return result;
};
const all_games: All_Games = getAllGames(puzzle);
const all_possible_games: Possible_Games = getPossibleGames(all_games);
const winning_games: number[] = getWinningGames(all_possible_games);
winning_games.forEach(w => console.log(`Games that match the thresholds:\n\t${w}`))
```

Onto our fourth and final function, which is the exact same piece of code that we wrote earlier for the Day 1 puzzle. As programmers are lazy by nature, we’re absolutely fine with this reutilising `getFinalResults()`

one last time:

```
const getFinalResults = (data: number[]): number => {
let result: number = 0;
data.forEach(nums => {result += nums});
console.log(`The answer for puzzle 2 is:\n\n\t${result}\n`);
return result;
};
const all_games: All_Games = getAllGames(puzzle);
const all_possible_games: Possible_Games = getPossibleGames(all_games);
const winning_games: number[] = getWinningGames(all_possible_games);
getFinalResults(winning_games);
```

And it looks like we’ve done it! Now dear reader, I hope you enjoyed this article, and feel free to reach out to me if you’ve taken a different approach, or used some funky language!