Merge pull request ByteByteGoHq#11 from marttp/kotlin-solutions-fast-and-slow-pointers

Kotlin chapter 4 - Fast and Slow Pointers

Author: Destiny-02

kotlin/Fast and Slow Pointers/HappyNumber.kt

@@ -0,0 +1,30 @@
+fun happyNumber(n: Int): Boolean {
+    var slow = n
+    var fast = n
+    while (true) {
+        slow = getNextNum(slow)
+        fast = getNextNum(getNextNum(fast))
+        if (fast == 1) {
+            return true
+        // If the fast and slow pointers meet, a cycle is detected. 
+        // Hence, 'n' is not a happy number.
+        } else if (fast == slow) {
+            return false
+        }
+    }
+}
+
+fun getNextNum(x: Int): Int {
+    var nextNum = 0
+    var num = x
+    while (num > 0) {
+        // Extract the last digit of 'x'.
+        val digit = num % 10
+        // Truncate (remove) the last digit from 'x' using floor 
+        // division.
+        num /= 10
+        // Add the square of the extracted digit to the sum.
+        nextNum += digit * digit
+    }
+    return nextNum
+}

kotlin/Fast and Slow Pointers/LinkedListLoop.kt

@@ -0,0 +1,19 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListLoop(head: ListNode?): Boolean {
+    var slow = head
+    var fast = head
+    // Check both 'fast' and 'fast.next' to avoid null pointer
+    // exceptions when we perform 'fast.next' and 'fast.next.next'.
+    while (fast != null && fast.next != null) {
+        slow = slow!!.next
+        fast = fast.next!!.next
+        if (fast == slow) {
+            return true
+        }
+    }
+    return false
+}

kotlin/Fast and Slow Pointers/LinkedListLoopNaive.kt

@@ -0,0 +1,18 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListLoopNaive(head: ListNode?): Boolean {
+    val visited = mutableSetOf<ListNode>()
+    var curr = head
+    while (curr != null) {
+        // Cycle detected if the current node has already been visited.
+        if (visited.contains(curr)) {
+            return true
+        }
+        visited.add(curr)
+        curr = curr.next
+    }
+    return false
+}

kotlin/Fast and Slow Pointers/LinkedListMidpoint.kt

@@ -0,0 +1,16 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListMidpoint(head: ListNode?): ListNode? {
+    var slow = head
+    var fast = head
+    // When the fast pointer reaches the end of the list, the slow
+    // pointer will be at the midpoint of the linked list.
+    while (fast != null && fast.next != null) {
+        slow = slow!!.next
+        fast = fast.next!!.next
+    }
+    return slow
+}