Added tasks 20, 21, 22, 23, 24.

Author: javadev

src/main/kotlin/g0001_0100/s0020_valid_parentheses/Solution.kt

@@ -0,0 +1,27 @@
+package g0001_0100.s0020_valid_parentheses
+
+import java.util.Stack
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #String #Stack
+// #2022_02_17_Time_3_ms_(53.65%)_Space_42.1_MB_(17.58%)
+
+class Solution {
+    fun isValid(s: String): Boolean {
+        val stack = Stack<Char>()
+        for (element in s) {
+            val c = element
+            if (c == '(' || c == '[' || c == '{') {
+                stack.push(c)
+            } else if (c == ')' && !stack.isEmpty() && stack.peek() == '(') {
+                stack.pop()
+            } else if (c == '}' && !stack.isEmpty() && stack.peek() == '{') {
+                stack.pop()
+            } else if (c == ']' && !stack.isEmpty() && stack.peek() == '[') {
+                stack.pop()
+            } else {
+                return false
+            }
+        }
+        return stack.isEmpty()
+    }
+}

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

@@ -0,0 +1,45 @@
+20\. Valid Parentheses
+
+Easy
+
+Given a string `s` containing just the characters `'('`, `')'`, `'{'`, `'}'`, `'['` and `']'`, determine if the input string is valid.
+
+An input string is valid if:
+
+1.  Open brackets must be closed by the same type of brackets.
+2.  Open brackets must be closed in the correct order.
+
+**Example 1:**
+
+**Input:** s = "()"
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** s = "()[]{}"
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** s = "(]"
+
+**Output:** false
+
+**Example 4:**
+
+**Input:** s = "([)]"
+
+**Output:** false
+
+**Example 5:**
+
+**Input:** s = "{[]}"
+
+**Output:** true
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of parentheses only `'()[]{}'`.

src/main/kotlin/g0001_0100/s0021_merge_two_sorted_lists/Solution.kt

@@ -0,0 +1,34 @@
+package g0001_0100.s0021_merge_two_sorted_lists
+
+import com_github_leetcode.ListNode
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Linked_List #Recursion
+// #2022_02_17_Time_1_ms_(61.88%)_Space_42.8_MB_(22.76%)
+
+class Solution {
+    fun mergeTwoLists(l1: ListNode?, l2: ListNode?): ListNode? {
+        var l1 = l1
+        var l2 = l2
+        var list: ListNode? = ListNode(-1)
+        val head = list
+        while (l1 != null || l2 != null) {
+            if (l1 != null && l2 != null) {
+                if (l1.`val` <= l2.`val`) {
+                    list!!.next = ListNode(l1.`val`)
+                    l1 = l1.next
+                } else {
+                    list!!.next = ListNode(l2.`val`)
+                    l2 = l2.next
+                }
+            } else if (l1 != null) {
+                list!!.next = ListNode(l1.`val`)
+                l1 = l1.next
+            } else {
+                list!!.next = ListNode(l2!!.`val`)
+                l2 = l2.next
+            }
+            list = list.next
+        }
+        return head!!.next
+    }
+}

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

@@ -0,0 +1,31 @@
+21\. Merge Two Sorted Lists
+
+Easy
+
+Merge two sorted linked lists and return it as a **sorted** list. The list should be made by splicing together the nodes of the first two lists.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg)
+
+**Input:** l1 = [1,2,4], l2 = [1,3,4]
+
+**Output:** [1,1,2,3,4,4]
+
+**Example 2:**
+
+**Input:** l1 = [], l2 = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** l1 = [], l2 = [0]
+
+**Output:** [0]
+
+**Constraints:**
+
+*   The number of nodes in both lists is in the range `[0, 50]`.
+*   `-100 <= Node.val <= 100`
+*   Both `l1` and `l2` are sorted in **non-decreasing** order.

src/main/kotlin/g0001_0100/s0022_generate_parentheses/Solution.kt

@@ -0,0 +1,30 @@
+package g0001_0100.s0022_generate_parentheses
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Dynamic_Programming
+// #Backtracking #2022_02_17_Time_1_ms_(87.91%)_Space_43.6_MB_(19.97%)
+
+class Solution {
+    fun generateParenthesis(n: Int): List<String> {
+        val sb = StringBuilder()
+        val ans: MutableList<String> = ArrayList()
+        return generate(sb, ans, n, n)
+    }
+
+    private fun generate(sb: StringBuilder, str: MutableList<String>, open: Int, close: Int): List<String> {
+        if (open == 0 && close == 0) {
+            str.add(sb.toString())
+            return str
+        }
+        if (open > 0) {
+            sb.append('(')
+            generate(sb, str, open - 1, close)
+            sb.deleteCharAt(sb.length - 1)
+        }
+        if (close > 0 && open < close) {
+            sb.append(')')
+            generate(sb, str, open, close - 1)
+            sb.deleteCharAt(sb.length - 1)
+        }
+        return str
+    }
+}

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

