Merge branch 'main' into renovate/protobuf

# Conflicts:
#	gradle/libs.versions.toml

Author: ashtanko

.github/workflows/build.yml

@@ -38,7 +38,7 @@ jobs:
         run: chmod +x gradlew
 
       - name: Cache Gradle dependencies
-        uses: actions/cache@v4.2.2
+        uses: actions/cache@v4.2.3
         with:
           path: ${{ env.GRADLE_HOME }}/caches
           key: |

README.md

@@ -22,22 +22,22 @@
 
 ### Metrics
 ```text
-14883 number of properties
-10262 number of functions
-8797 number of classes
-227 number of packages
-3461 number of kt files
+14991 number of properties
+10385 number of functions
+8856 number of classes
+229 number of packages
+3486 number of kt files
 ```
 
 
 ### Complexity Report
 ```text
-257847 lines of code (loc)
-157813 source lines of code (sloc)
-115157 logical lines of code (lloc)
-72253 comment lines of code (cloc)
-24539 cyclomatic complexity (mcc)
-20171 cognitive complexity
+259507 lines of code (loc)
+158943 source lines of code (sloc)
+115975 logical lines of code (lloc)
+72503 comment lines of code (cloc)
+24705 cyclomatic complexity (mcc)
+20233 cognitive complexity
 0 number of total code smells
 45 comment source ratio
 213 mcc per 1,000 lloc

build.gradle.kts

@@ -51,7 +51,7 @@ plugins {
 }
 
 jacoco {
-    toolVersion = "0.8.12"
+    toolVersion = "0.8.13"
 }
 
 repositories {
@@ -330,8 +330,8 @@ dependencies {
         implementation("org.openjdk.jol:jol-core:0.17")
         implementation("com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:1.0.0")
         implementation(jsoup)
-        implementation("com.google.protobuf:protobuf-java:4.30.0")
-        implementation("com.google.protobuf:protobuf-kotlin-lite:4.30.0")
+        implementation("com.google.protobuf:protobuf-java:4.30.2")
+        implementation("com.google.protobuf:protobuf-kotlin-lite:4.30.2")
         implementation("io.grpc:grpc-stub:1.71.0")
         implementation("io.grpc:grpc-protobuf:1.71.0")
 

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 coroutines = "1.10.1"       # https://github.com/Kotlin/kotlinx.coroutines
-junit = "5.12.0"            # https://junit.org/junit5 | https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter
-kotlin = "2.1.10"           # https://github.com/JetBrains/kotlin
+junit = "5.12.1"            # https://junit.org/junit5 | https://central.sonatype.com/artifact/org.junit.jupiter/junit-jupiter
+kotlin = "2.1.20"           # https://github.com/JetBrains/kotlin
 detekt = "1.23.8"           # https://github.com/detekt/detekt
 dokka = "2.0.0"             # https://github.com/Kotlin/dokka
 spotless = "7.0.2"          # https://github.com/diffplug/spotless
@@ -13,17 +13,17 @@ slf4j = "2.0.17"            # https://www.slf4j.org TODO remove
 rxjava = "3.1.10"            # https://github.com/ReactiveX/RxJava TODO remove
 rxkotlin = "3.0.1"          # https://github.com/ReactiveX/RxKotlin TODO remove
 lincheck = "2.36"           # https://github.com/JetBrains/lincheck
-serialization = "1.8.0"     # https://github.com/Kotlin/kotlinx.serialization
+serialization = "1.8.1"     # https://github.com/Kotlin/kotlinx.serialization
 retrofit = "2.11.0"         # https://github.com/square/retrofit TODO remove
 okhttp = "5.0.0-alpha.14"   # https://square.github.io/okhttp/changelogs/changelog TODO remove
-dagger = "2.55"           # https://dagger.dev TODO remove
+dagger = "2.56.1"           # https://dagger.dev TODO remove
 jmh = "1.37"                # https://github.com/openjdk/jmh
 kotlintest = "3.4.2"        # https://mvnrepository.com/artifact/io.kotlintest/kotlintest-core
 kotest = "5.9.1"            # https://kotest.io
 assertj = "3.27.3"          # https://mvnrepository.com/artifact/org.assertj/assertj-core | https://assertj.github.io/doc
-mockito = "5.16.0"          # https://mvnrepository.com/artifact/org.mockito/mockito-core
+mockito = "5.17.0"          # https://mvnrepository.com/artifact/org.mockito/mockito-core
 mockito_kotlin = "5.4.0"    # https://github.com/mockito/mockito-kotlin
-logback = "1.5.17"          # https://logback.qos.ch
+logback = "1.5.18"          # https://logback.qos.ch
 hamcrest = "3.0"            # https://hamcrest.org/JavaHamcrest/distributables
 mockk = "1.13.17"           # https://mockk.io
 kover = "0.9.1"             # https://github.com/Kotlin/kotlinx-kover
@@ -33,7 +33,7 @@ turbine = "1.2.0"           # https://github.com/cashapp/turbine/releases
 truth = "1.4.4"             # https://central.sonatype.com/artifact/com.google.truth/truth/overview
 sandwich = "2.1.0"          # https://github.com/skydoves/sandwich
 protobuf = "0.9.4"
-protoc = "4.30.0"
+protoc = "4.30.2"
 
 [libraries]
 kotlin-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "coroutines" }

src/main/kotlin/dev/shtanko/algorithms/img/call_stack_visualization.svg

@@ -0,0 +1,98 @@
+package dev.shtanko.algorithms.recursion
+
+internal interface PrettyPrintFib {
+    operator fun invoke(n: Int, depth: Int = 0, log: StringAppender = StringAppenderImpl()): Int
+}
+
+internal class PrettyPrintFibRecursion : PrettyPrintFib {
+
+    private fun logCall(n: Int, depth: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Call: fib($n)\n")
+    }
+
+    private fun logReturn(n: Int, depth: Int, result: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Return: fib($n) = $result\n")
+    }
+
+    override fun invoke(n: Int, depth: Int, log: StringAppender): Int {
+        logCall(n, depth, log)
+
+        // Base case: return 0 or 1 for n = 0 or n = 1
+        if (n == 0) {
+            logReturn(n, depth, 0, log)
+            return 0
+        }
+        if (n == 1) {
+            logReturn(n, depth, 1, log)
+            return 1
+        }
+
+        // Recursive calls to calculate fib(n-1) and fib(n-2)
+        val result = invoke(n - 1, depth + 1, log) + invoke(n - 2, depth + 1, log)
+
+        logReturn(n, depth, result, log)
+        return result
+    }
+}
+
+internal class PrettyPrintFibOptimized : PrettyPrintFib {
+
+    private val memo = mutableMapOf<Int, Int>() // Cache to store Fibonacci results
+
+    private fun logCall(n: Int, depth: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Call: fib($n)\n")
+    }
+
+    private fun logReturn(n: Int, depth: Int, result: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Return: fib($n) = $result\n")
+    }
+
+    override fun invoke(n: Int, depth: Int, log: StringAppender): Int {
+        logCall(n, depth, log)
+
+        // Check the memoization cache before proceeding with recursion
+        memo[n]?.let {
+            logReturn(n, depth, it, log)
+            return it // Return cached value
+        }
+
+        // Base case: return 0 or 1 for n = 0 or n = 1
+        if (n == 0) {
+            logReturn(n, depth, 0, log)
+            return 0
+        }
+        if (n == 1) {
+            logReturn(n, depth, 1, log)
+            return 1
+        }
+
+        // Recursive calls to calculate fib(n-1) and fib(n-2), and store the result in the cache
+        val result = invoke(n - 1, depth + 1, log) + invoke(n - 2, depth + 1, log)
+
+        memo[n] = result // Cache the result
+        logReturn(n, depth, result, log)
+        return result
+    }
+}
+
+internal class PrettyPrintFibTailRec : PrettyPrintFib {
+
+    // Tail-recursive function for Fibonacci
+    private tailrec fun fibTailRec(n: Int, depth: Int, log: StringAppender, prev: Int = 0, current: Int = 1): Int {
+        // Log the current call with depth
+        log.append("  ".repeat(depth) + "Call: fib($n, prev=$prev, current=$current)\n")
+
+        // Base case: return the current value when n reaches 0
+        if (n == 0) {
+            log.append("  ".repeat(depth) + "Return: fib($n) = $prev\n")
+            return prev
+        }
+
+        // Recursive case: move to the next Fibonacci number
+        return fibTailRec(n - 1, depth + 1, log, current, prev + current)
+    }
+
+    override fun invoke(n: Int, depth: Int, log: StringAppender): Int {
+        return fibTailRec(n, depth, log)
+    }
+}

src/main/kotlin/dev/shtanko/algorithms/img/understanding_recursion.svg

@@ -0,0 +1,55 @@
+package dev.shtanko.algorithms.recursion
+
+internal interface PrettyPrintPalindrome {
+    operator fun invoke(
+        str: String,
+        left: Int = 0,
+        right: Int = str.length - 1,
+        depth: Int = 0,
+        log: StringAppender = StringAppenderImpl(),
+    ): Boolean
+}
+
+internal class PrettyPrintPalindromeRecursion : PrettyPrintPalindrome {
+
+    private fun logCall(str: String, left: Int, right: Int, depth: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Call: isPalindrome(\"$str\", left=$left, right=$right)\n")
+    }
+
+    private fun logReturn(left: Int, right: Int, result: Boolean, depth: Int, log: StringAppender) {
+        log.append("  ".repeat(depth) + "Return: isPalindrome(left=$left, right=$right) = $result\n")
+    }
+
+    override fun invoke(str: String, left: Int, right: Int, depth: Int, log: StringAppender): Boolean {
+        logCall(str, left, right, depth, log)
+
+        // Base case: if pointers have met or crossed, it's a palindrome
+        if (left >= right) {
+            logReturn(left, right, true, depth, log)
+            return true
+        }
+
+        // If characters at left and right don't match, return false
+        if (str[left] != str[right]) {
+            logReturn(left, right, false, depth, log)
+            return false
+        }
+
+        // Recursive call moving inward
+        val result = invoke(str, left + 1, right - 1, depth + 1, log)
+
+        logReturn(left, right, result, depth, log)
+        return result
+    }
+}
+
+fun main() {
+    val palindromeChecker = PrettyPrintPalindromeRecursion()
+    val log = StringAppenderImpl()
+
+    val input = "racecar"
+    val result = palindromeChecker.invoke(input, 0, input.length - 1, 0, log)
+
+    println("Is \"$input\" a palindrome? $result")
+    println("Log:\n${log.get()}")
+}

src/main/kotlin/dev/shtanko/algorithms/recursion/PrettyPrintFib.kt

@@ -0,0 +1,58 @@
+package dev.shtanko.algorithms.recursion
+
+/**
+ * An interface defining a contract for appending strings and retrieving the final result.
+ */
+internal interface StringAppender {
+
+    /**
+     * Appends the given [str] to the internal string representation.
+     *
+     * @param str The string to append.
+     */
+    fun append(str: String)
+
+    /**
+     * Retrieves the current concatenated string.
+     *
+     * @return The complete string built so far.
+     */
+    fun get(): String
+
+    /**
+     * Clears the internal string representation, resetting it to an empty state.
+     */
+    fun clear()
+}
+
+/**
+ * A concrete implementation of [StringAppender] using [StringBuilder] for efficient string operations.
+ */
+internal class StringAppenderImpl : StringAppender {
+    private val sb = StringBuilder()
+
+    /**
+     * Appends the given [str] to the internal [StringBuilder].
+     *
+     * @param str The string to append.
+     */
+    override fun append(str: String) {
+        sb.append(str)
+    }
+
+    /**
+     * Retrieves the concatenated string from the internal [StringBuilder].
+     *
+     * @return The complete string built so far.
+     */
+    override fun get(): String {
+        return sb.toString()
+    }
+
+    /**
+     * Clears the internal [StringBuilder], resetting it to an empty state.
+     */
+    override fun clear() {
+        sb.setLength(0)
+    }
+}