solve : week 2 with swift

Author: changmuk.im

counting-bits/EGON.swift

@@ -0,0 +1,113 @@
+import Foundation
+
+class Solution {
+    func countBits(_ n: Int) -> [Int] {
+        return solve_2(n)
+    }
+    
+    /*
+        **내장함수를 사용한 풀이**
+     
+        Runtime: 37 ms (Beats 49.12%)
+        Time Complexity: O(n * log n)
+            - 길이가 n인 range를 순회하므로 O(n)
+            - 정수에 대해 non zero bit를 세는데 O(log n)
+            > O(n * log n)
+        Space Complexity: O(n)
+            - 배열에 값을 저장하며 크기가 n이 되므로 O(n)
+        Memory: 20.86 MB (Beats 90.106%)
+    */
+    func solve_1(_ n: Int) -> [Int] {
+        var result: [Int] = []
+        for num in 0...n {
+            result.append(num.nonzeroBitCount)
+        }
+        return result
+    }
+    
+    /*
+        ** Brian Kernighan's Algorithm을 사용한 풀이 **
+     
+        Runtime: 39 ms (Beats 42.11%)
+        Time Complexity: O(n * log n)
+            - 길이가 n인 range를 순회하므로 O(n)
+            - bitCountWithBrianKernighan 에서 내부 while문 실행마다 num이 절반으로 줄어드므로, 실행횟수는 O(log n)
+            > O(n * log n)
+        Space Complexity: O(n)
+            - 배열에 값을 저장하며 크기가 n이 되므로 O(n)
+        Memory: 16.01 MB (Beats 67.84%)
+    */
+    func solve_2(_ n: Int) -> [Int] {
+        
+        func bitCountWithBrianKernighan(_ num: Int) -> Int {
+            var num = num
+            var bitCount = 0
+            while 0 < num {
+                num &= (num - 1)
+                bitCount += 1
+            }
+            
+            return bitCount
+        }
+        
+        var result: [Int] = []
+        for num in 0...n {
+            result.append(bitCountWithBrianKernighan(num))
+        }
+        return result
+    }
+    
+    /*
+        ** MSB에 대해 DP를 사용한 풀이 **
+        > num의 비트 카운트 = MSB의 비트 카운트(1 고정) + (num - msb)의 비트 카운트
+     
+        Runtime: 36 ms (Beats 58.48%)
+        Time Complexity: O(n)
+            - 0부터 n까지 range를 순회하므로 O(n)
+            > O(n)
+        Space Complexity: O(n)
+            - 길이가 n인 dp 배열을 저장하므로 O(n)
+        Memory: 21.15 MB (Beats 67.84%)
+    */
+    func solve_3(_ n: Int) -> [Int] {
+        guard 1 <= n else { return [0] }
+        
+        var dp = [Int](repeating: 0, count: n + 1)
+        var msb = 1
+        for num in 1...n {
+            if msb << 1 == num {
+                msb = num
+            }
+            
+            dp[num] = 1 + dp[num - msb]
+        }
+        
+        return dp
+    }
+    
+    /*
+        ** LSB에 대해 DP를 사용한 풀이 **
+        > num의 비트 카운트 = num을 right shift한 숫자의 비트 카운트 + LSB의 비트 카운트(1 또는 0)
+     
+        Runtime: 28 ms (Beats 97.08%)
+        Time Complexity: O(n)
+            - 0부터 n까지 range를 순회하므로 O(n)
+            > O(n)
+        Space Complexity: O(n)
+            - 길이가 n인 dp 배열을 저장하므로 O(n)
+        Memory: 21.26 MB (Beats 53.80%)
+    */
+    func solve_4(_ n: Int) -> [Int] {
+        guard 1 <= n else { return [0] }
+        
+        var dp = [Int](repeating: 0, count: n + 1)
+        for num in 1...n {
+            dp[num] = dp[num >> 1] + (num & 1)
+        }
+        
+        return dp
+    }
+}
+
+let solution = Solution()
+print(solution.solve_4(0))

encode-and-decode-strings/EGON.swift

@@ -0,0 +1,68 @@
+import Foundation
+
+class Solution {
+    static let DELIMITER = ","
+    
+    /* ASCII 풀이 */
+    static let ASCII_STR_LENGTH = 3
+    
+    func encodeWithASCII(strs: [String]) -> String {
+        return strs.map { (str) in
+            str.compactMap { (char) in
+                guard let asciiValue = char.asciiValue else {
+                    return nil
+                }
+        
+                let asciiStr = String(asciiValue)
+                
+                return String(
+                    repeating: "0",
+                    count: Solution.ASCII_STR_LENGTH - asciiStr.count
+                ) + asciiStr
+            }.reduce("") { (acc, cur) in acc + cur }
+        }
+        .joined(separator: Solution.DELIMITER)
+    }
+    
+    func decodeWithASCII(str: String) -> [String] {
+        return str.components(separatedBy: Solution.DELIMITER)
+            .map { (encodedStr) in
+                return stride(from: 0, to: encodedStr.count, by: Solution.ASCII_STR_LENGTH)
+                    .compactMap { i in
+                        let startIndex = String.Index(utf16Offset: i, in: encodedStr)
+                        let endIndex = String.Index(utf16Offset: i + Solution.ASCII_STR_LENGTH, in: encodedStr)
+                        let asciiValue = UInt8(encodedStr[startIndex..<endIndex])
+                        return asciiValue
+                    }
+            }.compactMap { String(bytes: $0, encoding: .ascii) }
+    }
+    
+    /* BASE64 풀이 */
+    func encodeWithBASE64(strs: [String]) -> String {
+        return strs.compactMap { (str) in
+            if let data = str.data(using: .utf8) {
+                return data.base64EncodedString()
+            } else {
+                return nil
+            }
+        }.joined(separator: Solution.DELIMITER)
+    }
+    
+    func decodeWithBASE64(str: String) -> [String] {
+        return str.components(separatedBy: Solution.DELIMITER)
+            .compactMap { (encodedStr) in
+                if let data = Data(base64Encoded: encodedStr) {
+                    return String(data: data, encoding: .utf8)
+                } else {
+                    return nil
+                }
+            }
+    }
+}
+
+let solution = Solution()
+let strs = ["lint", "code", "love", "you"]
+let encoded = solution.encodeWithBASE64(strs: strs)
+print(encoded)
+let decoded = solution.decodeWithBASE64(str: encoded)
+print(decoded)

valid-anagram/EGON.swift

@@ -0,0 +1,34 @@
+class Solution {
+    
+    /*
+        Runtime: 16 ms (Beats 84.96%)
+        Time Complexity: O(n)
+            - 길이가 n인 str s, str t, dict counter를 순회하므로 O(3n) ~= O(n)
+        Space Complexity: O(n)
+            - 크기가 최대 n인 dict를 변수로 저장하여 사용하므로 O(n)
+        Memory: 16.01 MB (Beats 97.18%)
+    */
+    func isAnagram(_ s: String, _ t: String) -> Bool {
+        var countDict: [String.Element: Int] = [:]
+        
+        for char in s {
+            countDict[char] = (countDict[char] ?? 0) + 1
+        }
+        
+        for char in t {
+            guard let count = countDict[char] else {
+                return false
+            }
+            
+            countDict[char] = count - 1
+        }
+        
+        for count in countDict.values {
+            if count != 0 {
+                return false
+            }
+        }
+        
+        return true
+    }
+}