[doitduri] Week01 Solutions

contains-duplicate/doitduri.swift

@@ -0,0 +1,6 @@
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        let numbericSet = Set(nums)
+        return numbericSet.count < nums.count
+    }
+}

house-robber/doitduri.swift

@@ -0,0 +1,23 @@
+class Solution {
+func rob(_ nums: [Int]) -> Int {
+        let length = nums.count
+
+        if length == 1 {
+            return nums[0]
+        }
+
+        if length == 2 {
+            return max(nums[0], nums[1])
+        }
+
+        var tables = Array(repeating: 0, count: length)
+        tables[0] = nums[0]
+        tables[1] = max(nums[0], nums[1])
+
+        for i in 2..<length {
+            tables[i] = max(nums[i]+tables[i-2], tables[i-1])
+        }
+
+        return tables[length-1]
+    }
+}

longest-consecutive-sequence/doitduri.swift

@@ -0,0 +1,30 @@
+class Solution {
+    func longestConsecutive(_ nums: [Int]) -> Int {
+        var result = 1
+        var maxResult = 1
+        let sortedNums = nums.sorted()
+
+        guard var previous = sortedNums.first else {
+            return 0
+        }
+
+        for index in 1..<sortedNums.count {
+            let next = sortedNums[index]
+
+            if previous == next { // 숫자가 같으면 카운팅하지 않는다.
+                continue
+            }
+
+            if previous + 1 == next {
+                result += 1
+                maxResult = max(maxResult, result)
+            } else {
+                result = 1
+            }
+
+            previous = next
+        }
+
+        return maxResult
+    }
+}

top-k-frequent-elements/doitduri.swift

@@ -0,0 +1,18 @@
+class Solution {
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var tables: [Int: Int] = [:]
+
+        for num in nums {
+            tables[num] = (tables[num] ?? 0) + 1
+        }
+
+        let values = tables.values.sorted().reversed().prefix(k) // k개의 frequent
+        let result = tables.compactMap { (key: Int, value: Int) -> Int? in
+            if values.contains(value) {
+                return key
+            }
+            return nil
+        }
+        return result
+    }
+}

two-sum/doitduri.swift

@@ -0,0 +1,16 @@
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        let dict = nums.enumerated().reduce(into: [Int: Int]()) { initialValue, num in
+            initialValue[num.element] = num.offset
+        }
+
+        for startIndex in 0..<nums.count {
+            let findValue = target - nums[startIndex]
+            if let endIndex = dict[findValue], startIndex != endIndex {
+                return [startIndex, endIndex]
+            }
+        }
+
+        return []
+    }
+}