Added tasks 107-115.

Author: javadev

README.md

@@ -37,51 +37,57 @@ You may return the answer in **any order**.
 import java.util.Arrays
 
 class Solution {
-    fun fourSum(nums: IntArray, target: Int): List<List<Int?>?> {
-        var list: MutableList<List<Int?>?> = ArrayList()
-        var j: Int
-        var k: Int
-        var l: Int
+    fun fourSum(nums: IntArray, target: Int): List<List<Int>> {
+        val ret: MutableList<List<Int>> = ArrayList()
+        if (nums.size < 4) {
+            return ret
+        }
+        if (nums[0] == 1000000000 && nums[1] == 1000000000) {
+            return ret
+        }
         Arrays.sort(nums)
-        var i: Int = 0
-        while (i < nums.size - 3) {
-            if (i > 0 && nums[i] == nums[i - 1]) {
-                i++
+        for (i in 0 until nums.size - 3) {
+            if (i != 0 && nums[i] == nums[i - 1]) {
                 continue
             }
-            j = i + 1
-            while (j < nums.size - 2) {
-                if (j > i + 1 && nums[j] == nums[j - 1]) {
-                    j++
+            for (j in i + 1 until nums.size - 2) {
+                if (j != i + 1 && nums[j] == nums[j - 1]) {
                     continue
                 }
-                k = j + 1
-                l = nums.size - 1
-                while (k < l) {
-                    val sum = nums[i] + nums[j] + nums[k] + nums[l]
+                var left = j + 1
+                var right = nums.size - 1
+                val half = nums[i] + nums[j]
+                if (half + nums[left] + nums[left + 1] > target) {
+                    continue
+                }
+                if (half + nums[right] + nums[right - 1] < target) {
+                    continue
+                }
+                while (left < right) {
+                    val sum = nums[left] + nums[right] + half
                     if (sum == target) {
-                        val l1 = ArrayList<Int?>()
-                        l1.add(nums[i])
-                        l1.add(nums[j])
-                        l1.add(nums[k])
-                        l1.add(nums[l])
-                        list.add(l1)
-                        l--
-                        if (k < l && nums[l] == nums[l + 1]) {
-                            l--
+                        ret.add(listOf(nums[left++], nums[right--], nums[i], nums[j]))
+                        while (nums[left] == nums[left - 1] && left < right) {
+                            left++
+                        }
+                        while (nums[right] == nums[right + 1] && left < right) {
+                            right--
+                        }
+                    } else if (sum < target) {
+                        left++
+                        while (nums[left] == nums[left - 1] && left < right) {
+                            left++
                         }
-                    } else if (sum > target) {
-                        l--
                     } else {
-                        k++
+                        right--
+                        while (nums[right] == nums[right + 1] && left < right) {
+                            right--
+                        }
                     }
                 }
-                j++
             }
-            i++
         }
-        list = ArrayList(LinkedHashSet(list))
-        return list
+        return ret
     }
 }
 ```

src/main/kotlin/g0001_0100/s0018_4sum/readme.md

@@ -47,7 +47,6 @@ class Solution {
             chars.append(res[index].toString())
             index++
         }
-        System.out.println(chars)
         return chars.toString()
     }
 

src/main/kotlin/g0001_0100/s0043_multiply_strings/readme.md

@@ -56,7 +56,7 @@ import com_github_leetcode.TreeNode
 class Solution {
     private fun trav(n: TreeNode?, m: TreeNode?): Boolean {
         return if (n != null && m != null) {
-            if (n.`val` !== m.`val`) {
+            if (n.`val` != m.`val`) {
                 false
             } else trav(n.left, m.left) && trav(n.right, m.right)
         } else {

src/main/kotlin/g0001_0100/s0100_same_tree/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 107\. Binary Tree Level Order Traversal II
+
+Medium
+
+Given the `root` of a binary tree, return _the bottom-up level order traversal of its nodes' values_. (i.e., from left to right, level by level from leaf to root).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/tree1.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [[15,7],[9,20],[3]]
+
+**Example 2:**
+
+**Input:** root = [1]
+
+**Output:** [[1]]
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 2000]`.
+*   `-1000 <= Node.val <= 1000`
+
+## Solution
+
+```kotlin
+import com_github_leetcode.TreeNode
+import java.util.Collections
+import kotlin.collections.ArrayList
+
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private val order: MutableList<MutableList<Int>> = ArrayList()
+    fun levelOrderBottom(root: TreeNode?): List<MutableList<Int>> {
+        getOrder(root, 0)
+        Collections.reverse(order)
+        return order
+    }
+
+    fun getOrder(root: TreeNode?, level: Int) {
+        if (root != null) {
+            if (level + 1 > order.size) {
+                order.add(ArrayList())
+            }
+            order[level].add(root.`val`)
+            getOrder(root.left, level + 1)
+            getOrder(root.right, level + 1)
+        }
+    }
+}
+```

src/main/kotlin/g0101_0200/s0107_binary_tree_level_order_traversal_ii/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 108\. Convert Sorted Array to Binary Search Tree
+
+Easy
+
+Given an integer array `nums` where the elements are sorted in **ascending order**, convert _it to a **height-balanced** binary search tree_.
+
+A **height-balanced** binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree1.jpg)
+
+**Input:** nums = [-10,-3,0,5,9]
+
+**Output:** [0,-3,9,-10,null,5]
+
+**Explanation:** [0,-10,5,null,-3,null,9] is also accepted: ![](https://assets.leetcode.com/uploads/2021/02/18/btree2.jpg)
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/18/btree.jpg)
+
+**Input:** nums = [1,3]
+
+**Output:** [3,1]
+
+**Explanation:** [1,null,3] and [3,1] are both height-balanced BSTs.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` is sorted in a **strictly increasing** order.
+
+## Solution
+
+```kotlin
+import com_github_leetcode.TreeNode
+
+/**
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun sortedArrayToBST(num: IntArray): TreeNode? {
+        /*1. Set up recursion*/
+        return makeTree(num, 0, num.size - 1)
+    }
+
+    private fun makeTree(num: IntArray, left: Int, right: Int): TreeNode? {
+        /*2. left as lowest# can't be greater than right*/
+        if (left > right) {
+            return null
+        }
+        /*3. Set median# as node*/
+        val mid = (left + right) / 2
+        val midNode = TreeNode(num[mid])
+        /*4. Set mid node's kids*/
+        midNode.left = makeTree(num, left, mid - 1)
+        midNode.right = makeTree(num, mid + 1, right)
+        /*5. Sends node back || Goes back to prev node*/
+        return midNode
+    }
+}
+```

src/main/kotlin/g0101_0200/s0108_convert_sorted_array_to_binary_search_tree/readme.md

@@ -0,0 +1,89 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-Kotlin?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-Kotlin?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-Kotlin/fork)
+
+## 109\. Convert Sorted List to Binary Search Tree
+
+Medium
+
+Given the `head` of a singly linked list where elements are **sorted in ascending order**, convert it to a height balanced BST.
+
+For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of _every_ node never differ by more than 1.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/linked.jpg)
+
+**Input:** head = [-10,-3,0,5,9]
+
+**Output:** [0,-3,9,-10,null,5]
+
+**Explanation:** One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.
+
+**Example 2:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in `head` is in the range <code>[0, 2 * 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+
+## Solution
+
+```kotlin
+import com_github_leetcode.ListNode
+import com_github_leetcode.TreeNode
+
+/*
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun sortedListToBST(head: ListNode?): TreeNode? {
+        // Empty list -> empty tree / sub-tree
+        if (head == null) {
+            return null
+        }
+        // No next node -> this node will become leaf
+        if (head.next == null) {
+            val leaf = TreeNode(head.`val`)
+            leaf.left = null
+            leaf.right = null
+            return leaf
+        }
+        var slow = head
+        // Head-Start fast by 1 to get slow = mid -1
+        var fast = head.next!!.next
+        // Find the mid of list
+        while (fast != null && fast.next != null) {
+            slow = slow!!.next
+            fast = fast.next!!.next
+        }
+        // slow.next ->  mid = our "root"
+        val root = TreeNode(slow!!.next!!.`val`)
+        // Right sub tree from mid - end
+        root.right = sortedListToBST(slow.next!!.next)
+        // Left sub tree from head - mid (chop slow.next)
+        slow.next = null
+        root.left = sortedListToBST(head)
+        return root
+    }
+}
+```