Use the MutableRingList in KnotHash

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/collections/MutableRingList.kt

@@ -1,9 +1,17 @@
 package de.ronny_h.aoc.extensions.collections
 
-class MutableRingList<T>(initialList: List<T>) {
-    private val list: MutableList<T> = initialList.toMutableList()
+class MutableRingList<T>(initialCapacity: Int) {
+    private val list: MutableList<T> = ArrayList<T>(initialCapacity)
     private var offset = 0
 
+    constructor(initialList: List<T>) : this(initialList.size) {
+        list.addAll(initialList)
+    }
+
+    constructor(size: Int, init: (index: Int) -> T) : this(size) {
+        repeat(size) { index -> list.add(init(index)) }
+    }
+
     companion object {
         fun <T> mutableRingListOf(vararg elements: T): MutableRingList<T> = MutableRingList(elements.toList())
         fun mutableRingListOf(elements: String): MutableRingList<Char> = MutableRingList(elements.toList())
@@ -48,6 +56,20 @@ class MutableRingList<T>(initialList: List<T>) {
         return this
     }
 
+    fun reverseSubList(s: Int, length: Int): MutableRingList<T> {
+        val start = (offset + s) % list.size
+        if (start + length < list.size) {
+            list.subList(start, start + length).toList()
+        } else {
+            list.subList(start, list.size) + list.subList(0, length - list.size + start)
+        }
+            .reversed()
+            .forEachIndexed { i, item ->
+                list[(start + i) % list.size] = item
+            }
+        return this
+    }
+
     /**
      * @return A snapshot of the current state of this [MutableRingList]
      */

src/main/kotlin/de/ronny_h/aoc/year2017/day10/KnotHash.kt

@@ -1,6 +1,7 @@
 package de.ronny_h.aoc.year2017.day10
 
 import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.collections.MutableRingList
 
 fun main() = KnotHash().run("3770", "a9d0e68649d0174c8756a59ba21d4dc6")
 
@@ -31,30 +32,18 @@ private fun sparseHash(
     lengths: List<Int>,
     rounds: Int = 1,
 ): List<Int> {
-    val circularList = MutableList(size) { it }
+    val circularList = MutableRingList(size) { it }
     var position = 0
     var skipSize = 0
 
-    fun reverseSubList(start: Int, length: Int) {
-        if (start + length < size) {
-            circularList.subList(start, start + length).toList()
-        } else {
-            circularList.subList(start, size) + circularList.subList(0, length - size + start)
-        }
-            .reversed()
-            .forEachIndexed { i, item ->
-                circularList[(start + i) % size] = item
-            }
-    }
-
     repeat(rounds) {
         lengths.forEach { length ->
-            reverseSubList(position, length)
+            circularList.reverseSubList(position, length)
             position = (position + length + skipSize) % size
             skipSize++
         }
     }
-    return circularList
+    return circularList.toList()
 }
 
 fun List<Int>.reduceToDenseHash() = chunked(16) {

src/test/kotlin/de/ronny_h/aoc/extensions/collections/MutableRingListTest.kt

@@ -6,14 +6,18 @@ import io.kotest.matchers.shouldBe
 
 class MutableRingListTest : StringSpec({
 
-    "a MutableRingList<Char> can be created from a variable amounts of Chars and toString() generates a nice representation" {
+    "a MutableRingList<Char> can be created from a variable amount of Chars and toString() generates a nice representation" {
         mutableRingListOf('a', 'b', 'c', 'd', 'e').toString() shouldBe "[a, b, c, d, e]"
     }
 
     "a MutableRingList<Char> can be created from a String and toJoinedString() recreates that String" {
         mutableRingListOf("abcde").toJoinedString() shouldBe "abcde"
     }
 
+    "a MutableRingList can be created with an initializer function" {
+        MutableRingList(6) { it }.toJoinedString() shouldBe "012345"
+    }
+
     "get(index) returns the element at index" {
         mutableRingListOf("abcde").get(2) shouldBe 'c'
         mutableRingListOf("abcde")[2] shouldBe 'c'
@@ -72,4 +76,16 @@ class MutableRingListTest : StringSpec({
         mutableRingListOf("abcde").swap('a', 'e').toJoinedString() shouldBe "ebcda"
         mutableRingListOf("abcde").swap('c', 'c').toJoinedString() shouldBe "abcde"
     }
+
+    "reversSubList on an unmodified ringList" {
+        mutableRingListOf(1, 2, 3, 4, 5, 6).reverseSubList(1, 4).toList() shouldBe listOf(1, 5, 4, 3, 2, 6)
+        mutableRingListOf(1, 2, 3, 4, 5, 6).reverseSubList(4, 4).toList() shouldBe listOf(6, 5, 3, 4, 2, 1)
+    }
+
+    "reversSubList on a shifted ringList" {
+        mutableRingListOf(1, 2, 3, 4, 5, 6).shiftRight(2)
+            .reverseSubList(1, 4).toList() shouldBe listOf(5, 3, 2, 1, 6, 4)
+        mutableRingListOf(1, 2, 3, 4, 5, 6).shiftRight(2)
+            .reverseSubList(4, 4).toList() shouldBe listOf(4, 3, 1, 2, 6, 5)
+    }
 })