@@ -0,0 +1,21 @@
+22\. Generate Parentheses
+
+Medium
+
+Given `n` pairs of parentheses, write a function to _generate all combinations of well-formed parentheses_.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** ["((()))","(()())","(())()","()(())","()()()"]
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** ["()"]
+
+**Constraints:**
+
+*   `1 <= n <= 8`

src/main/kotlin/g0001_0100/s0023_merge_k_sorted_lists/Solution.kt

@@ -0,0 +1,64 @@
+package g0001_0100.s0023_merge_k_sorted_lists
+
+import com_github_leetcode.ListNode
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Heap_Priority_Queue #Linked_List
+// #Divide_and_Conquer #Merge_Sort #2022_02_18_Time_1_ms_(100.00%)_Space_43.9_MB_(75.94%)
+
+class Solution {
+    fun mergeKLists(lists: Array<ListNode>): ListNode? {
+        return if (lists.size == 0) {
+            null
+        } else mergeKLists(lists, 0, lists.size)
+    }
+
+    private fun mergeKLists(lists: Array<ListNode>, leftIndex: Int, rightIndex: Int): ListNode? {
+        return if (rightIndex > leftIndex + 1) {
+            val mid = (leftIndex + rightIndex) / 2
+            val left = mergeKLists(lists, leftIndex, mid)
+            val right = mergeKLists(lists, mid, rightIndex)
+            mergeTwoLists(left, right)
+        } else {
+            lists[leftIndex]
+        }
+    }
+
+    private fun mergeTwoLists(left: ListNode?, right: ListNode?): ListNode? {
+        var left = left
+        var right = right
+        if (left == null) {
+            return right
+        }
+        if (right == null) {
+            return left
+        }
+        val res: ListNode
+        if (left.`val` <= right.`val`) {
+            res = left
+            left = left.next
+        } else {
+            res = right
+            right = right.next
+        }
+        var node: ListNode? = res
+        while (left != null || right != null) {
+            if (left == null) {
+                node!!.next = right
+                right = right!!.next
+            } else if (right == null) {
+                node!!.next = left
+                left = left.next
+            } else {
+                if (left.`val` <= right.`val`) {
+                    node!!.next = left
+                    left = left.next
+                } else {
+                    node!!.next = right
+                    right = right.next
+                }
+            }
+            node = node.next
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,36 @@
+23\. Merge k Sorted Lists
+
+Hard
+
+You are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.
+
+_Merge all the linked-lists into one sorted linked-list and return it._
+
+**Example 1:**
+
+**Input:** lists = [[1,4,5],[1,3,4],[2,6]]
+
+**Output:** [1,1,2,3,4,4,5,6]
+
+**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6
+
+**Example 2:**
+
+**Input:** lists = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** lists = [[]]
+
+**Output:** []
+
+**Constraints:**
+
+*   `k == lists.length`
+*   `0 <= k <= 10^4`
+*   `0 <= lists[i].length <= 500`
+*   `-10^4 <= lists[i][j] <= 10^4`
+*   `lists[i]` is sorted in **ascending order**.
+*   The sum of `lists[i].length` won't exceed `10^4`.

src/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/Solution.kt

@@ -0,0 +1,45 @@
+package g0001_0100.s0024_swap_nodes_in_pairs
+
+import com_github_leetcode.ListNode
+
+// #Medium #Linked_List #Recursion #2022_02_18_Time_0_ms_(100.00%)_Space_41.9_MB_(22.86%)
+
+class Solution {
+    fun swapPairs(head: ListNode?): ListNode? {
+        if (head == null) {
+            return null
+        }
+        val len = getLength(head)
+        return reverse(head, len)
+    }
+
+    private fun getLength(curr: ListNode): Int {
+        var curr: ListNode? = curr
+        var cnt = 0
+        while (curr != null) {
+            cnt++
+            curr = curr.next
+        }
+        return cnt
+    }
+
+    // Recursive function to reverse in groups
+    private fun reverse(head: ListNode?, len: Int): ListNode? {
+        // base case
+        if (len < 2) {
+            return head
+        }
+        var curr = head
+        var prev: ListNode? = null
+        var next: ListNode?
+        for (i in 0..1) {
+            // reverse linked list code
+            next = curr!!.next
+            curr.next = prev
+            prev = curr
+            curr = next
+        }
+        head!!.next = reverse(curr, len - 2)
+        return prev
+    }
+}

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

@@ -0,0 +1,30 @@
+24\. Swap Nodes in Pairs
+
+Medium
+
+Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg)
+
+**Input:** head = [1,2,3,4]
+
+**Output:** [2,1,4,3]
+
+**Example 2:**
+
+**Input:** head = []
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** head = [1]
+
+**Output:** [1]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 100]`.
+*   `0 <= Node.val <= 100`

src/test/kotlin/g0001_0100/s0020_valid_parentheses/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0001_0100.s0020_valid_parentheses
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isValid() {
+        val solution = Solution()
+        assertThat(solution.isValid("()"), equalTo(true))
+        assertThat(solution.isValid("()[]{}"), equalTo(true))
+        assertThat(solution.isValid("(]"), equalTo(false))
+        assertThat(solution.isValid("([)]"), equalTo(false))
+        assertThat(solution.isValid("{[]}"), equalTo(true))
+    }
+}