Advent of Code in Kotlin - some silly (but nice, I think) things I've done/discovered

Having lots of fun re-upping my Kotlin skills with this year's AoC.

Here are some things I've done that I think are shareable.

1. Testing without JUnit - I'm trying to avoid using JUnit and just testing with check(), like so:
   val expected = 30  // as stated in puzzle's example    val actual = part2(testExample1)    check(expected == actual) {        """            FAILED Part 2            input -> $testExample1            expected [$expected]            but got  [$actual]        """.trimIndent()    }

I just discovered the check() has a lazyMessage parameter, which is nice. At some point I might cave and start using JUnit but doing this still helps me do TDD well enough.

2. Declarative/functional programming is nice!

I'm starting to settle on a problem-solving approach that's kind of "bass ackwards" but very much in line with TDD philosophy: Start with the end in mind. I'm working on Day 4 Part 2 right now and here's what I started writing:
fun part2(input: List<String>) =   input              // take the input      .asCards()      // parse to a list of Cards      .processWins()  // process the winning cards      .sum()          // how many cards we end up with
That's it. To get the answer, I work my way backwards and implement each of these steps, breaking each one down into smaller problems when necessary.

3. Kotlin makes it easy to create DSLs (Domain Specific Languages)

Extension functions really help for declarative/functional programming. Here's what the asCards() function ended up being:
fun List<String>.asCards(): List<ScratchCard> = map { ScratchCard.of(it) }
and ScratchCard is a data class with the of() factory function/method as a part of its companion object. This does the heavy lifting of parsing the input.

There are a few more things I'm playing around with but this is getting long and I have to get back to solving Day 4 Part 2. I'm falling way behind with all the reflection and playing around that I'm doing, but it's fun.

4. Using .also scope function for inline debugging statements

If I format them right, I can use IDEA's rectangular (column-wise) selection feature to easily add debugging statements:
   fun part2(input: List<String>): Int =        input               .also { "input -> $it".println() }          .asCards()        .also { "asCards() -> $it".println() }          .processWins()    .also { "processWins() -> $it".println() }          .sum()
When I don't need them, I just rectangular highlight the .also parts and delete or comment them out.

Just did this for Day 4 Part 2, which I just got done solving.

Who needs sleep when you can code in Kotlin all night!  

Still working through Day 5 part 1 (already the 9th day of Advent!!!). Hoping I can catch up a little bit this weekend.

Can't say enough about declarative style coding. I find it very helpful and fun to back into the solution by declaring the code I want to write. Here's what I declared for Day 5, part 1:
class Day05(val seeds: List<Long>, private val almanac: List<AlmanacMapping>) {   fun part1(): Long = seeds.convertTo("location", almanac).min()   companion object {      fun using(input: List<String>) = Day05(         seeds = seedsFrom(input.first()),         almanac = almanacFrom(input.subList(3, input.size))      )      private fun seedsFrom(line: String) = ... // parse to a List<Long>      private fun almanacFrom(input: List<String>) = ... // parse to List<AlmanacMapping>   } } fun main() {   Day05.using(readInput("Day05")).apply {      "Part 1 -> ${part1()}".println()   } }
Edit #1: Ah! Found a bug already just by looking at that code. Off by one:
        almanac = almanacFrom(input.subList(2, input.size))
Edit #2: And as I keep working the problem, I'm also changing the way the code tells the story:
  fun part1(): Long = almanac.convert(seeds, "seed", "location").min()

Junilu Lacar wrote:Edit #2: And as I keep working the problem, I'm also changing the way the code tells the story:
  fun part1(): Long = almanac.convert(seeds, "seed", "location").min()

Looks similar to what I had:
var minLocation = seeds.stream()  .mapToLong(seed -> almanac.find(seed, "seed", "location"))  .min()  .getAsLong();

Stephan van Hulst wrote:
Looks similar to what I had:
var minLocation = seeds.stream()  .mapToLong(seed -> almanac.find(seed, "seed", "location"))  .min()  .getAsLong();

That's awesome. Like minds...  

Well, one thing's for sure, I still have a ways to go to be truly conversant with Kotlin. I've been following this guy named Todd Ginsberg and I find his Kotlin solutions simply amazing in their elegance. For example, I (finally) completed Day 5 Part 2 yesterday but it was taking several minutes (6 to 8 mins) to complete its run. I did not know how to make it perform better.  I looked at Todd's solution and was skeptical that his approach would perform well but when I tried it, it took 6.4 seconds (I ran with a profiler) to complete over 20 million iterations. I know the exact number of iterations because it was also the answer to my puzzle.

His approach was quite simple but something that just escaped me, I wouldn't have thought to do it this way. Basically, he started with the end value (the location) and just went through all possible values until he found one that converted to a seed value that was in any of the ranges given in the puzzle input.

The Kotlin code pretty much says that.
   // reverse the conversion tables, location to seed    private val reverseConversionTables = conversionTables.reversed().map { it.reversed() }    fun part2(): Long =        generateSequence(0, Long::inc).first { location ->  // generate location values from 0 step 1, find the first        val seed = convert(location, reverseConversionTables)  // value that converts to a seed value        seedRanges.any { it.contains(seed) }  // that is in any of the ranges specified in the puzzle input    }
You could even get rid of the "seed" explaining variable but I prefer to keep it.
   fun part2(): Long =        generateSequence(0, Long::inc).first { location ->              seedRanges.any { it.contains( convert(location, reverseConversionTables) ) }        }
Just mwah! (chef kiss)

Junilu Lacar wrote:
You could even get rid of the "seed" explaining variable but I prefer to keep it.
   fun part2(): Long =        generateSequence(0, Long::inc).first { location ->              seedRanges.any { it.contains( convert(location, reverseConversionTables) ) }        }

I take it back. Should have tried it before posting. When I did this, the performance took a significant hit. I guess Kotlin is calling convert() multiple times when it evaluates the any() part. To keep the performance, you have to use that temporary seed variable so it's only executed once per iteration of the generated sequence. I profiled it again and this time part 2 took only 5,093ms to complete 20million iterations.

If you're interested, check out my final (maybe) solution code for Day 7: https://github.com/jlacar/aoc-2023-kotlin/blob/main/src/Day07.kt

I think that's about as tight as I can get my Kotlin at this point, but if you think there's another notch please let me know.

I just looked at Todd Ginsburg's Day 7 solution at https://github.com/tginsberg/advent-2023-kotlin/blob/main/src/main/kotlin/com/ginsberg/advent2023/Day07.kt and I think I finally came up with one that I like more than his, all bias aside.

Any thoughts?