practice stuffs

Author: Mohammad

src/test/kotlin/com/sample/umar/Learnings

@@ -4,3 +4,4 @@ Need to learn:
 	•	How HashSet avoids duplicates
 	•	Big-O cheat sheet for Kotlin collections
 
+* slow write and fast scan cheat code

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

@@ -59,6 +59,7 @@ fun backSpaceCharEquality(str1: String, str2: String): Boolean {
 	    • 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.
+	4.	Else If mismatch in size → return false.
+	5.  Else decrement both the pointers
+	6.	If both reach past the beginning → return true.
  */

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

@@ -0,0 +1,19 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(binarySearch(listOf<Int>(1, 3, 4, 5, 6, 7, 2), 6))
+}
+
+fun binarySearch(inputList: List<Int>, target: Int): Int {
+    var left = 0
+    var right = inputList.size - 1
+
+    while (left <= right) {
+        //compute mid
+        val mid = (left + right) / 2
+        if (target == inputList[mid]) return mid
+        if (target < inputList[mid]) right = mid - 1
+        if (target > inputList[mid]) left = mid + 1
+    }
+    return left
+}

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

@@ -5,7 +5,7 @@ fun main() {
 }
 
 /*
-    .  Return the count of unique elements in a sorted array
+    .  Return the count of unique elements in a sorted array in-place
 	•	slow → points to where next unique value should be written
 	•	fast → scans the full list
 	->  space and time is o(1) and o(n)

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

@@ -14,8 +14,8 @@ 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() // timsort
-    //val sortedKeys = sortKeys(mapFreq.keys.toMutableList())
+    //val sortedkeys = mapFreq.keys.sorted() // timsort o(n log n)
+    //val sortedKeys = sortKeys(mapFreq.keys.toMutableList()) o(n2) due to nested loops
 
     fun sortKeysInline(): List<Int> {
         val keys = mapFreq.keys.toMutableList()

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

@@ -14,29 +14,30 @@ fun validPalindrome(inputStr: String): Boolean {
     var left = 0
     var right = inputStr.length - 1
 
+    fun checkPalindrome(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
+    }
+
     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 (checkPalindrome(left + 1, right) || checkPalindrome(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/practice/LongestSubStringArrayPrac.kt

@@ -0,0 +1,45 @@
+package com.sample.umar.leetcodemediums.practice
+
+import kotlin.math.max
+
+/**
+ * Requirements:
+ * 	•	Sliding window
+ * 	•	Use a Set (O(1) lookup)
+ * 	•	Expand window with end
+ * 	•	Shrink window with start
+ * 	•	Track max length
+ * 	•	No duplicates allowed
+ * 	•	Return the length (Int)
+ */
+
+/**
+ * Algo:
+ * Declare a variable as maxLength to 0 as fallback and start to 0
+ * Loop through the given input string and use variables end and start (slide window) and move start ++ if char is already present in the set and remove else add it to the set
+ * Finally once loop finished, calculate the max length of unique chars through end - start + 1 and return
+ *
+ * Complexity: o(n) for scanning and o(1) lookup space
+ */
+
+fun main() {
+    println(maxLengthLongestSubString("pwwkew"))
+}
+
+fun maxLengthLongestSubString(inputString: String): Int {
+    var maxLength = 0
+    var start = 0
+    val charSet = mutableSetOf<Char>()
+    for (end in 0 until inputString.length) {
+        while (charSet.contains(inputString[end])) {
+            // remove the element at start
+            charSet.remove(inputString[start])
+            start++
+        }
+        charSet.add(inputString[end])
+        maxLength = max(maxLength, end - start + 1)
+    }
+    return maxLength
+}
+
+

src/test/kotlin/com/sample/umar/leetcodemediums/practice/MoveZerosPrac.kt

