20 and 33

Author: zyterence

Week_01/id_17/LeetCode_20_17.swift

@@ -0,0 +1,66 @@
+class Solution {
+    func isValid(_ s: String) -> Bool {
+        var stack1 = Stack(Array(s))
+        var stack2 = Stack([Character]())
+
+        while !stack1.isEmpty {
+            let a = stack1.pop()!
+            if let b = stack2.peek() {
+                if map(a) > 0 && map(a)+map(b) == 0 {
+                    stack2.pop()
+                } else {
+                    stack2.push(a)
+                }
+            } else {
+                stack2.push(a)
+            }
+        }
+
+        if stack2.isEmpty {
+            return true
+        } else {
+            return false
+        }
+    }
+
+    func map(_ character: Character) -> Int {
+        switch character {
+        case "(": return 1
+        case ")": return -1
+        case "{": return 2
+        case "}": return -2
+        case "[": return 4
+        case "]": return -4
+        default: return 0
+        }
+    }
+}
+
+struct Stack<Element> {
+	
+	private var storage: [Element] = []
+	
+	public init(_ elements: [Element]) {
+		storage = elements
+	}
+	
+	public mutating func push(_ element: Element) {
+		storage.append(element)
+	}
+	
+	@discardableResult
+	public mutating func pop() -> Element? {
+		return storage.popLast()
+	}
+	
+	func peek() -> Element? {
+		return storage.last
+	}
+	
+	public var isEmpty: Bool {
+		return peek() == nil
+	}
+}
+
+// Runtime: 12 ms, faster than 52.39% of Swift online submissions for Valid Parentheses.
+// Memory Usage: 19.7 MB, less than 12.25% of Swift online submissions for Valid Parentheses.

Week_01/id_17/LeetCode_33_17.swift

@@ -0,0 +1,46 @@
+class Solution {
+    func search(_ nums: [Int], _ target: Int) -> Int {
+        if nums.count == 0 { return -1 }
+        let breakPoint = find_breakPoint(nums)
+        return binary_search(nums, target, offset: breakPoint)
+    }
+
+    func find_breakPoint(_ numbers: [Int]) -> Int {
+        for (index, number) in numbers.enumerated() {
+            if number < numbers[0] { return index }
+        }
+        return 0
+    }
+
+    func binary_search(_ numbers: [Int], _ target: Int, offset: Int) -> Int {
+        if numbers.count == 0 { return -1 }
+        var low = 0
+        var high = numbers.count - 1
+
+        while low <= high {
+            let middle = (low + high)/2
+            let index = realIndex(middle, count: numbers.count, offset: offset)
+            let number = numbers[index]
+            if number == target {
+                return index
+            } else if number < target {
+                low = middle + 1
+            } else {
+                high = middle - 1
+            }
+        }
+
+        return -1
+    }
+
+    func realIndex(_ index: Int, count: Int, offset: Int) -> Int {
+        if index < count-offset {
+            return index+offset
+        } else {
+            return index+offset-count
+        }
+    }
+}
+
+// Runtime: 20 ms, faster than 100.00% of Swift online submissions for Search in Rotated Sorted Array.
+// Memory Usage: 19 MB, less than 33.33% of Swift online submissions for Search in Rotated Sorted Array.