[devdays9] WEEK 01 solutions

contains-duplicate/devdays9.kt

@@ -0,0 +1,6 @@
+class Solution {
+    fun containsDuplicate(nums: IntArray): Boolean {
+        val occurrences = HashSet<Int>(nums.size)
+        return nums.any { !occurrences.add(it) }
+    }
+}

house-robber/devdays9.kt

@@ -0,0 +1,15 @@
+import kotlin.math.max
+
+class Solution {
+    fun rob(nums: IntArray): Int {
+        var prevMaxMoney = 0
+        var maxMoney = 0
+        for (money in nums) {
+            prevMaxMoney.let {
+                prevMaxMoney = maxMoney
+                maxMoney = max(it + money, maxMoney)
+            }
+        }
+        return maxMoney
+    }
+}

longest-consecutive-sequence/devdays9.kt

@@ -0,0 +1,19 @@
+import kotlin.math.max
+
+class Solution {
+    fun longestConsecutive(nums: IntArray): Int {
+        val numsSet = nums.toHashSet()
+        var maxLength = 0
+        for (num in numsSet) {
+            if (num - 1 in numsSet) {
+                continue
+            }
+            var length = 1
+            while (num + length in numsSet) {
+                ++length
+            }
+            maxLength = max(length, maxLength)
+        }
+        return maxLength
+    }
+}

top-k-frequent-elements/devdays9.kt

@@ -0,0 +1,18 @@
+import java.util.PriorityQueue
+
+typealias Number = Int
+typealias Frequency = Int
+
+class Solution {
+    fun topKFrequent(nums: IntArray, k: Int): IntArray {
+        val frequencyMap = HashMap<Number, Frequency>(nums.size)
+        nums.forEach {
+            frequencyMap.merge(it, 1, Int::plus)
+        }
+        val heap = PriorityQueue<Int>(frequencyMap.size) { num1, num2 ->
+            frequencyMap[num2]!!.compareTo(frequencyMap[num1]!!)
+        }
+        heap += frequencyMap.keys
+        return IntArray(k) { heap.poll() }
+    }
+}

two-sum/devdays9.kt

@@ -0,0 +1,15 @@
+typealias Number = Int
+typealias Index = Int
+
+class Solution {
+    fun twoSum(nums: IntArray, target: Int): IntArray {
+        val occurrences = HashMap<Number, Index>(nums.size)
+        nums.forEachIndexed { index, num ->
+            occurrences[target - num]?.let { complementIndex ->
+                return intArrayOf(index, complementIndex)
+            }
+            occurrences[num] = index
+        }
+        return intArrayOf()
+    }
+}