@@ -0,0 +1,62 @@
+package com.sample.umar.leetcodemediums.practice
+
+//Return the array with all zeros moved to the end, maintaining the order of other elements.
+/*
+  Algorithm/Steps:
+    1. We can use a two pass approach
+    2. First pass o(n): Scan the input array and store non-zero elements in a result list
+    3. Calculate the zero's size from total size of input array - non zero result list
+    4. Append/add the zeros based on the zero's size to the result list and return
+
+    Time = O(n)
+    Space = O(n)
+
+    // Use in-place method with a slow and fast pointer. o(1) space
+    1. slow pointer to index/put the nonzero value
+    2. fast to scan the input list
+ */
+
+
+fun main() {
+    println(moveZeroInPlace(mutableListOf<Int>(0, 0, 2, 3, 1, 4, 5, 6, 7, 9, 8, 0, 3)))
+}
+
+// Two pass approach
+fun moveZeros(inputList: List<Int>): List<Int> {
+    val resultList = mutableListOf<Int>()
+
+    for (value in inputList) {
+        if (value != 0) resultList.add(value)
+    }
+    val nonZeroSize = inputList.size - resultList.size
+    repeat(nonZeroSize) {
+        resultList.add(0)
+    }
+    return resultList
+}
+
+//in-place approach
+fun moveZeroInPlace(inputList: MutableList<Int>): List<Int> {
+    // slow pointer to index/put the nonzero value
+    var slow = 0
+    for (fast in 0 until inputList.size) {
+        if (inputList[fast] != 0) {
+            inputList[slow] = inputList[fast]
+            slow++
+        }
+    }
+
+    while (slow < inputList.size) {
+        inputList[slow] = 0
+        slow++
+    }
+    return inputList
+}
+
+/*
+I used a slow pointer to collect all non-zero elements in the front while preserving order,
+then filled the rest with zeros.
+This yields O(n) time and O(1) space.
+ */
+
+

src/test/kotlin/com/sample/umar/leetcodemediums/practice/ProductExpectSelfPrac.kt

@@ -0,0 +1,36 @@
+package com.sample.umar.leetcodemediums.practice
+
+
+// Use prefix and suffix logic and derive the product moving left and right expect the selected element
+fun main() {
+    println(productExpectSelf(listOf<Int>(1, 2, 3, 4, 5)))
+}
+
+fun productExpectSelf(inputList: List<Int>): List<Int> {
+    // Declare a result list with default value as 1 matching the input list size we can overwrite
+    // the products into respective positions
+    val resultList: MutableList<Int> = MutableList(inputList.size) { 1 }
+
+    // Use prefix to product the left side of the element
+    var prefix = 1
+    // Use suffix to product the right side of the element
+    var suffix = 1
+
+    for (i in 0 until inputList.size) {
+        resultList[i] = prefix
+        prefix *= inputList[i]
+    }
+
+    for (j in inputList.size - 1 downTo 0) {
+        resultList[j] *= suffix
+        suffix *= inputList[j]
+    }
+
+    return resultList
+}
+
+/**
+ * I build a prefix product and suffix product,
+ * and combine them in a single result array.
+ * Time O(n), space O(1) without extra result array
+ */

src/test/kotlin/com/sample/umar/leetcodemediums/practice/TwoSumPrac.kt

@@ -0,0 +1,33 @@
+package com.sample.umar.leetcodemediums.practice
+
+fun main() {
+    println(twoSumIndices(listOf<Int>(1, 2, 4, 5, 2, 3, 8, 6), 7))
+}
+
+fun twoSumIndices(inputList: List<Int>, target: Int): Pair<Int, Int> {
+    val lookUpMap: MutableMap<Int, Int> = mutableMapOf<Int, Int>()
+
+    inputList.forEachIndexed { index, value ->
+        lookUpMap[value] = index
+    }
+    // Compute the complement
+    for (i in 0 until inputList.size) {
+        val complement = target - inputList[i]
+        // Look up for the complement existence
+        if (lookUpMap.contains(complement) && i != lookUpMap[complement]) {
+            return Pair(i, lookUpMap[complement]!!)
+        }
+    }
+    return Pair(0, 0)
+}
+
+/**
+ * Algo:
+ * 1. Declare an mutable map and store its key as input value and value as an index to that value
+ * 2. Compute a complement as target - current value
+ * 3. Loop up for that complement in the map and if present and the index is not the same as input list then return the index of it as well as the current value
+ * 4. Put in a pair and return
+ *
+ * Complexity: o(n) for populating the map and o(1) for lookup
+ *
+ */