A modern programming language that makes developers happier.

kotlinlang

Day 4: <https://github.com/tginsberg/advent-2019-kotlin/blob/master/src/main/kotlin/com/ginsberg/advent2019/Day04.kt>

Mine probably isn't super efficient, I go over the candidates a few times. But I'm aiming for clarity so I'm happy with it.

oooh, zipWithNext. I used `v.zip(v.drop(1))`

It's amazing what's in the Kotlin Standard Library, isn't it?

I guess I will have to try to use a more functional approach for the next days. Your solution is so much more elegant than my simple for loop :wink:. However I only loop over each number once and not twice.

Also `containsMatchingPair(it) &amp;&amp; containsIsolatedPair(it)` is a bit overkill since `containsIsolatedPair(it)` already implies `containsMatchingPair(it)`

technically it doesn't.
`isSorted &amp;&amp; containsIsolatedPair -&gt; containsMatchingPair` though

Yeah, mine is probably not as efficient as it could be. But my goal is to a) Solve the AoC problem and not the general case of problems like that and b) Explain it to people (I blog about each day, which I'll write later after work). So my code almost always sacrifices speed for explainability. :slightly_smiling_face:

Totally agree with those goals. That said `isSorted(it) && containsMatchingPair(it) && containsIsolatedPair(it)` looks like those a 3 separate conditions, while in fact they are only 2.

Yeah, that's true. I'll fix that. :slightly_smiling_face:

Ah damn, I thought I couldn't use `groupBy`  but I now realize you can, as a side-effect of also checking that the numbers are ever-increasing! Clever stuff

Not realizing this made my solution ugly:
```fun Int.groupedDigits(): List&lt;List&lt;Char&gt;&gt; {
  val result = mutableListOf(mutableListOf&lt;Char&gt;())
  this.toString().forEach {
    if (result.last().contains(it)) {
      result.last().add(it)
    } else {
      result.add(mutableListOf(it))
    }
  }
  return result.drop(1)
}

fun Int.isValidPassword2(): Boolean {
  val groups = this.groupedDigits()
  val hasIsolatedPair = groups.any { it.size == 2 }
  val everIncreasing = groups.windowed(2).all { 
    it[0].first() &lt; it[1].first()
  }
  return hasIsolatedPair &amp;&amp; everIncreasing
}```


Interestingly, I made a function similar to <@UDDTUDN4F>’s and was surprised to find that it performs a couple of ms better than `groupBy { it }.any { it.value.size == 2 }`.

I was about to make the same comments about `groupBy` not working as <@UDDTUDN4F>, pretty clever.

Assuming you actually thought about it of course :wink: