Add time and space complexity comments to solutions (#247)

Author: igorwojda

misc/template/challenge/Solution.kt

@@ -1,13 +1,15 @@
 package com.igorwojda.challenge
 
 // Time complexity: O(?)
+// Space complexity: O(?)
 private object Solution1 {
     private fun challenge(str: String): String {
         TODO()
     }
 }
 
 // Time complexity: O(?)
+// Space complexity: O(?)
 private object Solution2 {
     private fun challenge(str: String): String {
         TODO()

src/test/kotlin/com/igorwojda/cache/advancedlru/Solution.kt

@@ -5,7 +5,10 @@ import java.time.Duration
 import java.util.PriorityQueue
 
 // Implementation is using  combination of HashMap and PriorityQueue.
-// Time Complexity: O(N) (JVM priority queue is O(log(n)) on offer/poll methods and O(N) on remove(item) method)
+// Time complexity:
+// put: O(n) - plus O(n) per expired item evicted; PriorityQueue.remove(item) is O(n), offer/poll O(log n)
+// get: O(n) - PriorityQueue.remove(item) is O(n)
+// Space complexity: O(n) - n is number of cached items
 internal object Solution1 {
     class AdvancedLRUCache<K : Any, V : Any>(private val capacity: Int, private val clock: Clock = Clock.systemDefaultZone()) : LRUCache<K, V> {
         private val map: MutableMap<K, CacheItem<K, V>> = mutableMapOf()

src/test/kotlin/com/igorwojda/cache/lru/Solution.kt

@@ -1,7 +1,10 @@
 package com.igorwojda.cache.lru
 
 // Implementation is using  combination of HashMap and LinkedList.
-// Time Complexity: O(1)
+// Time complexity:
+// put: O(1)
+// get: O(1)
+// Space complexity: O(n) - n is capacity
 object Solution1 {
     class LRUCacheImpl<K : Any, V : Any>(
         private val capacity: Int,
@@ -111,7 +114,10 @@ object Solution1 {
 }
 
 // Implementation using LinkedHashMap
-// Time Complexity: O(1)
+// Time complexity:
+// put: O(1)
+// get: O(1)
+// Space complexity: O(n) - n is capacity
 object Solution2 {
     class LRUCacheImpl<K : Any, V : Any>(
         private val capacity: Int,
@@ -139,7 +145,10 @@ object Solution2 {
 }
 
 // Implementation using List
-// Time Complexity: O(n)
+// Time complexity:
+// put: O(n) - removeIf and removeFirst on ArrayList
+// get: O(n) - linear search and remove
+// Space complexity: O(n) - n is capacity
 object Solution3 {
     class LRUCacheImpl<K : Any, V : Any>(
         private val capacity: Int,

src/test/kotlin/com/igorwojda/common/anycallback/Solution.kt

@@ -1,5 +1,7 @@
 package com.igorwojda.common.anycallback
 
+// Time complexity: O(n^2) - drop(1) copies the list at each level
+// Space complexity: O(n^2) - each stack frame holds its own dropped copy
 internal object Solution1 {
     fun <T : Any> anyCallback(
         list: List<T>,
@@ -17,6 +19,8 @@ internal object Solution1 {
     }
 }
 
+// Time complexity: O(n) - subList is an O(1) view
+// Space complexity: O(n) - recursion call stack
 internal object Solution2 {
     fun <T : Any> anyCallback(
         list: List<T>,
@@ -27,6 +31,8 @@ internal object Solution2 {
     }
 }
 
+// Time complexity: O(n) - O(n^2) for non-RandomAccess lists (drop copies)
+// Space complexity: O(n) - recursion call stack; O(n^2) for non-RandomAccess lists
 internal object Solution3 {
     fun <T : Any> anyCallback(
         list: List<T>,

src/test/kotlin/com/igorwojda/integer/addupto/Solution.kt

@@ -1,16 +1,22 @@
 package com.igorwojda.integer.addupto
 
 // Kotlin idiomatic solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution1 {
     private fun addUpTo(n: Int): Int = (1..n).sum()
 }
 
 // Kotlin idiomatic solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution2 {
     private fun addUpTo(n: Int): Int = (0..n).fold(0) { accumulated, current -> accumulated + current }
 }
 
 // Recursive solution
+// Time complexity: O(n)
+// Space complexity: O(n) - recursion call stack
 private object Solution3 {
     private fun addUpTo(n: Int): Int {
         if (n == 1) {
@@ -21,14 +27,16 @@ private object Solution3 {
     }
 }
 
-// Time Complexity: O(1)
 // Mathematical formula
+// Time complexity: O(1)
+// Space complexity: O(1)
 private object Solution4 {
     private fun addUpTo(n: Int): Int = n * (n + 1) / 2
 }
 
-// Time Complexity: O(n)
 // Iterative solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution5 {
     private fun addUpTo(n: Int): Int {
         var total = 0
@@ -40,6 +48,8 @@ private object Solution5 {
 }
 
 // Iterative solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution6 {
     private fun addUpTo(n: Int): Int {
         var total = 0

src/test/kotlin/com/igorwojda/integer/countdown/Solution.kt

@@ -1,6 +1,8 @@
 package com.igorwojda.integer.countdown
 
 // Kotlin idiomatic solution
+// Time complexity: O(n)
+// Space complexity: O(n)
 private object Solution1 {
     private fun countDown(n: Int): List<Int> {
         // Create a range and convert it to a list
@@ -9,6 +11,8 @@ private object Solution1 {
 }
 
 // Recursive solution
+// Time complexity: O(n^2) - each level copies the result of the recursive call
+// Space complexity: O(n) - result list and recursion call stack
 private object Solution2 {
     private fun countDown(n: Int): List<Int> {
         if (n == 0) {
@@ -20,6 +24,8 @@ private object Solution2 {
 }
 
 // Recursive solution with helper function
+// Time complexity: O(n^2) - each level copies the result of the recursive call
+// Space complexity: O(n) - result list and recursion call stack
 private object Solution3 {
     private fun countDown(n: Int): List<Int> {
         // We want to keep return type unchanged while implementing recursive solution, so we will
@@ -37,6 +43,8 @@ private object Solution3 {
 }
 
 // Kotlin idiomatic solution
+// Time complexity: O(n)
+// Space complexity: O(n)
 private object Solution4 {
     private fun countDown(n: Int): List<Int> = List(n + 1) { n - it }
 }

src/test/kotlin/com/igorwojda/integer/countupanddown/Solution.kt

@@ -1,6 +1,8 @@
 package com.igorwojda.integer.countupanddown
 
 // Calculate element value from element position
+// Time complexity: O(n)
+// Space complexity: O(n)
 private object Solution1 {
     private fun countUpAndDown(n: Int): List<Int> {
         val size = (n * 2) + 1
@@ -15,6 +17,8 @@ private object Solution1 {
 }
 
 // Returns a new list combining one collection of numbers from 0 to n-1 and another with numbers from n to 0
+// Time complexity: O(n)
+// Space complexity: O(n)
 private object Solution2 {
     private fun countUpAndDown(n: Int): List<Int> = (0 until n) + (n downTo 0)
 }

src/test/kotlin/com/igorwojda/integer/digitfrequency/Solution.kt

@@ -1,7 +1,8 @@
 package com.igorwojda.integer.digitfrequency
 
-// Time complexity: O(n)
 // Generate digit frequency map for each integer and compare them
+// Time complexity: O(d) - d is number of digits
+// Space complexity: O(d)
 private object Solution1 {
     private fun equalDigitFrequency(
         i1: Int,
@@ -20,9 +21,10 @@ private object Solution1 {
     }
 }
 
-// Time complexity: O(n^2)
 // Loop through each character of first integer and look for this character in another integer. If character if found
 // remove it from second integer to make sure that character frequency match.
+// Time complexity: O(d^2) - d is number of digits; indexOf and removeAt are O(d)
+// Space complexity: O(d)
 private object Solution2 {
     private fun equalDigitFrequency(
         i1: Int,

src/test/kotlin/com/igorwojda/integer/factorial/Solution.kt

@@ -1,6 +1,8 @@
 package com.igorwojda.integer.factorial
 
 // iterative solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution1 {
     private fun factorial(n: Int): Int {
         var total = 1
@@ -14,6 +16,8 @@ private object Solution1 {
 }
 
 // another iterative solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution2 {
     private fun factorial(n: Int): Int = when (n) {
         0 -> 1
@@ -22,6 +26,8 @@ private object Solution2 {
 }
 
 // recursive solution
+// Time complexity: O(n)
+// Space complexity: O(n) - recursion call stack
 private object Solution3 {
     private fun factorial(n: Int): Int = when (n) {
         0, 1 -> 1
@@ -30,6 +36,8 @@ private object Solution3 {
 }
 
 // Tail-recursive solution
+// Time complexity: O(n)
+// Space complexity: O(n) - recursion call stack (no tailrec modifier, so not optimized)
 private object Solution4 {
     private fun factorial(n: Int): Int {
         fun fact(

src/test/kotlin/com/igorwojda/integer/fibonacci/basic/Solution.kt

@@ -1,6 +1,8 @@
 package com.igorwojda.integer.fibonacci.basic
 
 // iterative solution
+// Time complexity: O(n)
+// Space complexity: O(1)
 private object Solution1 {
     private fun fibonacci(n: Int): Int {
         if (n < 2) {
@@ -22,6 +24,8 @@ private object Solution1 {
 }
 
 // iterative solution with temporary list (not efficient)
+// Time complexity: O(n)
+// Space complexity: O(n)
 private object Solution2 {
     private fun fibonacci(n: Int): Int {
         val list = mutableListOf(0, 1)
@@ -35,6 +39,8 @@ private object Solution2 {
 }
 
 // recursive solution
+// Time complexity: O(2^n)
+// Space complexity: O(n) - recursion call stack
 private object Solution3 {
     private fun fibonacci(n: Int): Int = when (n) {
         0 -> 0
@@ -44,6 +50,8 @@ private object Solution3 {
 }
 
 // recursive solution
+// Time complexity: O(2^n)
+// Space complexity: O(n) - recursion call stack
 private object Solution4 {
     private fun fibonacci(n: Int): Int {
         if (n < 2) {