Add LRU Cache Challange (#138)

Author: igorwojda

README.md

@@ -131,7 +131,8 @@ multiple times and be persistent over time.
 - [Min sub list length](src/test/kotlin/com/igorwojda/list/minsublistlength)
 - [Subtract](src/test/kotlin/com/igorwojda/list/subtract)
 - [Coins](src/test/kotlin/com/igorwojda/list/coins)
-- [Medan Of Sorted Lists](src/test/kotlin/com/igorwojda/list/medianoftwosorted/README.md)
+- [Medan Of Sorted Lists](src/test/kotlin/com/igorwojda/list/medianoftwosorted)
+- [LRU Cache](src/test/kotlin/com/igorwojda/cache/lru)
 
 # Useful links
 

misc/ChallengeGroups.md

@@ -180,3 +180,7 @@ We use sliding window instead of nested loops which decreases complexity from `O
 - [Binary search tree](../src/test/kotlin/com/igorwojda/tree/binarysearchtree)
 - [Tree level width](../src/test/kotlin/com/igorwojda/tree/multiway/levelwidth)
 - [Tree traversal](../src/test/kotlin/com/igorwojda/tree/multiway/traversal)
+
+## Cache
+
+- [LRU Cache](../src/test/kotlin/com/igorwojda/cache/lru)

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

@@ -0,0 +1,52 @@
+package com.igorwojda.cache.lru
+
+import org.amshove.kluent.shouldBeEqualTo
+import org.junit.jupiter.api.Test
+
+class LRUCache(private val capacity: Int) {
+    val size: Int get() = TODO("Add your solution here")
+
+    fun get(key: Int): String? {
+        TODO("Add your solution here")
+    }
+
+    fun put(key: Int, value: String) {
+        TODO("Add your solution here")
+    }
+}
+
+private class Test {
+    @Test
+    fun `lru cache is empty after creation`() {
+        val lruCache = LRUCache(3)
+
+        lruCache.size shouldBeEqualTo 0
+    }
+
+    @Test
+    fun `oldest value is not removed from cache after capacity is exceeded`() {
+        val lruCache = LRUCache(2)
+
+        lruCache.put(1, "Person1")
+        lruCache.put(2, "Person2")
+        lruCache.put(3, "Person3")
+
+        lruCache.size shouldBeEqualTo 2
+        lruCache.get(1) shouldBeEqualTo null
+        lruCache.get(2) shouldBeEqualTo "Person2"
+        lruCache.get(3) shouldBeEqualTo "Person3"
+    }
+
+    @Test
+    fun `retrieved element becomes most recently used`() {
+        val lruCache = LRUCache(2)
+        lruCache.put(1, "Person1")
+        lruCache.put(2, "Person2")
+        lruCache.get(1)
+        lruCache.put(3, "Person3")
+
+        lruCache.get(1) shouldBeEqualTo "Person1"
+        lruCache.get(2) shouldBeEqualTo null
+        lruCache.get(3) shouldBeEqualTo "Person3"
+    }
+}

src/test/kotlin/com/igorwojda/cache/lru/README.md

@@ -0,0 +1,37 @@
+# LRU Cache
+
+## Instructions
+
+Design a data structure that follows the constraints of a 
+[Least Recently Used (LRU) cache](https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU).
+
+Implement the `LRUCache` class:
+
+`LRUCache` (int capacity) Initialize the LRU cache with positive size `capacity` and two methods:
+- `get(key: Int)` - return the value of the key if the key exists, otherwise return `null`.
+- `put(key: Int, value: String)` - update the value of the key if the key exists, otherwise, add the key-value pair 
+to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
+- `size` - currently used cache.
+
+The overall run time complexity of each methods should be `O(1)`.
+
+[Challenge](Challenge.kt) | [Solution](Solution.kt)
+
+## Examples
+
+```kotlin
+val lruCache = LRUCache(3)
+lruCache.size shouldBeEqualTo 0
+```
+
+```kotlin
+val lruCache = LRUCache(2)
+lruCache.put(1, 10)
+lruCache.put(2, 20)
+lruCache.put(3, 30)
+
+lruCache.size shouldBeEqualTo 2
+lruCache.get(1) shouldBeEqualTo null
+lruCache.get(2) shouldBeEqualTo 20
+lruCache.get(3) shouldBeEqualTo 30
+```

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

@@ -0,0 +1,160 @@
+package com.igorwojda.cache.lru
+
+// Implementation is using  combination of HashMap and LinkedList.
+// Time Complexity: O(1)
+private object Solution1 {
+    class LRUCache(private val capacity: Int) {
+        private val map = HashMap<Int, Node>()
+
+        private var head: Node? = null
+        private var tail: Node? = null
+
+        val size get() = map.size
+
+        fun put(key: Int, value: String) {
+            // 1. Check if node exicts
+            val existingNode = map[key]
+
+            if (existingNode == null) {
+                // 2. Check Map capacity
+                if (map.size >= capacity) {
+                    val removedNode = removeHead()
+                    map.remove(removedNode?.key)
+                }
+
+                // 3. Add a new node
+                val newNode = Node(key, value)
+
+                map[key] = newNode
+                addTail(newNode)
+            } else {
+                existingNode.value = value
+                moveToTail(existingNode)
+            }
+        }
+
+        private fun addTail(node: Node) {
+            // 1. If list is empty
+            if (head == null) {
+                head = node
+            } else {
+                node.prev = tail
+                tail?.next = node
+            }
+
+            tail = node
+        }
+
+        private fun removeHead(): Node? {
+            // 1. Head exists
+            if (head != null) {
+                // 2. Store current head to return
+                val node = head
+
+                // 3. Remove head
+                head = head?.next
+                head?.prev = null
+
+                // 4. Remove tail if head is tail
+                if (node == tail) tail = null
+
+                return node
+            }
+
+            return null
+        }
+
+        fun get(key: Int): String? {
+            // 1. get the node
+            val node = map[key]
+
+            // 2. Move to tail if exists
+            if (node != null) {
+                moveToTail(node)
+            }
+
+            // 3. Return value
+            return node?.value
+        }
+
+        private fun moveToTail(node: Node) {
+            // 1. Check if node is tail
+            if (node != tail) {
+                // 2. Remove node from list
+                if (node == head) {
+                    head = node.next
+                } else {
+                    node.prev?.next = node.next
+                    node.next?.prev = node.prev
+                }
+
+                // 3. Add node to tail
+                addTail(node)
+            }
+        }
+
+        private data class Node(
+            val key: Int,
+            var value: String,
+            var prev: Node? = null,
+            var next: Node? = null,
+        )
+    }
+}
+
+// Implementation using LinkedHashMap
+// Time Complexity: O(1)
+private object Solution2 {
+    class LRUCache(private val capacity: Int) {
+        val size get() = linkedHashMap.size
+
+        private val linkedHashMap = object :
+            LinkedHashMap<Int, String>(capacity, 0.75f, true) {
+            override fun removeEldestEntry(eldest: MutableMap.MutableEntry<Int, String>?): Boolean {
+                return size > capacity
+            }
+        }
+
+        fun put(key: Int, value: String) {
+            linkedHashMap[key] = value
+        }
+
+        fun get(key: Int): String? {
+            return linkedHashMap[key]?.also {
+                linkedHashMap.remove(key)
+                linkedHashMap[key] = it
+            }
+        }
+    }
+}
+
+// Implementation using List
+// Time Complexity: O(n)
+private object Solution3 {
+    class LRUCache(private val capacity: Int) {
+        private val list = mutableListOf<Pair<Int, String>>()
+
+        val size get() = list.size
+
+        fun get(key: Int): String? {
+            val value = list.firstOrNull { it.first == key }?.second
+
+            if (value != null) {
+                val pair = Pair(key, value)
+                list.remove(pair)
+                list.add(pair)
+            }
+
+            return list.firstOrNull { it.first == key }?.second
+        }
+
+        fun put(key: Int, value: String) {
+            list.removeIf { it.first == key }
+            list.add(Pair(key, value))
+
+            if (list.size > capacity) {
+                list.removeFirst()
+            }
+        }
+    }
+}

src/test/kotlin/com/igorwojda/integer/addupto/README.md

@@ -1,6 +1,7 @@
 # Add up to
 
 ## Instructions
+
 Given positive integer `n` implement a function which calculates sum of all numbers from `1` up to (and including)
 number `n`.
 

src/test/kotlin/com/igorwojda/linkedlist/doubly/base/Challenge.kt

@@ -1,7 +1,7 @@
 package com.igorwojda.linkedlist.doubly.base
 
 private class DoublyLinkedList<E> {
-    // implement
+    // Add your solution here
 }
 
 private data class Node<T>(

src/test/kotlin/com/igorwojda/linkedlist/singly/base/Challenge.kt

@@ -1,7 +1,7 @@
 package com.igorwojda.linkedlist.singly.base
 
 private class SinglyLinkedList<E> {
-    // implement
+    // Add your solution here
 }
 
 private data class Node<T>(