I decided to do Advent of Code 2019 Day 4! I’m gonna solve the puzzles in Scala! I’m starting late, because I found out about it late. So we’re going to start at Day 4, and catch up in another post, or posts.

I have also decided to implement the solutions in Scala. My Scala skills have gotten rusty, so this is a good time to exercise them again. I have forgotten much of my Scala, since I don’t use it. Reading another post, in Kotlin, showed me just how much I’ve forgotten of the standard library functions. My first solution follows. I may add another solution using the Scala Standard Library functions to do even less actual code.

The full code is on my gitlab.

## Part 1

To start with, I have a simple executable that runs the valid password count method, and prints it out to the command line. I just hard-coded the range, rather than reading in the input from a file.

```
object Puzzle4Main extends App {
val p4 = new Puzzle4
val range = 134792 to 675810
println("Valid passwords Part 1: " + p4.validPasswordCount1(range))
println("Valid passwords Part 2: " + p4.validPasswordCount2(range))
}
```

I didn’t start with both parts, but that’s the final product. Next I took the criteria from the puzzle and built a scalatest FunSpec for part one.

```
class Puzzle4Spec extends AnyFunSpec {
val p4 = new Puzzle4
describe("Tests for puzzle 4: part 1") {
it("111111 meets the password criteria") {
assert(p4.passwordValidPart1("111111"))
}
it("223450 does not meet the criteria") {
assert(!p4.passwordValidPart1("223450"))
}
it("123789 does not meet criteria") {
assert(!p4.passwordValidPart1("123789"))
}
it("123455 meets criteria") {
assert(p4.passwordValidPart1("123455"))
}
}
}
```

I added another criteria when I wasn’t sure if my indexing logic was actually doing the right thing. These tests all passed my implementation, eventually.

```
def passwordValidPart1(input: String): Boolean = {
if (input.length != 6) {
false
} else {
val numbers = input.toCharArray.map(_.asDigit).toList
atLeastOneDouble(numbers) && numbersNeverDecrease(numbers)
}
}
def atLeastOneDouble(numbers: List[Int]): Boolean = {
(0 until (numbers.length - 1)).exists(index => numbers(index) == numbers(index + 1))
}
def numbersNeverDecrease(numbers: List[Int]): Boolean = {
(0 until (numbers.length - 1)).forall(index => numbers(index) <= numbers(index + 1))
}
```

Since I’ve forgotten lots of Scala, especially the methods available to me on the standard library, I probably did a lot manually here that I didn’t need to. It passes the tests, however, and produces an accurate result!

## Part 2

This revealed part two of the puzzle. Tests first!

```
describe("Puzzle 4: part 2") {
it("112233 meets criteria") {
assert(p4.passwordValidPart2("112233"))
}
it("123444 does not meet") {
assert(!p4.passwordValidPart2("123444"))
}
it("111122 meets criteria") {
assert(p4.passwordValidPart2("111122"))
}
}
```

My implementation here is arguably more complex than the first one, and looking at the kotlin blog, I should’ve remembered a lot more of the standard library.

```
def validPasswordCount2(inclusive: Range.Inclusive): Int = {
inclusive.count(number => passwordValidPart2(number.toString))
}
def passwordValidPart2(input: String): Boolean = {
val numbers = input.toCharArray.map(_.asDigit).toList
val grouped = numberGroups(numbers)
numbersNeverDecrease(numbers) && numberGroupsOfOnlyTwo(grouped)
}
def numbersNeverDecrease(numbers: List[Int]): Boolean = {
(0 until (numbers.length - 1)).forall(index => numbers(index) <= numbers(index + 1))
}
// find the groups of numbers
def numberGroups(numbers: List[Int]): List[List[Int]] = {
@tailrec def findGroups(working: List[Int], acc: List[List[Int]], previousNumber: Int): List[List[Int]] = {
if (working.isEmpty) {
acc
} else {
val current = working.head
if (current == previousNumber) {
val sequence = acc.head :+ current
findGroups(working.tail, sequence :: acc.tail, current)
} else {
val sequence = List(current)
findGroups(working.tail, sequence :: acc, current)
}
}
}
findGroups(numbers, List.empty[List[Int]], -1).reverse
}
def numberGroupsOfOnlyTwo(groups: List[List[Int]]): Boolean = {
groups.exists(_.length == 2)
}
```

I reused the `numbersNeverDecrease`

method, and then built a couple of methods to group the numbers into a list of lists, and then make sure I had at least one group of numbers that was only a size of 2. I think I can use a Scala standard library method to do the same thing, but it is fun to write tail recursive methods ðŸ™‚

## Further reading

- My gitlab project containing all of the solutions
- Full solution for day 4
- Advent of Code 2019!
- All my Advent of Code 2019 Posts