Added tasks 17, 18.

Author: javadev

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

@@ -0,0 +1,40 @@
+package g0001_0100.s0017_letter_combinations_of_a_phone_number
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Backtracking
+
+class Solution {
+    fun letterCombinations(digits: String): List<String> {
+        if (digits.isEmpty()) {
+            return emptyList()
+        }
+        val words: MutableList<String> = ArrayList()
+        val word = CharArray(digits.length)
+        helper(digits, word, 0, words)
+        return words
+    }
+
+    private fun helper(digits: String, word: CharArray, cur: Int, words: MutableList<String>) {
+        if (cur == digits.length) {
+            words.add(String(word))
+        } else {
+            for (ch in charsForDigit(digits[cur])) {
+                word[cur] = ch
+                helper(digits, word, cur + 1, words)
+            }
+        }
+    }
+
+    private fun charsForDigit(digit: Char): CharArray {
+        return when (digit) {
+            '2' -> charArrayOf('a', 'b', 'c')
+            '3' -> charArrayOf('d', 'e', 'f')
+            '4' -> charArrayOf('g', 'h', 'i')
+            '5' -> charArrayOf('j', 'k', 'l')
+            '6' -> charArrayOf('m', 'n', 'o')
+            '7' -> charArrayOf('p', 'q', 'r', 's')
+            '8' -> charArrayOf('t', 'u', 'v')
+            '9' -> charArrayOf('w', 'x', 'y', 'z')
+            else -> charArrayOf()
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+17\. Letter Combinations of a Phone Number
+
+Medium
+
+Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent. Return the answer in **any order**.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png)
+
+**Example 1:**
+
+**Input:** digits = "23"
+
+**Output:** ["ad","ae","af","bd","be","bf","cd","ce","cf"]
+
+**Example 2:**
+
+**Input:** digits = ""
+
+**Output:** []
+
+**Example 3:**
+
+**Input:** digits = "2"
+
+**Output:** ["a","b","c"]
+
+**Constraints:**
+
+*   `0 <= digits.length <= 4`
+*   `digits[i]` is a digit in the range `['2', '9']`.

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

@@ -0,0 +1,55 @@
+package g0001_0100.s0018_4sum
+
+// #Medium #Array #Sorting #Two_Pointers
+
+import java.util.Arrays
+
+class Solution {
+    fun fourSum(nums: IntArray, target: Int): List<List<Int>> {
+        val list: MutableList<List<Int>> = ArrayList()
+        Arrays.sort(nums)
+        val n = nums.size
+        if (n == 0) {
+            return list
+        }
+        for (a in 0 until n - 3) {
+            if (a > 0 && nums[a] == nums[a - 1]) {
+                continue
+            }
+            for (d in n - 1 downTo a + 2 + 1) {
+                if (d < n - 1 && nums[d] == nums[d + 1]) {
+                    continue
+                }
+                var b = a + 1
+                var c = d - 1
+                val min = nums[a] + nums[d] + nums[b] + nums[b + 1]
+                if (min > target) {
+                    continue
+                }
+                val max = nums[a] + nums[d] + nums[c] + nums[c - 1]
+                if (max < target) {
+                    break
+                }
+                while (c > b) {
+                    val sum = nums[a] + nums[b] + nums[c] + nums[d]
+                    if (sum > target) {
+                        c--
+                    } else if (sum < target) {
+                        b++
+                    } else {
+                        list.add(Arrays.asList(nums[a], nums[b], nums[c], nums[d]))
+                        while (c > b && nums[b] == nums[b + 1]) {
+                            b++
+                        }
+                        while (c > b && nums[c] == nums[c - 1]) {
+                            c--
+                        }
+                        b++
+                        c--
+                    }
+                }
+            }
+        }
+        return list
+    }
+}

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

@@ -0,0 +1,29 @@
+18\. 4Sum
+
+Medium
+
+Given an array `nums` of `n` integers, return _an array of all the **unique** quadruplets_ `[nums[a], nums[b], nums[c], nums[d]]` such that:
+
+*   `0 <= a, b, c, d < n`
+*   `a`, `b`, `c`, and `d` are **distinct**.
+*   `nums[a] + nums[b] + nums[c] + nums[d] == target`
+
+You may return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,0,-1,0,-2,2], target = 0
+
+**Output:** [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
+
+**Example 2:**
+
+**Input:** nums = [2,2,2,2,2], target = 8
+
+**Output:** [[2,2,2,2]]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 200`
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>

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

@@ -0,0 +1,60 @@
+package g0001_0100.s0017_letter_combinations_of_a_phone_number
+
+import org.hamcrest.CoreMatchers
+import org.hamcrest.MatcherAssert
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class SolutionTest {
+    @Test
+    fun letterCombinations() {
+        MatcherAssert.assertThat(
+            Solution().letterCombinations("23"),
+            CoreMatchers.equalTo(Arrays.asList("ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"))
+        )
+    }
+
+    @Test
+    fun letterCombinations2() {
+        MatcherAssert.assertThat(Solution().letterCombinations(""), CoreMatchers.equalTo(Arrays.asList<Any>()))
+    }
+
+    @Test
+    fun letterCombinations3() {
+        MatcherAssert.assertThat(Solution().letterCombinations("2"), CoreMatchers.equalTo(Arrays.asList("a", "b", "c")))
+    }
+
+    @Test
+    fun letterCombinations4() {
+        MatcherAssert.assertThat(Solution().letterCombinations("4"), CoreMatchers.equalTo(Arrays.asList("g", "h", "i")))
+    }
+
+    @Test
+    fun letterCombinations5() {
+        MatcherAssert.assertThat(Solution().letterCombinations("5"), CoreMatchers.equalTo(Arrays.asList("j", "k", "l")))
+    }
+
+    @Test
+    fun letterCombinations6() {
+        MatcherAssert.assertThat(Solution().letterCombinations("6"), CoreMatchers.equalTo(Arrays.asList("m", "n", "o")))
+    }
+
+    @Test
+    fun letterCombinations7() {
+        MatcherAssert.assertThat(
+            Solution().letterCombinations("7"), CoreMatchers.equalTo(Arrays.asList("p", "q", "r", "s"))
+        )
+    }
+
+    @Test
+    fun letterCombinations8() {
+        MatcherAssert.assertThat(Solution().letterCombinations("8"), CoreMatchers.equalTo(Arrays.asList("t", "u", "v")))
+    }
+
+    @Test
+    fun letterCombinations9() {
+        MatcherAssert.assertThat(
+            Solution().letterCombinations("9"), CoreMatchers.equalTo(Arrays.asList("w", "x", "y", "z"))
+        )
+    }
+}

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

@@ -0,0 +1,18 @@
+package g0001_0100.s0018_4sum
+
+import com_github_leetcode.ArrayUtils.getLists
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun fourSum() {
+        assertThat(
+            Solution().fourSum(intArrayOf(1, 0, -1, 0, -2, 2), 0),
+            equalTo(
+                getLists(arrayOf(intArrayOf(-2, -1, 1, 2), intArrayOf(-2, 0, 0, 2), intArrayOf(-1, 0, 0, 1)))
+            )
+        )
+    }
+}