Update kotlin

Author: igr

kotlin/build.gradle

@@ -3,9 +3,6 @@ plugins {
 }
 
 allprojects {
-    version = "1.0.0-SNAPSHOT"
-    group = "ac.obl.voidkt"
-
     repositories {
         mavenCentral()
     }
@@ -16,3 +13,6 @@ tasks.named('wrapper') {
     distributionType = Wrapper.DistributionType.ALL
 }
 
+dependencies {
+    implementation "org.jodd:jodd-util:6.0.0"
+}

kotlin/gradle.properties

@@ -1,4 +1,4 @@
-kotlin_version=1.7.20
+kotlin_version=1.9.10
 gradle_version=7.4.2
 kotlin.code.style=official
 

kotlin/src/main/kotlin/ac/obl/voidkt/terminal/Terminal.kt

@@ -0,0 +1,60 @@
+package challenge.height
+
+/**
+You are given an array A representing heights of students. All the students are asked to stand in rows. The students arrive by one, sequentially (as their heights appear in A). For the i-th student, if there is a row in which all the students are taller than A[i], the student will stand in one of such rows. If there is no such row, the student will create a new row. Your task is to find the minimum number of rows created.
+Write a function that, given a non-empty array A containing N integers, denoting the heights of the students, returns the minimum number of rows created.
+
+For example, given A = [5, 4, 3, 6, 1], the function should return 2.
+
+Students will arrive in sequential order from A[0] to A[N−1]. So, the first student will have height = 5, the second student will have height = 4, and so on.
+For the first student, there is no row, so the student will create a new row.
+Row1 = [5]
+For the second student, all the students in Row1 have height greater than 4. So, the student will stand in Row1.
+Row1 = [5, 4]
+Similarly, for the third student, all the students in Row1 have height greater than 3. So, the student will stand in Row1.
+Row1 = [5, 4, 3]
+For the fourth student, there is no row in which all the students have height greater than 6. So, the student will create a new row.
+Row1 = [5, 4, 3]
+Row2 = [6]
+For the fifth student, all the students in Row1 and Row2 have height greater than 1. So, the student can stand in either of the two rows.
+Row1 = [5, 4, 3, 1]
+Row2 = [6]
+Since two rows are created, the function should return 2.
+
+Assume that:
+N is an integer within the range [1..1,000]
+each element of array A is an integer within the range [1..10,000]
+ */
+class HeightRows {
+
+    data class Height(var value: Int)
+
+    fun calc(students: Array<Int>): Int {
+        val rows: MutableList<Height> = mutableListOf()
+
+        students.forEach { studentHeight ->
+            val minHeightFromAllMatchingRows: Height? =
+                rows
+                    .filter {
+                        // student may join this row, everyone is high(er)
+                        studentHeight < it.value
+                    }
+                    .minWith(Comparator { p1, p2 -> p1.value.compareTo(p2.value) })
+                    ?.let {
+                        it.value = studentHeight
+                        it
+                    }
+
+            if (minHeightFromAllMatchingRows == null) {
+                rows.add(Height(studentHeight))
+            }
+        }
+        return rows.size
+    }
+}
+
+fun main() {
+    println(HeightRows().calc(arrayOf(9, 5, 2)));
+    println(HeightRows().calc(arrayOf(9, 5, 10)));
+    println(HeightRows().calc(arrayOf(9, 2, 7, 1, 6)));
+}

kotlin/src/main/kotlin/challenge/height/HeightRows.kt

@@ -0,0 +1,63 @@
+package challenge.tvsm
+
+import challenge.tvsm.maze.*
+import challenge.tvsm.model.Candles
+import challenge.tvsm.model.HeroK
+import challenge.tvsm.model.HeroMinotaurK
+import challenge.tvsm.model.HeroTheseusK
+
+class TwoHeroes(val theseus: HeroTheseusK, val minotaur: HeroMinotaurK)
+class HeroAndCandles(val hero: HeroK, val candles: Candles)
+
+class MazeK(
+	private var theseus: HeroTheseusK,
+	private var minotaur: HeroMinotaurK,
+	private var candles: Candles = Candles()
+) {
+
+	fun minotaur(fn: (HeroMinotaurK) -> Unit) {
+		fn(minotaur)
+	}
+
+	fun theseus(fn: (HeroK) -> Unit) {
+		fn(theseus)
+	}
+
+	private fun heroes(): TwoHeroes  {
+		return TwoHeroes(theseus, minotaur)
+	}
+
+	fun solve() {
+		while (true) {
+
+			HeroAndCandles(minotaur, candles).run {
+				senseCandleInNextCavern(this)
+			}.ifCandleSeen {
+				turnBack(it)
+			}
+
+			minotaur(enterCavern)
+			enterCavern(theseus)
+
+			HeroAndCandles(theseus, candles).apply {
+				putCandleInHeroesCavern(this)
+			}
+
+			checkPlace(heroes())
+				.inSamePlace {
+					TheseusKillMinotaur(it)
+				}
+				.also { if (it) return@solve }
+
+			minotaur(enterLeftUnmarkedExit)
+			theseus(enterRightUnmarkedExit)
+
+			checkPlace(heroes())
+				.inSamePlace {
+					MinotaurKillTheseus(it)
+				}
+				.also { if (it) return@solve }
+		}
+	}
+
+}

kotlin/src/main/kotlin/challenge/tvsm/Maze.kt

@@ -0,0 +1,49 @@
+package challenge.tvsm
+
+import challenge.tvsm.model.*
+
+fun createMazeK(cavernPairs: Iterable<Pair<String, String>>,
+                theseusPair: Pair<String, String>,
+                minotaurPair: Pair<String, String>): MazeK {
+
+	// collect caverns first (as passages uses caverns)
+	val caverns: Set<MutableCavernK> = cavernPairs
+		.map { it.first }
+		.distinct()
+		.map { MutableCavernK(it) }
+		.toSet()
+
+	fun cavernOf(name: String): MutableCavernK {
+		return caverns.find { it.name == name } ?: throw IllegalArgumentException("Non-existing cavern: $name")
+	}
+
+	// then create _distinct_ passages
+	val passages = cavernPairs
+		.map { MutablePassageK(cavernOf(it.first), cavernOf(it.second)) }
+		.toSet()
+
+	// then add passages to caverns
+	fun passageOf(from: String, to: String) : MutablePassageK {
+		return passages.find {
+			(it.a.name == from && it.b.name == to) ||
+				(it.a.name == to && it.b.name == from)
+		} ?: throw IllegalArgumentException("Invalid passage $from - $to")
+	}
+
+	fun passageOf(pair: Pair<String, String>) : MutablePassageK {
+		return passageOf(pair.first, pair.second)
+	}
+
+	cavernPairs
+		.map { Pair(cavernOf(it.first), passageOf(it)) }
+		.forEach { it.first.addPassage(it.second) }
+
+
+	// finally put heroes in the maze
+
+	val theseus = HeroTheseusK(PositionInPassageK(passageOf(theseusPair), cavernOf(theseusPair.second), null))
+	val minotaur = HeroMinotaurK(PositionInPassageK(passageOf(minotaurPair), cavernOf(minotaurPair.second), null))
+
+	// *** We don't need to store the passages and caverns!
+	return MazeK(theseus, minotaur)
+}

kotlin/src/main/kotlin/challenge/tvsm/MazeBuilder.kt

@@ -0,0 +1,76 @@
+package challenge.tvsm
+
+import jodd.util.ResourcesUtil
+import jodd.util.StringPool
+
+// *** just a quick-and-dirty text parser
+class MazeLoader {
+	// utility class that controls the lifespan and usage of caverns set
+	class Caverns {
+		var caverns = new()
+
+		private fun new(): MutableList<Pair<String, String>> {
+			return mutableListOf()
+		}
+
+		fun add(pairs: Iterable<Pair<String, String>>) {
+			caverns.addAll(pairs)
+		}
+
+		fun get(): Iterable<Pair<String, String>> {
+			val result = caverns;
+			caverns = new()
+			return result;
+		}
+	}
+
+	fun loadMazes(): List<MazeK> {
+		val mazes = mutableListOf<MazeK>()
+		val caverns = Caverns()
+		val input = ResourcesUtil.getResourceAsString("challenge/theseusvsminotaur/in1.txt")
+
+		input
+			.lines()
+			.forEach { line ->
+				println(line)
+
+				if (isEndOfFile(line)) {
+					return@forEach
+				}
+
+				if (isEndOfMaze(line)) {
+					// positions of Theseus and Minotaur
+
+					val theseus = line[1].toString() to line[2].toString()
+					val minotaur = line[3].toString() to line[4].toString()
+
+					mazes.add(createMazeK(caverns.get(), theseus, minotaur))
+				} else {
+					// caverns
+
+					val ndx = line.indexOf(':')
+					val cavernName = line.substring(0, ndx)
+
+					line.substring(ndx + 1)
+						.toCharArray()
+						.map { it.toString() }
+						.map { cavernName to it }
+						.toList()
+						.let {
+							caverns.add(it)
+						}
+				}
+			}
+
+		return mazes
+	}
+
+	private fun isEndOfMaze(line: String): Boolean {
+		return line.startsWith(StringPool.AT)
+	}
+
+	private fun isEndOfFile(line: String): Boolean {
+		return line == StringPool.HASH
+	}
+
+}

kotlin/src/main/kotlin/challenge/tvsm/MazeLoader.kt

@@ -0,0 +1,13 @@
+package challenge.tvsm
+
+
+fun main() {
+	MazeLoader()
+		.loadMazes()
+		.stream()
+		.forEach {
+			println("---------------------------")
+			it.solve()
+		}
+
+}

kotlin/src/main/kotlin/challenge/tvsm/TM.kt

@@ -0,0 +1,12 @@
+package challenge.tvsm.maze
+
+import challenge.tvsm.model.HeroK
+
+val enterCavern = fun(hero: HeroK) {
+	return hero.doInPassage {
+		it.stepIntoCavern()
+	}.let {
+		hero.move(it)
+	}
+}
+

kotlin/src/main/kotlin/challenge/tvsm/maze/EnterCavern.kt

@@ -0,0 +1,34 @@
+package challenge.tvsm.maze
+
+import challenge.tvsm.model.HeroK
+
+val enterLeftUnmarkedExit = fun(hero: HeroK) {
+	hero.doInCavern {
+		var pp = it.previousPassage
+		while (true) {
+			val leftPassage = it.cavern.leftPassageOf(pp)
+			val otherCave = leftPassage.otherEndOf(it.cavern)
+			if (!hero.usedExitTo(otherCave)) {
+				hero.move(it.enterPassage(leftPassage))
+				break
+			}
+			pp = leftPassage
+		}
+	}
+}
+
+val enterRightUnmarkedExit = fun(hero: HeroK) {
+	hero.doInCavern {
+		var pp = it.previousPassage
+		while (true) {
+			val rightPassage = it.cavern.rightPassageOf(pp)
+			val otherCave = rightPassage.otherEndOf(it.cavern)
+			if (!hero.usedExitTo(otherCave)) {
+				hero.move(it.enterPassage(rightPassage))
+				break
+			}
+			pp = rightPassage
+		}
+	}
+
+}