LatestUniqueOrder, MaximumSubArray, TopKElements, Zalando tech screening

Author: sumanas27

src/main/kotlin/dsalgoleetcode/LatestUniqueOrder.kt

@@ -0,0 +1,18 @@
+package main.kotlin.dsalgoleetcode
+
+class LatestUniqueOrder {
+
+    fun latestUniqueOrders(orders: List<Order>): List<Order> {
+        val latestMap = mutableMapOf<String, Order>()
+
+        for(order in orders){
+            val current = latestMap[order.id]
+            if(current == null || order.timestamp > current.timestamp){
+                latestMap[order.id] = order
+            }
+        }
+        return latestMap.values.toList()
+    }
+}
+
+data class Order(val id: String, val timestamp: Long)

src/main/kotlin/dsalgoleetcode/MaximumSubArray.kt

@@ -0,0 +1,40 @@
+package main.kotlin.dsalgoleetcode
+
+import kotlin.math.max
+
+/**
+ * Problem Statement:
+ * Given an integer array nums, find the contiguous subarray (containing at least one number)
+ * that has the largest sum, and return the sum.
+ *
+ * Input
+ * val nums = intArrayOf(-2, 1, -3, 4, -1, 2, 1, -5, 4)
+ *
+ * Output
+ * 6
+ *
+ * Explanation
+ * The subarray [4, -1, 2, 1] has the largest sum = 6.
+ * */
+
+class MaximumSubArray {
+
+    fun maximumSubArray(input: IntArray): Int{
+
+        var currentSum = input[0]
+        var maxSum = input[0]
+
+        for (element in input){
+            currentSum = currentSum + element
+            maxSum = max(maxSum, currentSum)
+            currentSum = max(currentSum, 0)
+        }
+        return maxSum
+    }
+}
+
+fun main(){
+
+    val maximumSubArray = MaximumSubArray()
+    println(maximumSubArray.maximumSubArray(intArrayOf(2,3,-8,7,-1, 2,3)))
+}

src/main/kotlin/dsalgoleetcode/TopKElements.kt

@@ -0,0 +1,20 @@
+package main.kotlin.dsalgoleetcode
+
+/**
+ *     val nums = listOf("apple", "banana", "apple", "orange", "banana", "apple")
+ *     val k = 2
+ * */
+
+
+class TopKElements {
+
+    fun topKFrequent(nums: List<String>, k: Int): List<String>{
+
+        return nums.groupingBy { it }
+            .eachCount() //{"apple" -> 3, "banana" -> 2, "orange" -> 1}
+            .entries // [Map.Entry("apple" → 3), Map.Entry("banana" → 2), ...]
+            .sortedByDescending { it.value } // ["apple" (3), "banana" (2), "orange" (1)]
+            .take(2)
+            .map { it.key } // ["apple", "banana"]
+    }
+}

src/main/kotlin/zalando/FetchProductExcludingCurrent.kt

@@ -0,0 +1,36 @@
+package main.kotlin.zalando
+
+/**
+ * Problem Statement:
+ * You are given an array of integers, where each element represents a product value.
+ * Return a new array result[] such that:
+ *
+ * result[i] is equal to the product of all elements in the original array except arr[i].
+ *
+ * [1, 2, 3, 4] => [24, 12, 8, 6]
+ * */
+
+class FetchProductExcludingCurrent {
+
+    fun fetchProduct(input: List<Int>): List<Int> {
+
+        var currentProduct = 1
+
+        val result = mutableListOf<Int>()
+
+        // for((element, index) in input.withIndex()){
+        //     var currentProduct = element * input[index + 1] *
+        // }
+        for (i in 0..input.size - 1) {
+            for (j in 0..input.size - 1) {
+                if (i == j) continue
+                currentProduct = currentProduct * input[j]
+            }
+            result.add(currentProduct)
+            currentProduct = 1
+        }
+
+        println(result)
+        return result
+    }
+}