Merge pull request ByteByteGoHq#6 from marttp/main

Add Kotlin solutions - Chapter 1: Two Pointers

Author: Destiny-02

kotlin/Two Pointers/IsPalindromeValid.kt

@@ -0,0 +1,22 @@
+fun isPalindromeValid(s: String): Boolean {
+    var left = 0
+    var right = s.length - 1
+    while (left < right) {
+        // Skip non-alphanumeric characters from the left.
+        while (left < right && !s[left].isLetterOrDigit()) {
+            left++
+        }
+        // Skip non-alphanumeric characters from the right.
+        while (left < right && !s[right].isLetterOrDigit()) {
+            right--
+        }
+        // If the characters at the left and right pointers don't
+        // match, the string is not a palindrome.
+        if (s[left] != s[right]) {
+            return false
+        }
+        left++
+        right--
+    }
+    return true
+}

kotlin/Two Pointers/LargestContainer.kt

@@ -0,0 +1,26 @@
+import kotlin.math.min
+import kotlin.math.max
+
+fun largestContainer(heights: List<Int>): Int {
+    var maxWater = 0
+    var left = 0
+    var right = heights.size - 1
+    while (left < right) {
+        // Calculate the water contained between the current pair of
+        // lines.
+        val water = min(heights[left], heights[right]) * (right - left)
+        maxWater = max(maxWater, water)
+        // Move the pointers inward, always moving the pointer at the
+        // shorter line. If both lines have the same height, move both
+        // pointers inward.
+        if (heights[left] < heights[right]) {
+            left++
+        } else if (heights[left] > heights[right]) {
+            right--
+        } else {
+            left++
+            right--
+        }
+    }
+    return maxWater
+}

kotlin/Two Pointers/LargestContainerBruteForce.kt

@@ -0,0 +1,15 @@
+import kotlin.math.max
+import kotlin.math.min
+
+fun largestContainerBruteForce(heights: List<Int>): Int {
+    val n = heights.size
+    var maxWater = 0
+    // Find the maximum amount of water stored between all pairs of lines.
+    for (i in 0 until n) {
+        for (j in i + 1 until heights.size) {
+            val water = min(heights[i], heights[j]) * (j - i)
+            maxWater = max(maxWater, water)
+        }
+    }
+    return maxWater
+}

kotlin/Two Pointers/NextLexicographicalSequence.kt

@@ -0,0 +1,35 @@
+fun nextLexicographicalSequence(s: String): String {
+    val letters = s.toCharArray()
+
+    // Locate the pivot, which is the first character from the right that breaks
+    // non-increasing order. Start searching from the second-to-last position,
+    // since the last character is neither increasing nor decreasing.
+    var pivot = letters.size - 2
+    while (pivot >= 0 && letters[pivot] >= letters[pivot + 1]) {
+        pivot--
+    }
+
+    // If pivot is not found, the string is already in its largest permutation. In
+    // this case, reverse the string to obtain the smallest permutation.
+    if (pivot == -1) {
+        letters.reverse()
+        return letters.joinToString("")
+    }
+
+    // Find the rightmost successor to the pivot.
+    var rightmostSuccessor = letters.size - 1
+    while (letters[rightmostSuccessor] <= letters[pivot]) {
+        rightmostSuccessor--
+    }
+
+    // Swap the rightmost successor with the pivot to increase the lexicographical
+    // order of the suffix.
+    letters[pivot] =
+            letters[rightmostSuccessor].also { letters[rightmostSuccessor] = letters[pivot] }
+
+    // Reverse the suffix after the pivot to minimize its permutation.
+    val suffix = letters.sliceArray(pivot + 1 until letters.size)
+    suffix.reverse()
+
+    return (letters.sliceArray(0..pivot) + suffix).joinToString("")
+}

kotlin/Two Pointers/PairSumSorted.kt

@@ -0,0 +1,20 @@
+fun pairSumSorted(nums: IntArray, target: Int): List<Int> {
+    var left = 0
+    var right = nums.size - 1
+    while (left < right) {
+        val sum = nums[left] + nums[right]
+        // If the sum is smaller, increment the left pointer, aiming
+        // to increase the sum toward the target value.
+        if (sum < target) {
+            left++
+            // If the sum is larger, decrement the right pointer, aiming
+            // to decrease the sum toward the target value.
+        } else if (sum > target) {
+            right--
+            // If the target pair is found, return its indexes.
+        } else {
+            return listOf(left, right)
+        }
+    }
+    return emptyList()
+}

