exercise/id15

Author: kotler-dev

README.md

@@ -55,6 +55,7 @@ My Kotlin exercises with tests from [Leetcode](https://leetcode.com/kotlerdev)
 | 217 | [Contains Duplicate](src/main/kotlin/exercise/easy/id217/Description217.md)                   | [solution](src/main/kotlin/exercise/easy/id217/Solution217.kt) | [test](src/test/kotlin/exercise/easy/id217/Solution217Test.kt) |    Easy    |
 | 283 | [Move Zeroes](src/main/kotlin/exercise/easy/id283/Description283.md)                          | [solution](src/main/kotlin/exercise/easy/id283/Solution283.kt) | [test](src/test/kotlin/exercise/easy/id283/Solution283Test.kt) |    Easy    |
 | 977 | [Squares of a Sorted Array](src/main/kotlin/exercise/easy/id977/Description977.md)            | [solution](src/main/kotlin/exercise/easy/id977/Solution977.kt) | [test](src/test/kotlin/exercise/easy/id977/Solution977Test.kt) |    Easy    |
+| 15  | [3Sum](src/main/kotlin/exercise/medium/id15/Description15.md)                                 | [solution](src/main/kotlin/exercise/medium/id15/Solution15.kt) | [test](src/test/kotlin/exercise/medium/id15/Solution15Test.kt) |   Medium   |
 | 57  | [Insert Internal](src/main/kotlin/exercise/medium/id57/Description57.md)                      | [solution](src/main/kotlin/exercise/medium/id57/Solution57.kt) | [test](src/test/kotlin/exercise/medium/id57/Solution57Test.kt) |   Medium   |
 
 #### String

src/main/kotlin/exercise/medium/id15/Description15.md

@@ -0,0 +1,49 @@
+[//]: # (Copyright [2023] [Anton Kotler kotler.developer@gmail.com] License MIT)
+
+# 3Sum
+
+![Difficulty](https://img.shields.io/badge/Difficulty-Medium-548af7)
+
+Given an integer array nums, return all the triples `[nums[i], nums[j]], nums[k]]`, such that `i != j`, `i != k`,
+and `j != k`, and `nums[i] + nums[j] + nums[k] == 0`.  
+Notice that the solution set must not contain duplicate triplets.
+
+Example 1:
+
+```
+Input: nums = [-1,0,1,2,-1,-4]
+Output: [[-1,-1,2],[-1,0,1]]
+Explanation:
+nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.
+nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.
+nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.
+The distinct triplets are [-1,0,1] and [-1,-1,2].
+Notice that the order of the output and the order of the triplets does not matter.
+```
+
+Example 2:
+
+```
+Input: nums = [0,1,1]
+Output: []
+Explanation: The only possible triplet does not sum up to 0.
+```
+
+Example 3:
+
+```
+Input: nums = [0,0,0]
+Output: [[0,0,0]]
+Explanation: The only possible triplet sums up to 0.
+```
+
+Constraints:
+
+- `3 <= nums.length <= 3000`
+- `-10^5 <= nums[i] <= 10^5`
+
+| ID | Description |          Solution           |                                       Test                                       | Difficulty |
+|:--:|:------------|:---------------------------:|:--------------------------------------------------------------------------------:|:----------:|
+| 15 | 3Sum        | [solution](./Solution15.kt) | [test](../../../../../../src/test/kotlin/exercise/medium/id15/Solution15Test.kt) |   Medium   |
+
+:top: [Back to all topics](https://github.com/kotler-dev/kotlin-leetcode)

src/main/kotlin/exercise/medium/id15/Solution15.kt

@@ -0,0 +1,41 @@
+package exercise.medium.id15
+
+
+class Solution15 {
+    fun threeSum(nums: IntArray): List<List<Int>> {
+        if (nums.isEmpty() || nums.size < 3) return emptyList()
+
+        val numList = mutableListOf<List<Int>>()
+        var currentIndex = 0
+
+
+        while (currentIndex < nums.size) {
+            var shiftIndex = 0
+            val list = mutableListOf<Int>(0, 0, 0)
+            list[0] = nums[currentIndex]
+            var step = 1
+
+            while (shiftIndex < nums.size) {
+                if (shiftIndex != currentIndex) {
+                    list[step] = nums[shiftIndex]
+                    step++
+                    if (step == 3) {
+                        println("current: ${currentIndex}, list3: ${list}")
+//                        if ((list[0] != list[1]) && (list[0] != list[2]) && (list[1] != list[2])) {
+                        if ((list[0] + list[1] + list[2] == 0)) {
+                            list.sort()
+                            if (list !in numList) numList.add(list.toList())
+                        }
+                        step = 1
+                        shiftIndex--
+                    }
+                }
+                shiftIndex++
+            }
+            currentIndex++
+        }
+        println(numList)
+
+        return numList
+    }
+}

src/test/kotlin/exercise/medium/id15/Solution15Test.kt

@@ -0,0 +1,42 @@
+package exercise.medium.id15
+
+import io.kotest.assertions.print.print
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.datatest.withData
+import io.kotest.matchers.collections.shouldContainAll
+import io.kotest.matchers.equals.shouldBeEqual
+import io.kotest.matchers.shouldBe
+
+data class TestCase(val nums: IntArray, val expected: List<List<Int>>)
+
+class Solution15Test : FunSpec({
+
+    context("shouldBe") {
+        withData(
+            nameFn = { "${it.nums.print().value}, expected: ${it.expected.print().value}" },
+            TestCase(
+                nums = intArrayOf(-1, 0, 1, 2, -1, -4, -2, -3, 3, 0, 4), expected = listOf(
+                    listOf(-4, 0, 4),
+                    listOf(-4, 1, 3),
+                    listOf(-3, -1, 4),
+                    listOf(-3, 0, 3),
+                    listOf(-3, 1, 2),
+                    listOf(-2, -1, 3),
+                    listOf(-2, 0, 2),
+                    listOf(-1, -1, 2),
+                    listOf(-1, 0, 1),
+                )
+            ),
+            TestCase(
+                nums = intArrayOf(3, 0, -2, -1, 1, 2),
+                expected = listOf(listOf(-2, -1, 3), listOf(-2, 0, 2), listOf(-1, 0, 1))
+            ),
+            TestCase(nums = intArrayOf(-1, 0, 1, 2, -1, -4), expected = listOf(listOf(-1, -1, 2), listOf(-1, 0, 1))),
+            TestCase(nums = intArrayOf(0, 0, 0), expected = listOf(listOf(0, 0, 0))),
+            TestCase(nums = intArrayOf(0, 0, 0, 0), expected = listOf(listOf(0, 0, 0))),
+            TestCase(nums = intArrayOf(0, 1, 1), expected = emptyList()),
+        ) { (nums, expected) ->
+            Solution15().threeSum(nums) shouldContainAll expected
+        }
+    }
+})