The LeetCode problem [53, 54]'s Swift solution.

Author: hypeagle

README.md

@@ -25,6 +25,8 @@
 
 [38. Count and Say](https://leetcode.com/problems/count-and-say) [[C](./src/38.c)]
 
+[53. Maximum Subarray](https://leetcode.com/problems/maximum-subarray) [[Swift](./swift/53.swift)]
+
 ## Medium
 [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers) [[C](./src/2.c)]
 
@@ -80,6 +82,8 @@
 
 [50. Pow(x, n)](https://leetcode.com/problems/powx-n) [[C](./src/50.c)]
 
+[54. Spiral Matrix](https://leetcode.com/problems/spiral-matrix) [[Swift](./swift/54.swift)]
+
 ## Hard
 [4. Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays) [[C](./src/4.c)]
 

swift/53.swift

@@ -0,0 +1,49 @@
+
+// 53. Maximum Subarray
+
+class Solution {
+ func maxSubArrayDC(_ nums: [Int], x: Int, y: Int) -> Int {
+ var v: Int, L: Int, R: Int, maxs: Int
+ if x + 1 == y {
+ return nums[x]
+ }
+ 
+ let m = (x + y) >> 1
+ maxs = max(maxSubArrayDC(nums, x: x, y: m), maxSubArrayDC(nums, x: m, y: y))
+ 
+ v = 0
+ L = nums[m - 1]
+ for i in stride(from: m - 1, to: x - 1, by: -1) {
+ v += nums[i]
+ L = max(L, v)
+ }
+ 
+ v = 0
+ R = nums[m]
+ for i in m ..< y {
+ v += nums[i]
+ R = max(R, v)
+ }
+ 
+ return max(maxs, L + R)
+ }
+ 
+ func maxSubArray(_ nums: [Int]) -> Int {
+// var maxNums = nums
+// let numsLen = nums.count
+// 
+// var maxValue: Int = maxNums[0]
+// 
+// for i in 1 ..< numsLen {
+// maxNums[i] = max(nums[i], (maxNums[i - 1] + nums[i]))
+// if maxNums[i] > maxValue {
+// maxValue = maxNums[i]
+// }
+// }
+// 
+// return maxValue
+ return maxSubArrayDC(nums, x: 0, y: nums.count)
+ }
+}
+
+// print(Solution().maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))

swift/54.swift

@@ -0,0 +1,61 @@
+
+// 54. Spiral Matrix
+
+class Solution {
+ func spiralOrder(_ matrix: [[Int]]) -> [Int] {
+ let m = matrix.count
+ if m == 0 {
+ return []
+ }
+ let n = matrix[0].count
+ if n == 0 {
+ return []
+ }
+ var ret: [Int] = Array.init(repeating: 0, count: m * n)
+ var flag: [Bool] = Array.init(repeating: false, count: m * n)
+ var count = 0
+ var x = 0
+ var y = 0
+ ret[count] = matrix[x][y]
+ flag[0] = true
+ count += 1
+ 
+ while count < m * n {
+ while count < m * n && y + 1 < n && !flag[x * n + y + 1] {
+ ret[count] = matrix[x][y + 1]
+ flag[x * n + y + 1] = true
+ y += 1
+ count += 1
+ }
+ 
+ while count < m * n && x + 1 < m && !flag[(x + 1) * n + y] {
+ ret[count] = matrix[x + 1][y]
+ flag[(x + 1) * n + y] = true
+ x += 1
+ count += 1
+ }
+ 
+ while count < m * n && y - 1 >= 0 && !flag[x * n + y - 1] {
+ ret[count] = matrix[x][y - 1]
+ flag[x * n + y - 1] = true
+ y -= 1
+ count += 1
+ }
+ 
+ while count < m * n && x - 1 >= 0 && !flag[(x - 1) * n + y] {
+ ret[count] = matrix[x - 1][y]
+ flag[(x - 1) * n + y] = true
+ x -= 1
+ count += 1
+ }
+ }
+ 
+ return ret
+ }
+}
+
+// let matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+// let matrix = [[3], [2]]
+// let ret = Solution().spiralOrder(matrix) 
+// 
+// print(ret)