after ox round

Author: Mohammad

src/test/kotlin/com/sample/umar/SampleTry.kt

@@ -43,6 +43,7 @@ private fun createEmptyTempFile(fileName: String?, contentType: String?) {
     } catch (e: IOException) {
         println("Security exception occurred: ${e.message}")
     }
+
 }
 
 private fun getFileNamePrefix(fileName: String?): String {

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

@@ -7,7 +7,7 @@ fun main() {
 // 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)
+    //normalise the k (reduces the number of rotations which produce same result)
     val k = step % inputList.size
 
     fun reverse(startIndex: Int, endIndex: Int) {

src/test/kotlin/com/sample/umar/leetcodemediums/okx/TwoStringOfSame.kt

@@ -0,0 +1,34 @@
+package com.sample.umar.leetcodemediums.okx
+
+/*
+You are given 2 strings of the same length, consisting of 0-1. We call them string A and string B. Now we want to make them become the same string. We only have one operation. That is to select one character in A and swap with another character in B(You can choose any position in the string).
+Then what is the minimum number of operations, we can make two strings become the same string.
+ */
+
+//Also some questions
+/**
+ * 1. What is memory leaks and how to detect memory leaks in production
+ * 2. What is fps and how ui is rendered and what process happened during ui rendering
+ * 3. What is the difference between apk and aab
+ *
+ */
+
+fun main() {
+    println(minOperationsToMakeEqual("0101", "0011")) // Output: 1
+    println(minOperationsToMakeEqual("01010", "10100")) // Output: 2
+    println(minOperationsToMakeEqual("011", "000")) // Output: -1
+}
+
+fun minOperationsToMakeEqual(A: String, B: String): Int {
+    if (A.length != B.length) return -1
+
+    var count01 = 0
+    var count10 = 0
+
+    for (i in A.indices) {
+        if (A[i] == '0' && B[i] == '1') count01++
+        if (A[i] == '1' && B[i] == '0') count10++
+    }
+
+    return if (count01 == count10) count01 else -1
+}

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

@@ -77,7 +77,7 @@ fun backSpaceCompare(str1: String, str2: String): Boolean {
 	    • You skip all characters that should be removed
 	    • You stop on the next valid letter: break
 	2.	Move j left same way.
-	3.	Compare the valid characters at i and j.
+	3.	Compare the valid characters at i and j if mismatch return false.
 	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/practice/BinaryInsertPositionPrac.kt

@@ -4,7 +4,7 @@ package com.sample.umar.leetcodemediums.practice
  * Given a sorted list of integers and a target value, return the index where the target should be inserted.
  * Requirements:
  * 	•	Use binary search
- * 	•	O(log n) time
+ * 	•	O(log n) time (Anything we divide)
  * 	•	O(1) space
  * 	•	If target exists → return its index
  * 	•	If not → return the index where it should be inserted

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

@@ -0,0 +1,38 @@
+package com.sample.umar.leetcodemediums.practice
+
+/**
+ * maxProfit(listOf(7,1,5,3,6,4))  // returns 5
+ *
+ * Algo:
+ * Two pointer approach: create buy and sell planned for next day to arrive max profit on the given list of prises
+ * If the value of sell is greater the value of buy then compute (sell -  buy) to arrive max profit
+ * Else assign the buy as sell and continue until arrive we arrive profit by moving sell pointer ahead
+ *
+ * O(n)
+ */
+
+
+fun main() {
+    println(maxProfit(listOf(7, 1, 5, 3, 6, 4)))
+}
+
+fun maxProfit(inputList: List<Int>): Int {
+    // two pointer approach
+    var buy = 0
+    var sell = 1
+    var maxProfit = 0
+
+    while (sell < inputList.size) {
+        if (inputList[sell] > inputList[buy]) {
+            // Profit made
+            val profit = inputList[sell] - inputList[buy]
+            maxProfit = maxOf(maxProfit, profit)
+        } else {
+            // find better price to buy
+            buy = sell
+        }
+        sell++
+    }
+
+    return maxProfit
+}

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

@@ -0,0 +1,60 @@
+package com.sample.umar.leetcodemediums.practice
+
+/**
+ * 1. Create a map of <String, MutableList<String>>
+ *
+ * 2. Loop through each word in the input list:
+ *        - Sort the characters of the word → this becomes the key
+ *        - If this sorted key is NOT in the map:
+ *              create a new empty list for that key
+ *        - Add the original word to the list stored under this key
+ *
+ * 3. After processing all words:
+ *        return all the values of the map (each value is a group of anagrams)
+ *
+ * ⏱ Time:
+ *
+ * O(n · k log k)
+ * (n strings, each sorted with length k)
+ *
+ * 💾 Space:
+ *
+ * O(n · k)
+ * (groups stored in map)
+ *
+ * Time Complexity:
+ *
+ * “For each of n strings I sort its characters, which costs O(k log k).
+ * Therefore the total complexity is O(n · k log k).”
+ *
+ * Space Complexity:
+ *
+ * “I store groups of anagrams inside a map.
+ * In the worst case that requires O(nk) space.”
+ */
+
+fun main() {
+    println(groupAnagrams(listOf<String>("eat", "tea", "tan", "ate", "nat", "bat")))
+}
+
+fun groupAnagrams(inputString: List<String>): List<List<String>> {
+    // Create a map to store the key as input words in a sorted order and for every match create and append it to a list of word and return
+    val freqMap = mutableMapOf<String, MutableList<String>>()
+    inputString.forEach { str ->
+        val charListStr = mutableListOf<Char>()
+        for (i in 0 until str.length) {
+            charListStr.add(str[i])
+        }
+        var sortedString = ""
+        charListStr.sorted().forEach {
+            sortedString += it.toString()
+        }
+        if (!freqMap.containsKey(sortedString)) {
+            freqMap[sortedString] = mutableListOf<String>(str)
+        } else {
+            val valueList = freqMap[sortedString]
+            valueList?.add(str)
+        }
+    }
+    return freqMap.values.toList()
+}

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

@@ -0,0 +1,25 @@
+package com.sample.umar.leetcodemediums.practice
+
+import kotlin.math.max
+
+fun main() {
+    println(maxSubArraySumKadane(listOf(-1, 0, 2, 3, 4, -2, 4, 7, -9)))
+}
+
+
+/**
+ * Iterate the given input list and find the max sum of subarray
+ * Declare two vars called currentsum and maxsum and access the first element
+ * Decide to start a new subarray sum or extend the summation through finding its max
+ */
+
+fun maxSubArraySumKadane(inputList: List<Int>): Int {
+    var currentMax = inputList[0]
+    var maxSum = inputList[0]
+
+    for (i in 1 until inputList.size) {
+        currentMax = max(inputList[i], inputList[i] + currentMax)
+        maxSum = max(maxSum, currentMax)
+    }
+    return maxSum
+}

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

@@ -0,0 +1,56 @@
+package com.sample.umar.leetcodemediums.practice
+
+/**
+ * Given: When two intervals overlap, you should merge them into ONE interval.
+ * [[1,3], [2,6], [8,10], [15,18]] -> [[1,6], [8,10], [15,18]]
+ *
+ * Complexity: Time o(n log n) and space O(n)
+ *
+ * Algo:
+ * 1. Sort intervals by start.
+ * 2. Scan left to right and merge whenever current.start <= last.end.
+ * 3. If no overlap, append as new interval.
+ * 4. Return merged list.
+ */
+
+
+fun main() {
+    val inputList: MutableList<MutableList<Int>> =
+        mutableListOf(mutableListOf<Int>(1, 3), mutableListOf<Int>(8, 10), mutableListOf<Int>(2, 6))
+    println(mergeInterval(inputList))
+}
+
+fun mergeInterval(inputList: MutableList<MutableList<Int>>): List<List<Int>> {
+    // Step 1: Sort intervals by start time
+    val sortedList = inputList.sortedBy { it[0] }
+
+    val resultList = mutableListOf<MutableList<Int>>()
+
+    for (interval in sortedList) {
+        // Let interval = [start, end]
+        val currentStart = interval[0]
+        val currentEnd = interval[1]
+        // If result is empty OR current interval starts after last merged interval ends
+        if (resultList.isEmpty() || currentStart > resultList.last()[1]) {
+            // --------- NO OVERLAP ---------
+            // Safe to add new interval
+            resultList.add(interval)
+
+        } else {
+            // --------- OVERLAP ---------
+            // Merge current interval with the last one in the result
+            val lastMerged = resultList.last()
+            lastMerged[1] = maxOf(lastMerged[1], currentEnd)
+        }
+    }
+
+    return resultList
+}
+
+/**
+ * For each interval:
+ *    If result is empty → add it
+ *    Else:
+ *       If no overlap → add it
+ *       If overlap → merge by extending end
+ */

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

@@ -14,6 +14,7 @@ package com.sample.umar.leetcodemediums.practice
     // 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
+    3. Finally, move the zeros to the last by using slow value and check against the inputList.size
  */
 
 
@@ -46,6 +47,7 @@ fun moveZeroInPlace(inputList: MutableList<Int>): List<Int> {
         }
     }
 
+    // New move the zeroes to the right
     while (slow < inputList.size) {
         inputList[slow] = 0
         slow++