leet code mediums part 2

Author: Mohammad

src/test/kotlin/com/sample/umar/leetcodemediums/BackSpaceScan.kt

@@ -0,0 +1,64 @@
+package com.sample.umar.leetcodemediums
+
+//Given 2 strings s and t, each containing letters and # (which means backspace),
+// return true if both strings are equal after applying backspaces.
+//# means delete the previous character.
+fun main() {
+    println(backSpaceCharEquality("ab#c", "ad#c"))
+}
+
+// Use the two-pointer backward approach "It’s faster and more optimal"
+fun backSpaceCharEquality(str1: String, str2: String): Boolean {
+    var i = str1.length - 1
+    var j = str2.length - 1
+
+    var skip1 = 0
+    var skip2 = 0
+
+    while (i >= 0 || j >= 0) {
+        while (i >= 0) {
+            if (str1[i] == '#') {
+                skip1++
+                i--
+            } else if (skip1 > 0) {
+                i--
+            } else {
+                break
+            }
+        }
+
+        while (j >= 0) {
+            if (str2[j] == '#') {
+                skip2++
+                j--
+            } else if (skip2 > 0) {
+                j--
+            } else {
+                break
+            }
+        }
+
+        // compare both strings
+        if (i >= 0 && j >= 0 && str1[i] != str2[j]) {
+            return false
+        } else if ((i < 0 && j >= 0) || (j < 0 && i >= 0)) {
+            return false
+        } else {
+            i--
+            j--
+        }
+    }
+    return true
+}
+
+
+/* Algo:
+    1. Move i left until:
+	    • You skip all #
+	    • You skip all characters that should be removed
+	    • You stop on the next valid letter
+	2.	Move j left same way.
+	3.	Compare the valid characters at i and j.
+	4.	If mismatch → return false.
+	5.	If both reach past the beginning → return true.
+ */

src/test/kotlin/com/sample/umar/leetcodemediums/FirstUniqueChar.kt

@@ -0,0 +1,19 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(firstUniqueChar("leetcode"))
+}
+
+// Return the first unique char index from the given string (two pass)
+fun firstUniqueChar(inputStr: String): Int {
+    // use a map to store the char freq
+    val freqMap = mutableMapOf<Char, Int>()
+    inputStr.forEach { char ->
+        freqMap[char] = (freqMap[char] ?: 0) + 1
+    }
+    for (i in 0 until inputStr.length) {
+        val count = freqMap[inputStr[i]]
+        if (count == 1) return i
+    }
+    return -1
+}

src/test/kotlin/com/sample/umar/leetcodemediums/RemoveDuplicates.kt

@@ -0,0 +1,24 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(removeDuplicates(mutableListOf<Int>(0, 1, 2, 3, 3, 4, 5, 6, 6, 6, 7, 8)))
+}
+
+/*
+    .  Return the count of unique elements in a sorted array
+	•	slow → points to where next unique value should be written
+	•	fast → scans the full list
+	->  space and time is o(1) and o(n)
+ */
+// Use two pointer solution to deal in same array (in-place modification)
+fun removeDuplicates(inputList: MutableList<Int>): Int {
+    var slow = 0
+    for (fast in 0 until inputList.size) {
+        if (inputList[fast] != inputList[slow]) {
+            slow++
+            inputList[slow] = inputList[fast]
+        }
+    }
+    return slow + 1
+}
+

src/test/kotlin/com/sample/umar/leetcodemediums/RotateArray.kt

@@ -0,0 +1,45 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(rotateArray(mutableListOf<Int>(1, 2, 4, 3, 5, 6, 4, 8), 1))
+}
+
+// Given an array, rotate it to the right by k steps.
+// Reverse method steps, since it is in-place and o(1) space and o(n) time
+fun rotateArray(inputList: MutableList<Int>, step: Int): List<Int> {
+    //normalise the k (reduces the number of rotations that produce same result)
+    val k = step % inputList.size
+
+    fun reverse(startIndex: Int, endIndex: Int) {
+        var left = startIndex
+        var right = endIndex
+        //reverse is in-place
+        while (left < right) {
+            val temp = inputList[left]
+            inputList[left] = inputList[right]
+            inputList[right] = temp
+            left++
+            right--
+        }
+    }
+    // Step 1: Reverse whole array
+    reverse(0, inputList.size - 1)
+
+    // Step 2: Reverse only the first k elements
+    reverse(0, k - 1)
+
+    // step 3: Reverse remaining elements
+    reverse(k, inputList.size - 1)
+
+    return inputList
+}
+
+
+/*
+Algo:
+1. Reverse whole array
+2. Reverse first k elements
+3. Reverse remaining elements
+4. Use a inline fun to reverse(left, right) that use basic swap via temp variable with left < right
+ */
+

