new mixins for combinations/permutations, package mixins renamed to i…

…terables.

still some tests missing

lib/src/main/kotlin/de/linkel/aoc/utils/StringMixIn.kt

@@ -0,0 +1,14 @@
+package de.linkel.aoc.utils
+
+fun CharSequence.replaceIndex(idx: Int, char: Char): CharSequence {
+    if (idx < 0 || idx >= length)
+        throw IndexOutOfBoundsException("index $idx is out of bounds 0..${length-1}")
+    val sb = StringBuilder()
+    sb.appendRange(this, 0, idx)
+    sb.append(char)
+    sb.appendRange(this, idx + 1, length)
+    return sb
+}
+
+fun String.replaceIndex(idx: Int, char: Char): String =
+    (this as CharSequence).replaceIndex(idx, char).toString()

lib/src/main/kotlin/de/linkel/aoc/utils/graph/Graph.kt

@@ -6,7 +6,7 @@ data class Node<K>(
 )
 
 class Graph<K>(
-    nodes: Set<Node<K>>
+    val nodes: Set<Node<K>>
 ) {
     private val network = nodes.associateBy { it.id }
 
@@ -79,6 +79,28 @@ class Graph<K>(
             }
     }
 
+    fun subGraphs(): Iterable<Graph<K>> {
+        val results = mutableListOf<Set<Node<K>>>()
+        val all = network.keys.toMutableSet()
+        while (all.isNotEmpty()) {
+            val first = all.first()
+            val current = mutableSetOf<K>()
+            val queue = mutableListOf(first)
+            while (queue.isNotEmpty()) {
+                val node = queue.removeAt(0)
+                current.add(node)
+                queue.addAll(
+                    network[node]!!.edges.keys
+                       .filter { it !in current }
+                )
+            }
+            results.add(current.map { network[it]!! }.toSet())
+            all.removeAll(current)
+        }
+        return results
+            .map { Graph(it) }
+    }
+
     data class DijkstraNode<K>(
         val id: K,
         val distance: Int,

lib/src/main/kotlin/de/linkel/aoc/utils/grid/Segment.kt

@@ -0,0 +1,46 @@
+package de.linkel.aoc.utils.grid
+
+import kotlin.math.abs
+import kotlin.math.sign
+
+data class Segment(
+    val x: Int,
+    val y: Int
+) {
+    operator fun plus(v: Vector): Segment {
+        return copy(
+            x = x + v.deltaX,
+            y = y + v.deltaY
+        )
+    }
+    operator fun minus(p: Segment): Vector {
+        return Vector(
+            deltaX = x - p.x,
+            deltaY = y - p.y
+        )
+    }
+
+    operator fun rangeTo(p: Segment): List<Segment> {
+        if (p == this) {
+            return listOf(p)
+        }
+        val vector = p - this
+        return if (vector.deltaY == 0) {
+            (0 .. abs(vector.deltaX))
+                .map { i -> this.copy(
+                    x = x + (i) * vector.deltaX.sign
+                )}
+        } else if (vector.deltaX == 0) {
+            (0 .. abs(vector.deltaY))
+                .map { i -> this.copy(
+                    y = y + (i) * vector.deltaY.sign
+                )}
+        } else {
+            throw IllegalArgumentException("rangeTo only works in straight lines")
+        }
+    }
+
+    override fun toString(): String {
+        return "$x/$y"
+    }
+}

lib/src/main/kotlin/de/linkel/aoc/utils/iterables/CombinationMixIn.kt

@@ -0,0 +1,72 @@
+package de.linkel.aoc.utils.iterables
+
+fun <T> List<T>.combinationPairs(
+    withSelf: Boolean = false,
+    withMirrors: Boolean = false
+): Sequence<Pair<T,T>> {
+    val size = this.size
+    val list = this
+    return sequence {
+        (0 until size)
+            .forEach { i ->
+                ((if (withMirrors) 0 else i) until size)
+                    .forEach { j ->
+                        if (withSelf || i != j) {
+                            yield(Pair(list[i], list[j]))
+                        }
+                    }
+            }
+    }
+}
+
+fun <A, B> List<A>.combineWith(other: List<B>): Sequence<Pair<A, B>> {
+    val list = this
+    return sequence {
+        list
+            .forEach { a ->
+                other.forEach { b ->
+                        yield(Pair(a, b))
+                    }
+            }
+    }
+}
+
+fun <T> List<List<T>>.combinations(): Sequence<List<T>> {
+    val outer = this
+    return sequence {
+        val sizes = outer.map { it.size }
+        val indices = outer.map { 0 }.toMutableList()
+        while (indices.mapIndexed { i, o -> o < sizes[i] }.all { it }) {
+            yield(
+                indices.mapIndexed { i,o -> outer[i][o] }
+            )
+            if (outer.indices
+                .firstOrNull { i ->
+                    indices[i] = indices[i] + 1
+                    if (indices[i] >= sizes[i]) {
+                        indices[i] = 0
+                        false
+                    } else true
+            } == null) {
+                break
+            }
+        }
+    }
+}
+
+fun <T> List<T>.permutations(maxSize: Int = -1): Sequence<List<T>> {
+    val list = this
+    return sequence {
+        if (list.isEmpty() || maxSize == 0) {
+            yield(emptyList())
+        } else {
+            list.indices.forEach { i ->
+                val item = list[i]
+                list.withoutIndex(i).permutations(maxSize - 1)
+                    .forEach {
+                        yield(it + item)
+                    }
+            }
+        }
+    }
+}

lib/src/main/kotlin/de/linkel/aoc/utils/mixins/ConcatSequence.kt → lib/src/main/kotlin/de/linkel/aoc/utils/iterables/ConcatSequence.kt

@@ -1,4 +1,4 @@
-package de.linkel.aoc.utils.mixins
+package de.linkel.aoc.utils.iterables
 
 fun <T> Sequence<T>.prepend(element: T): Sequence<T> {
     return if (this is ConcatSequence<T>) {

lib/src/main/kotlin/de/linkel/aoc/utils/iterables/FilterMixIn.kt

@@ -0,0 +1,5 @@
+package de.linkel.aoc.utils.iterables
+
+
+fun <T> List<T>.withoutIndex(blacklist: IntRange) = this.filterIndexed { idx, _ -> idx !in blacklist }
+fun <T> List<T>.withoutIndex(index: Int) = this.filterIndexed { idx, _ -> idx != index }

lib/src/main/kotlin/de/linkel/aoc/utils/mixins/IntRangeMixIn.kt → lib/src/main/kotlin/de/linkel/aoc/utils/iterables/IntRangeMixIn.kt

@@ -1,4 +1,4 @@
-package de.linkel.aoc.utils.mixins
+package de.linkel.aoc.utils.iterables
 
 fun IntRange.intersects(other: IntRange): Boolean {
     return (this.first <= other.first && this.last >= other.first) || (other.first <= this.first && other.last >= this.first)

lib/src/main/kotlin/de/linkel/aoc/utils/mixins/LongRangeMixIn.kt → lib/src/main/kotlin/de/linkel/aoc/utils/iterables/LongRangeMixIn.kt

@@ -1,4 +1,4 @@
-package de.linkel.aoc.utils.mixins
+package de.linkel.aoc.utils.iterables
 
 fun LongRange.intersects(other: LongRange): Boolean {
     return (this.first <= other.first && this.last >= other.first) || (other.first <= this.first && other.last >= this.first)

lib/src/main/kotlin/de/linkel/aoc/utils/mixins/NumberIterables.kt → lib/src/main/kotlin/de/linkel/aoc/utils/iterables/NumberIterables.kt

@@ -1,4 +1,4 @@
-package de.linkel.aoc.utils.mixins
+package de.linkel.aoc.utils.iterables
 
 import de.linkel.aoc.utils.CommonMath
 import java.math.BigDecimal

lib/src/main/kotlin/de/linkel/aoc/utils/iterables/SplitSequenceMixIn.kt

@@ -0,0 +1,20 @@
+package de.linkel.aoc.utils.iterables
+
+
+fun <T> Sequence<T>.split(predicate: (T) -> Boolean): Sequence<List<T>> {
+    val input = this
+    return sequence {
+        val buffer = mutableListOf<T>()
+        input.forEach { element ->
+            if (predicate(element)) {
+                yield(buffer.toList())
+                buffer.clear()
+            } else {
+                buffer.add(element)
+            }
+        }
+        if (buffer.isNotEmpty()) {
+            yield(buffer.toList())
+        }
+    }
+}

lib/src/main/kotlin/de/linkel/aoc/utils/rangeset/AbstractNumberRangeSet.kt

@@ -1,6 +1,6 @@
 package de.linkel.aoc.utils.rangeset
 
-import de.linkel.aoc.utils.mixins.ConcatIterator
+import de.linkel.aoc.utils.iterables.ConcatIterator
 
 abstract class AbstractNumberRangeSet<O, T, R, C>(
     ranges: Iterable<R>,
@@ -25,7 +25,6 @@ abstract class AbstractNumberRangeSet<O, T, R, C>(
                 cache.add(range)
             }
         }
-        println("$ranges -> $cache")
         segments = cache.toList()
         first = segments.firstOrNull()?.start ?: factory.maxValue
         last = segments.lastOrNull()?.endInclusive ?: factory.minValue

lib/src/main/kotlin/de/linkel/aoc/utils/rangeset/IntRangeSet.kt

@@ -1,7 +1,7 @@
 package de.linkel.aoc.utils.rangeset
 
-import de.linkel.aoc.utils.mixins.intersect
-import de.linkel.aoc.utils.mixins.intersects
+import de.linkel.aoc.utils.iterables.intersect
+import de.linkel.aoc.utils.iterables.intersects
 
 class IntRangeSetFactory: RangeFactory<Int, IntRange, Int> {
     companion object {

lib/src/main/kotlin/de/linkel/aoc/utils/rangeset/LongRangeSet.kt

@@ -1,7 +1,7 @@
 package de.linkel.aoc.utils.rangeset
 
-import de.linkel.aoc.utils.mixins.intersect
-import de.linkel.aoc.utils.mixins.intersects
+import de.linkel.aoc.utils.iterables.intersect
+import de.linkel.aoc.utils.iterables.intersects
 
 class LongRangeSetFactory: RangeFactory<Long, LongRange, Long> {
     companion object {

lib/src/test/kotlin/de/linkel/aoc/utils/StringTest.kt

@@ -0,0 +1,11 @@
+package de.linkel.aoc.utils
+
+import org.assertj.core.api.Assertions
+import org.junit.jupiter.api.Test
+
+class StringTest {
+    @Test
+    fun `can replace s single character at a given position`() {
+        Assertions.assertThat("test".replaceIndex(1, '3')).isEqualTo("t3st")
+    }
+}