leet code mediums

Author: Mohammad

src/test/kotlin/com/igorwojda/integer/digitfrequency/Challenge.kt

@@ -31,6 +31,17 @@ private fun processMap(data: String): MutableMap<String, Int> {
     return counterMap
 }
 
+
+private fun sortWithFreq(inputList: List<Int>): List<Int> {
+    val countFreq: MutableMap<Int, Int> = mutableMapOf<Int, Int>()
+
+    for (num in inputList) {
+        countFreq[num] = (countFreq[num] ?: 0) + 1
+    }
+
+    return emptyList()
+}
+
 private class Test {
     @Test
     fun `'789' and '897' have the same digit frequency`() {

src/test/kotlin/com/igorwojda/integer/pyramidgenerator/Challenge.kt

@@ -4,7 +4,15 @@ import org.amshove.kluent.shouldBeEqualTo
 import org.junit.jupiter.api.Test
 
 fun generatePyramid(n: Int): List<String> {
-    TODO("not implemented")
+    // two loops, space usually (n - i) and # is 2*i-1
+    val hash = "#"
+    val spacer = " "
+    val resultList: MutableList<String> = mutableListOf()
+    (1..n).forEach {
+        resultList.add(hash.repeat(2 * it - 1))
+    }
+    println(resultList)
+    return resultList
 }
 
 private class Test {

src/test/kotlin/com/igorwojda/integer/stepsgenerator/Challenge.kt

@@ -4,7 +4,29 @@ import org.amshove.kluent.shouldBeEqualTo
 import org.junit.jupiter.api.Test
 
 fun generateSteps(n: Int): List<String> {
-    TODO("not implemented")
+    val result: MutableList<String> = mutableListOf<String>()
+    //val str = "#"
+    //val spacer = " "
+    /*for (i in 1 .. n) {
+        result.add((str.repeat(i)) + spacer.repeat(n - i))
+    }
+    println(result)*/
+    // Without repeat, we need a total of three loops: 1. exact n times (rows), 2. for no. of "#", 3. for space (n - i)
+
+    for (i in 1 .. n) {
+        var str = ""
+        var storeSpacer = ""
+        val spacer = " "
+        for (j in 1 .. i) {
+            str += "#"
+            (j .. (n - i)).forEach {
+                storeSpacer += spacer
+            }
+        }
+        result.add(str + storeSpacer)
+    }
+    println(result)
+    return result
 }
 
 private class Test {

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

@@ -0,0 +1,6 @@
+Need to learn:
+* HashMap internals and collections in general
+	•	What is hash collision and Why hash collisions are rare
+	•	How HashSet avoids duplicates
+	•	Big-O cheat sheet for Kotlin collections
+

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

@@ -0,0 +1,26 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(findDuplicates(listOf<Int>(1, 2, 2, 3, 4, 2, 3, 6, 4, 7, 8, 3)))
+}
+
+// return the duplicate numbers
+fun findDuplicates(inputList: List<Int>): List<Int> {
+    // declare a map and use the input value to process and set the numbers freq
+    val freqMap: MutableMap<Int, Int> = mutableMapOf<Int, Int>()
+    val resultList: MutableList<Int> = mutableListOf()
+    for (i in inputList) {
+        freqMap[i] = (freqMap[i] ?: 0) + 1
+    }
+
+    freqMap.forEach { (value, count) ->
+        if (count > 1) {
+            resultList.add(value)
+        }
+    }
+    return resultList
+}
+
+/*
+also learn about how to add prefix values in existing list?
+ */

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

@@ -0,0 +1,36 @@
+package com.sample.umar.leetcodemediums
+
+import java.lang.Integer.max
+
+fun main() {
+    println(longestSubString("abcghsccdef"))
+}
+
+fun longestSubString(inputStr: String): Int {
+    var maxLength = 0
+    val setChars = mutableSetOf<Char>()
+    var start = 0
+
+    for(end in inputStr.indices) {
+        val currentChar = inputStr[end]
+        // use while, not if, because the window may contain multiple copies of the same chars 'bbb'
+        while (setChars.contains(currentChar)) {
+            setChars.remove(inputStr[start])
+            start ++
+        }
+        setChars.add(currentChar)
+        maxLength = max(maxLength, end - start + 1)
+    }
+
+    return maxLength
+}
+
+/**
+ * for (end in s.indices) {
+ *     while (duplicate) shrink from left
+ *     add char at end
+ *     update max (maxLength, end-start + 1)
+ * }
+ *
+ * O(n) due to sign operation of add or remove and o(1) for space due to unique chars
+ */

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

@@ -0,0 +1,48 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(majorityNumber(listOf<Int>(1, 2, 3, 3, 3, 2, 3, 2, 3, 3, 3, 5, 6)))
+}
+
+fun majorityNumber(inputList: List<Int>): Int {
+    // store the freq of numbers in a map
+    val freqMap = mutableMapOf<Int, Int>()
+
+    inputList.forEach {
+        freqMap[it] = (freqMap[it] ?: 0) + 1
+    }
+
+    for (i in freqMap.keys) {
+        val counter = freqMap[i]
+        if (counter != null && counter > inputList.size / 2) {
+            return i
+        }
+    }
+    return 0
+}
+
+fun majorityElementMooreSolution(inputList: List<Int>): Int {
+    var candidate = 0
+    var count = 0
+    for (num in inputList) {
+        if (count == 0) {
+            candidate = num
+        }
+
+        if (num == candidate) {
+            count++
+        } else {
+            count--
+        }
+    }
+
+    return candidate
+}
+
+/*
+    .   When count hits 0, pick a new candidate
+	•	Increase count when numbers match
+	•	Decrease count when they differ
+	•	Final candidate is majority element
+	No maps, no sorting, no extra loops.
+ */

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

@@ -0,0 +1,21 @@
+package com.sample.umar.leetcodemediums
+
+import kotlin.math.max
+
+fun main() {
+    println(maxSubArraySum(listOf<Int>(-1, 0, 1, 2, 3, -2, 1, 4, 5)))
+}
+
+fun maxSubArraySum(inputList: List<Int>): Int {
+    var currentSum = inputList[0]
+    var maxSum = inputList[0]
+
+    // Should I start a new subarray from this number?
+    // Or should I extend the previous running sum?
+    // update the maxSum to keep a track and return
+    for (i in 1..inputList.size - 1) {
+        currentSum = max(inputList[i], inputList[i] + currentSum)
+        maxSum = max(maxSum, currentSum)
+    }
+    return maxSum
+}

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

@@ -0,0 +1,21 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(findMissingNumber(listOf<Int>(0)))
+}
+
+// Only one number will be missing and the input range is always n + 1 inclusive of 0
+fun findMissingNumber(inputList: List<Int>): Int {
+    // Let's use a set to store the numbers and lookup against the input list that will be o(1) for lookup
+    val elementSet: MutableSet<Int> = mutableSetOf()
+
+    inputList.forEach {
+        elementSet.add(it)
+    }
+
+    for (i in 0..inputList.size) {
+        if (!elementSet.contains(i)) return i
+    }
+
+    return 0
+}

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

@@ -0,0 +1,29 @@
+package com.sample.umar.leetcodemediums
+
+fun main() {
+    println(moveZeros(listOf<Int>(1, 3, 4, 5, 6, 0, 1, 4, 0, 3, 2, 0, 9)))
+}
+
+
+fun moveZeros(inputList: List<Int>): List<Int> {
+    // filter non zeros from the give list and move it to a result list
+    val resultList = mutableListOf<Int>()
+    val inputSize = inputList.size
+
+    for (i in inputList.indices) {
+        if (inputList[i] != 0) {
+            resultList.add(inputList[i])
+        }
+    }
+
+    println(resultList)
+
+    // filtered and added all non-zero elements now get the difference in size
+    val zeroSize = inputSize - resultList.size
+
+    (0 until zeroSize).forEach { _ ->
+        resultList.add(0)
+    }
+
+    return resultList
+}