kotlin/Two Pointers/PairSumSortedBruteForce.kt

@@ -0,0 +1,11 @@
+fun pairSumSortedBruteForce(nums: IntArray, target: Int): List<Int> {
+    val n = nums.size
+    for (i in 0 until n) {
+        for (j in i + 1 until nums.size) {
+            if (nums[i] + nums[j] == target) {
+                return listOf(i, j)
+            }
+        }
+    }
+    return emptyList()
+}

kotlin/Two Pointers/ShiftZeroToTheEnd.kt

@@ -0,0 +1,15 @@
+fun shiftZerosToTheEnd(nums: IntArray) {
+    // The 'left' pointer is used to position non-zero elements.
+    var left = 0
+    // Iterate through the array using a 'right' pointer to locate non-zero
+    // elements.
+    for (right in nums.indices) {
+        if (nums[right] != 0) {
+            // Swap element
+            nums[left] = nums[right].also { nums[right] = nums[left] }
+            // Increment 'left' since it now points to a position already occupied
+            // by a non-zero element.
+            left++
+        }
+    }
+}

kotlin/Two Pointers/ShiftZeroToTheEndNaive.kt

@@ -0,0 +1,19 @@
+fun shiftZerosToTheEndNaive(nums: IntArray) {
+    val temp = IntArray(nums.size)
+    var i = 0
+
+    // Add all non-zero elements to the left of 'temp'.
+    for (num in nums) {
+        if (num != 0) {
+            // Mark non-zero on tmp
+            // Otherwise, skip this num
+            temp[i] = num
+            i++
+        }
+    }
+
+    // Set 'nums' to 'temp'.
+    for (j in temp.indices) {
+        nums[j] = temp[j]
+    }
+}

kotlin/Two Pointers/TripletSum.kt

@@ -0,0 +1,48 @@
+fun tripletSum(nums: List<Int>): List<List<Int>> {
+    val triplets = mutableListOf<List<Int>>()
+    val sortedNums = nums.sorted()
+    for (i in sortedNums.indices) {
+        // Optimization: triplets consisting of only positive numbers
+        // will never sum to 0.
+        if (sortedNums[i] > 0) {
+            break
+        }
+        // To avoid duplicate triplets, skip 'a' if it's the same as
+        // the previous number.
+        if (i > 0 && sortedNums[i] == sortedNums[i - 1]) {
+            continue
+        }
+        // Find all pairs that sum to a target of '-a' (-nums[i]).
+        var listOfPair = pairSumSortedAllPairs(sortedNums, i + 1, -1 * sortedNums[i])
+        for (l in listOfPair) {
+            triplets.add(listOf(sortedNums[i], l[0], l[1]))
+        }
+    }
+    return triplets
+}
+
+fun pairSumSortedAllPairs(nums: List<Int>, start: Int, target: Int): List<List<Int>> {
+    val listOfPair = mutableListOf<List<Int>>()
+    var left = start
+    var right = nums.size - 1
+    while (left < right) {
+        val pairSum = nums[left] + nums[right]
+        if (pairSum == target) {
+            listOfPair.add(listOf(nums[left], nums[right]))
+            left++
+            right--
+            // To avoid duplicate '[b, c]' pairs, skip 'b' if it's the same as the previous number.
+            while (left < right && nums[left] == nums[left - 1]) {
+                left++
+            }
+            while (left < right && nums[right] == nums[right + 1]) {
+                right--
+            }
+        } else if (pairSum < target) {
+            left++
+        } else {
+            right--
+        }
+    }
+    return listOfPair
+}

kotlin/Two Pointers/TripletSumBruteForce.kt

@@ -0,0 +1,18 @@
+fun tripletSumBruteForce(nums: List<Int>): List<List<Int>> {
+    // Use a hash set to ensure we don't add duplicate triplets.
+    val triplets = hashSetOf<List<Int>>()
+    // Iterate through the indexes of all triplets. O(n^3)
+    for (i in nums.indices) {
+        for (j in i + 1 until nums.size) {
+            for (k in j + 1 until nums.size) {
+                if (nums[i] + nums[j] + nums[k] == 0) {
+                    // Sort the triplet before including it in the hash set.
+                    val candidateList = mutableListOf(nums[i], nums[j], nums[k])
+                    candidateList.sort()
+                    triplets.add(candidateList)
+                }
+            }
+        }
+    }
+    return triplets.toList()
+}