# Completed Advent Of Code: Day One

Advent of Code 2023 is here and I just completed its day-one challenge. Overall, it was fun to play with strings and numbers in javascript. Without any further ado, let's explore the solution.

The challenge is divided into two parts. The first part is quite simple but the second one adds a cherry on top of the cake.

## Part 1 ^{#}

From a given list of strings, I had to find the digits, combine the first and last digit in order of occurrence in the string and them sum it up all. To simplify, for a given string `gh34s1`

, the output will be `31`

with `3`

as the first digit, `1`

as the last digit and `31`

as their concatenation.

So, for two strings `gh34s1`

and `d7hs23`

the sum of their digits will be `31 + 23 = 54`

.

I stored the input in a `.txt`

file and then looped over line by line to get the string from each line.

```
import readline from 'readline'
import fs from 'fs'
import path from 'path'
async function readFileByLine() {
const lines = []
const readInterface = readline.createInterface({
input: fs.createReadStream(path.resolve('day-1/input.txt')),
output: process.stdout,
terminal: false
});
for await (const line of readInterface) {
lines.push(line)
}
return lines
}
(async () => {
const lines = await readFileByLine()
// code
})()
```

Then, to parse the digits in the string and to validate if they are numbers, I used zod. There was a simple way to sort the first and last digits but I couldn't figure it out until I started with Part-2.

```
const calibrationByLine = lines.map((line, i) => {
const lineArr = line.split('')
const firstAndLastNumber = {
first: null,
last: null
}
for (const [index, char] of lineArr.entries()) {
if (!z.nan().safeParse(parseInt(char, 10)).success) {
firstAndLastNumber.first === null ? firstAndLastNumber.first = char : firstAndLastNumber.last = char;
}
};
firstAndLastNumber.last === null && (firstAndLastNumber.last = firstAndLastNumber.first);
return parseInt(`${firstAndLastNumber.first}${firstAndLastNumber.last}`, 10)
})
const result = calibrationByLine.reduce((acc, curr) => acc + curr, 0)
console.log(result)
```

This approach gave me the correct answer for sure but there was a better approach. Yes, regex!

## Part-2 ^{#}

Part-2 had me thinking that my solution was correct, but in fact it wasn't. Lets see what was it. So, the second part introduced a twist in the story, not only the digits were represented as integers in the string, but also their alphabetical synonyms ("one", "two", "three") were also a part of it.

Regex was the answer. I tried `/(one|two|three|four|five|six|seven|eight|nine)/g`

as a regular expression along with `matchAll()`

to find all occurrences of the alphabetical number representations and it seemed to work.

Then, I stored the digits along with their indexes in an array of objects by mapping the alphabetical numbers to their respective integers and sorted them in an ascending order based on the index to get the first and last digits.

```
const regex = new RegExp('(one|two|three|four|five|six|seven|eight|nine)', 'g')
const stringToIntMap = new Map([["one", 1], ["two", 2], ["three", 3], ["four", 4], ["five", 5], ["six", 6], ["seven", 7], ["eight", 8], ["nine", 9]])
const calibrationByLine = lines.map((line, i) => {
const allDigitsInLine = []
for (const match of line.matchAll(regex)) {
allDigitsInLine.push({
digit: stringToIntMap.get(match[1]),
index: match.index
})
}
const lineArr = line.split('')
const firstAndLastNumber = {
first: {
digit: null,
index: null
},
last: {
digit: null,
index: null
}
}
for (const [index, char] of lineArr.entries()) {
if (!z.nan().safeParse(parseInt(char, 10)).success) {
allDigitsInLine.push({
digit: char,
index
})
}
};
const sortedDigitsAccordingToIndex = allDigitsInLine.sort((a, b) => a.index - b.index)
firstAndLastNumber.first = {
...sortedDigitsAccordingToIndex[0]
}
firstAndLastNumber.last = {
...sortedDigitsAccordingToIndex[sortedDigitsAccordingToIndex.length - 1]
}
firstAndLastNumber.last.digit === null && (firstAndLastNumber.last.digit = firstAndLastNumber.first.digit);
return parseInt(`${firstAndLastNumber.first.digit}${firstAndLastNumber.last.digit}`, 10)
})
const result = calibrationByLine.reduce((acc, curr) => acc + curr, 0)
console.log(result)
```

What it would do is, for a string like `d3two4eight`

, the first digit it will select is `3`

and the last as `8`

. So, the output for this string would be `38`

. So far so good. I submitted the answer and it was incorrect. There was a catch.

The input also contained strings such as `3eightwo`

. The alphabetical parts of `eight`

and `two`

overlap. And so, my assumption was to ignore the latter digit and just keep `eight`

which would make the output as `38`

. But the correct output should be `32`

after taking into account the overlapping representations.

After a bit of googling I found out about how to find overlapping matches using the lookahead assertion in regular expressions.

Modified the regex to this and I got the perfect answer.

`new RegExp('(?=(one|two|three|four|five|six|seven|eight|nine))', 'gm')`

And that's it. Through this challenge I learned about regex more than I could have normally. Here's the entire solution:

```
import readline from 'readline'
import fs from 'fs'
import path from 'path'
import { z } from 'zod'
const regex = new RegExp('(?=(one|two|three|four|five|six|seven|eight|nine))', 'gm')
const stringToIntMap = new Map([["one", 1], ["two", 2], ["three", 3], ["four", 4], ["five", 5], ["six", 6], ["seven", 7], ["eight", 8], ["nine", 9]])
async function readFileByLine() {
const lines = []
const readInterface = readline.createInterface({
input: fs.createReadStream(path.resolve('day-1/input.txt')),
output: process.stdout,
terminal: false
});
for await (const line of readInterface) {
lines.push(line)
}
return lines
}
(async () => {
// reading file line by line and storing it in an array - each line contains a string
const lines = await readFileByLine()
// looping over each string
const calibrationByLine = lines.map((line, i) => {
const allDigitsInLine = []
// finding alphabetical digits, mapping them to their integers, and storing them along with index
for (const match of line.matchAll(regex)) {
allDigitsInLine.push({
digit: stringToIntMap.get(match[1]),
index: match.index
})
}
const lineArr = line.split('')
const firstAndLastNumber = {
first: {
digit: null,
index: null
},
last: {
digit: null,
index: null
}
}
// finding integers and storing them along with index
for (const [index, char] of lineArr.entries()) {
if (!z.nan().safeParse(parseInt(char, 10)).success) {
allDigitsInLine.push({
digit: char,
index
})
}
};
// sorting integers based on the index - ascending
const sortedDigitsAccordingToIndex = allDigitsInLine.sort((a, b) => a.index - b.index)
firstAndLastNumber.first = {
...sortedDigitsAccordingToIndex[0]
}
firstAndLastNumber.last = {
...sortedDigitsAccordingToIndex[sortedDigitsAccordingToIndex.length - 1]
}
firstAndLastNumber.last.digit === null && (firstAndLastNumber.last.digit = firstAndLastNumber.first.digit);
// concatenating digits and converting into integer
return parseInt(`${firstAndLastNumber.first.digit}${firstAndLastNumber.last.digit}`, 10)
})
// summing up the result of every string
const result = calibrationByLine.reduce((acc, curr) => acc + curr, 0)
console.log(result)
})()
```

The execution time for `1000`

strings turns out to be:

`executed: 94.047 ms`