Add Add Two Numbers (#131)

Author: igorwojda

README.md

@@ -114,6 +114,7 @@ multiple times and be persistent over time.
 - [Radix sort](src/test/kotlin/com/igorwojda/list/sort/radixsort)
 - [Doubly linked list](src/test/kotlin/com/igorwojda/linkedlist/doubly/base)
 - [Max binary heap](src/test/kotlin/com/igorwojda/tree/heap/maxbinaryheap)
+- [Add Numbers](src/test/kotlin/com/igorwojda/linkedlist/singly/addnumbers)
 
 **Expert**
 

misc/ChallengeGroups.md

@@ -101,6 +101,7 @@ We use sliding window instead of nested loops which decreases complexity from `O
 - [Circular linked list?](../src/test/kotlin/com/igorwojda/linkedlist/singly/circularcheck/README.md)
 - [Take n-th element from last](../src/test/kotlin/com/igorwojda/linkedlist/singly/fromlast/README.md)
 - [Midpoint](../src/test/kotlin/com/igorwojda/linkedlist/singly/midpoint/README.md)
+- [Add Numbers](../src/test/kotlin/com/igorwojda/linkedlist/singly/addnumbers)
 
 ## Doubly Linked List
 

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

@@ -0,0 +1,61 @@
+package com.igorwojda.linkedlist.singly.addnumbers
+
+import org.amshove.kluent.shouldBeEqualTo
+import org.junit.jupiter.api.Test
+
+private data class ListNode(
+    var data: Int,
+    var next: ListNode? = null,
+)
+
+private fun addTwoNumbers(l1: ListNode?, l2: ListNode?): ListNode? {
+    TODO("Add your solution here")
+}
+
+private class Test {
+    @Test
+    fun `add 5, 3, 7 to 2, 3, 3 returns 7, 3, 8`() {
+        val number1 = getList(5, 3, 7)
+        val number2 = getList(7, 3, 8)
+        val result = getList(2, 7, 5, 1)
+
+        addTwoNumbers(number1, number2) shouldBeEqualTo result
+    }
+
+    @Test
+    fun `add 0 to 0 returns 0`() {
+        val number1 = getList(0)
+        val number2 = getList(0)
+        val result = getList(0)
+
+        addTwoNumbers(number1, number2) shouldBeEqualTo result
+    }
+
+    @Test
+    fun `add 7 to 2, 3, 5 returns 9, 3, 5`() {
+        val number1 = getList(7)
+        val number2 = getList(2, 3, 5)
+        val result = getList(9, 3, 5)
+
+        addTwoNumbers(number1, number2) shouldBeEqualTo result
+    }
+
+    private fun getList(vararg ints: Int): ListNode? {
+        var head: ListNode? = null
+        var current: ListNode? = null
+
+        ints.forEach {
+            val node = ListNode(it)
+
+            if (head == null) {
+                head = node
+                current = node
+            } else {
+                current?.next = node
+                current = node
+            }
+        }
+
+        return head
+    }
+}

src/test/kotlin/com/igorwojda/linkedlist/singly/addnumbers/README.md

@@ -0,0 +1,25 @@
+# Add Numbers
+
+## Instructions
+
+Compute the sum of two non-empty linked lists, each representing a non-negative integer. he individual digits of these 
+integers are stored in the linked lists in reverse order, with each node holding a single digit. The result of the 
+addition should be returned as a linked list.
+
+[Challenge](Challenge.kt) | [Solution](Solution.kt)
+
+## Examples
+
+```kotlin
+private data class ListNode(
+    var data: Int,
+    var next: ListNode? = null,
+)
+
+val i1 = ListNode(1)
+i1.next = ListNode(3)
+
+val i2 = ListNode(11)
+
+addTwoNumbers(i1, i2) // returns ListNode(2, ListNode(4))
+```

src/test/kotlin/com/igorwojda/linkedlist/singly/addnumbers/Solution.kt

@@ -0,0 +1,51 @@
+package com.igorwojda.linkedlist.singly.addnumbers
+
+object Solution1 {
+    private fun addTwoNumbers(l1: ListNode?, l2: ListNode?): ListNode? {
+        val n1 = getNumber(l1)
+        val n2 = getNumber(l2)
+
+        val result = n1 + n2
+
+        return getList(result)
+    }
+
+    private fun getNumber(l1: ListNode?): Int {
+        var node = l1
+        var numberStr = ""
+
+        while (node != null) {
+            numberStr += node.data
+            node = node.next
+        }
+
+        return numberStr.reversed().toInt()
+    }
+
+    private fun getList(int: Int): ListNode? {
+        val intStr = int.toString().reversed()
+        var list: ListNode? = null
+        var lastListNode: ListNode? = null
+
+        intStr.forEach {
+            val node = ListNode(it.digitToInt())
+
+            if (list == null) {
+                list = node
+                lastListNode = node
+            } else {
+                lastListNode?.next = node
+                lastListNode = node
+            }
+        }
+
+        return list
+    }
+
+    private data class ListNode(
+        var data: Int,
+        var next: ListNode? = null,
+    )
+}
+
+private object KtLintWillNotComplain