Matchsticks
Tags: adventofcode, algorithms, regex, javascript
Published: 2022-09-20 18:27:07

## [Advent of Code 2015 Day 8](https://adventofcode.com/2015/day/8)

## Part 1
1. An `escape` room, eh?
2. `reduce()`, `replaceAll()` and `eval()` for the win!

### An `escape` room, eh?
- Strings full of escaped characters
- Gotta process 'em all
- And compare raw length to processed length

### `reduce()`, `replaceAll()` and `eval()` for the win!
Counting the characters in the raw text is simple enough:
- The input file is one long string containing all the characters
- I just need to remove newline characters

```js
input.replaceAll('\n','').length
```

Counting the in-memory characters is easy with `eval()`:
- Any string
- When passed into `eval()`
- Takes on it's in-memory form

So, a string like `"aaa\"aaa"`...

...after being `eval`uated like this:
```js
eval("aaa\"aaa")
```

...becomes `aaa"aaa`

From there, I just need it's length.

When wrapped inside a `reduce()`, my in-memory character counting algorithm in JavaScript looks like this:
```js
input.split('\n')
  .reduce(
    (sum, str) => sum += eval(str).length
  , 0)
```

After subtracting the latter sum from the former sum, I generated the correct answer!

## Part 2
1. Enter: `regex` and math

### Enter: `regex` and math
- `regex` to count all occurrences of `\` and `"` in each string
- Math to calculate each encoded strings total character count

The `regex` looks like this:
```js
/\\|\"/g
```
- `\\` matches all backslash characters
- `|` matches either one
- `\"` matches all double-quote characters

The math looks like this:
```
Set specials to the count of all \ and " characters
Set others to the difference between all characters and specials
Set total to 2 + others + specials times 2
```
- The additional 2 accounts for the appended enclosing double-quotes

An example:
```
"aaa\"aaa"

specials = ",\,"," -> 4
others = a,a,a,a,a,a -> 6
total = 2 + 6 + (4 * 2) => 16
```

When wrapped inside a `reduce()`, my encoded character counting algorithm in JavaScript looks like this:
```js
input.split('\n')
  .reduce(
    (sum, str) => {
      let specials = [...str.matchAll(/\\|\"/g)].length
      let others = str.length - specials
      return sum + 2 + others + specials * 2
    }
  , 0)
```

After subtracting the new sum from the original sum, I generated the correct answer!

My full algorithm for both parts in JavaScript:
```js
let codeChars = input.replaceAll('\n','').length
let memoryChars = input.split('\n')
  .reduce(
    (sum, str) => sum += eval(str).length
  , 0)
let encodedChars = input.split('\n')
  .reduce(
    (sum, str) => {
      let extra = [...str.matchAll(/\\|\"/g)].length
      let others = str.length - extra
      return sum + 2 + others + extra * 2
    }
  , 0)
console.log("Part 1", codeChars - memoryChars)
console.log("Part 2", encodedChars - codeChars)
```

My algorithm, animated:
![Animation of algorithm](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/n444w83x4pn8gwx54152.gif)

## I did it!!
- I solved both parts!
- Using `reduce()`, `regex`, `replaceAll()`, `eval()`, and a little arithmetic!

That felt like a softball puzzle.

Though, it is the first year of the series and I'm into the first 10 Days.

Here's to hoping it's two-star-earning days thru to the end!