Merge pull request #1991 from radiantchoi/main

[radiantchoi] WEEK 01 solutions

Author: radiantchoi

contains-duplicate/radiantchoi.swift

@@ -0,0 +1,15 @@
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        var occurences = [Int: Bool]()
+
+        for num in nums {
+            if let occurs = occurences[num] {
+                return occurs
+            } else {
+                occurences[num] = true
+            }
+        } 
+
+        return false
+    }
+}

house-robber/radiantchoi.swift

@@ -0,0 +1,20 @@
+class Solution {
+    func rob(_ nums: [Int]) -> Int {
+        if nums.count < 3 {
+            return nums.max()!
+        }
+
+        var expected = [Int]()
+        expected.append(nums[0])
+        expected.append(max(nums[0], nums[1]))
+
+        for i in 2..<nums.count {
+            let prev = expected[i - 1]
+            let prevPrev = expected[i - 2]
+
+            expected.append(max(prev, prevPrev + nums[i]))
+        }
+
+        return expected.removeLast()
+    }
+}

top-k-frequent-elements/radiantchoi.swift

@@ -0,0 +1,17 @@
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var occurences = [Int: Int]()
+
+        for num in nums {
+            if let occurence = occurences[num] {
+                occurences[num] = occurence + 1
+            } else {
+                occurences[num] = 1
+            }
+        }
+
+        let numbers = occurences.keys.sorted { occurences[$0] ?? 0 > occurences[$1] ?? 0 }
+
+        return Array(numbers[0..<k])
+    }
+}

two-sum/radiantchoi.swift

@@ -0,0 +1,26 @@
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        let nums = nums.enumerated().sorted { $0.1 < $1.1 }
+
+        for (index, num) in nums {
+            let newTarget = target - num
+
+            var left = 0
+            var right = nums.count - 1
+
+            while left <= right {
+                let mid = (left + right) / 2
+
+                if nums[mid].1 == newTarget && nums[mid].0 != index {
+                    return [index, nums[mid].0]
+                } else if nums[mid].1 < newTarget {
+                    left = mid + 1
+                } else {
+                    right = mid - 1
+                }
+            }
+        }
+
+        return [0, 1]
+    }
+}