src/test/kotlin/com/sample/umar/leetcodemediums/SortDuplicateNumbers.kt

@@ -14,8 +14,29 @@ fun sortDuplicateNumbers(inputList: List<Int>): List<Int> {
         mapFreq[it] = (mapFreq[it] ?: 0) + 1
     }
     // Sort the keys into a list using manual method
-    //val sortedkeys = mapFreq.keys.sorted()
-    val sortedKeys = sortKeys(mapFreq.keys.toMutableList())
+    //val sortedkeys = mapFreq.keys.sorted() // timsort
+    //val sortedKeys = sortKeys(mapFreq.keys.toMutableList())
+
+    fun sortKeysInline(): List<Int> {
+        val keys = mapFreq.keys.toMutableList()
+        // Use swap technique, check neighbouring elements one after the other and swap in-place
+        for (i in 0 until keys.size) {
+            //It marks the position where the smallest remaining number should go.
+            var minIndex = i
+            for (j in i + 1 until keys.size) {
+                if (keys[j] < keys[minIndex]) {
+                    minIndex = j
+                }
+            }
+            val temp = keys[i]
+            keys[i] = keys[minIndex]
+            keys[minIndex] = temp
+        }
+        return keys
+    }
+
+    val sortedKeys = sortKeysInline()
+
 
     sortedKeys.forEach { key ->
         // add sorted list with duplicates
@@ -43,4 +64,5 @@ fun sortKeys(inputList: MutableList<Int>): List<Int> {
         inputList.remove(smallest)
     }
     return sortedList
-}
+}
+

src/test/kotlin/com/sample/umar/leetcodemediums/ValidPalindrome.kt

@@ -0,0 +1,42 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(validPalindrome("abbca"))
+}
+
+/*
+"aba" → true
+"abca" → true  (delete 'b' or 'c')
+"abc" → false
+** Pattern: Two-pointers + One skip allowed
+ */
+fun validPalindrome(inputStr: String): Boolean {
+    var left = 0
+    var right = inputStr.length - 1
+
+    while (left < right) {
+        if (inputStr[left] == inputStr[right]) {
+            left++
+            right--
+        } else {
+            // mismatch : “delete ONE character” rule (but we check and actually skip)
+            // call a helper func
+            return (checkPalindrome(inputStr, left + 1, right) || checkPalindrome(inputStr, left, right - 1))
+        }
+    }
+    return true
+}
+
+fun checkPalindrome(inputStr: String, left: Int, right: Int): Boolean {
+    var i = left
+    var j = right
+    while (i < j) {
+        if (inputStr[i] == inputStr[j]) {
+            i++
+            j--
+        } else {
+            return false
+        }
+    }
+    return true
+}

src/test/kotlin/com/sample/umar/leetcodemediums/ValidParentheses.kt

@@ -0,0 +1,30 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(validParentheses("{[[[[]]]}()]"))
+}
+
+fun validParentheses(inputString: String): Boolean {
+    // declare a stack with list of chars to feed in
+    val stackCh: MutableList<Char> = mutableListOf<Char>()
+    for (ch in inputString) {
+        if (ch == '[' || ch == '(' || ch == '{') {
+            stackCh.add(ch)
+        }
+
+        if (ch == ']' || ch == ')' || ch == '}') {
+            if (stackCh.isEmpty()) return false
+            val top = stackCh.last()
+            if (ch == ']' && top != '[') {
+                return false
+            } else if (ch == ')' && top != '(') {
+                return false
+            } else if (ch == '}' && top != '{') {
+                return false
+            } else {
+                stackCh.removeAt(stackCh.size - 1)
+            }
+        }
+    }
+    return stackCh.isEmpty()
+}