[Swift]LeetCode896. 单调数列 | Monotonic Array

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10606658.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

An array is monotonic if it is either monotone increasing or monotone decreasing.

An array A is monotone increasing if for all i <= j, A[i] <= A[j].  An array A is monotone decreasing if for all i <= j, A[i] >= A[j].

Return true if and only if the given array A is monotonic. 

Example 1:

Input: [1,2,2,3]
Output: true

Example 2:

Input: [6,5,4,4]
Output: true

Example 3:

Input: [1,3,2]
Output: false

Example 4:

Input: [1,2,4,5]
Output: true

Example 5:

Input: [1,1,1]
Output: true 

Note:

1. 1 <= A.length <= 50000
2. -100000 <= A[i] <= 100000

---

如果数组是单调递增或单调递减的，那么它是单调的。

如果对于所有 i <= j，A[i] <= A[j]，那么数组 A 是单调递增的。 如果对于所有 i <= j，A[i]> = A[j]，那么数组 A 是单调递减的。

当给定的数组 A 是单调数组时返回 true，否则返回 false。 

示例 1：

输入：[1,2,2,3]
输出：true

示例 2：

输入：[6,5,4,4]
输出：true

示例 3：

输入：[1,3,2]
输出：false

示例 4：

输入：[1,2,4,5]
输出：true

示例 5：

输入：[1,1,1]
输出：true 

提示：

1. 1 <= A.length <= 50000
2. -100000 <= A[i] <= 100000

---

500ms

 

class Solution {
    enum Order: UInt8 {
        case increasing
        case decreasing
        case identical
        case nonMonotonic
    }
    
    func isMonotonic(_ A: [Int]) -> Bool {
        guard A.count > 1 else {
            return true
        }

        var last = A[0]
        var order: Order = .identical

        for idx in 1..<A.count {
            let num = A[idx]
            if num == last {
                continue
            } else if (num < last && order == .increasing)
            || (num > last && order == .decreasing) {
                order = .nonMonotonic
                break
            } else if order == .identical {
                order = num < last ? .decreasing : .increasing
            }
            last = num
        }
        return order != .nonMonotonic
    }
}

---

Runtime: 504 ms

Memory Usage: 19.6 MB

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        var crement = true
        if A.last! < A.first! {
            crement = false
        }
        for i in 1..<A.count {
            if crement {
                if A[i] < A[i-1] {
                    return false
                }
            } else {
                if A[i] > A[i-1] {
                    return false
                }
            }
        }
        return true
    }
}

---

580ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        let count = A.count
        guard count > 2 else {
            return true
        }
        
        var flag: Bool?
        for i in 1..<count {
            if A[i] > A[i - 1] {
                if let mark = flag {
                    if !mark {
                        return false
                    }
                } else {
                    flag = true
                }
            } else if A[i] < A[i - 1] {
                if let mark = flag {
                    if mark {
                        return false
                    }
                } else {
                    flag = false
                }
            }
        }
        return true
    }
}

---

588ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        var store: Int = 0
        for i in 0..<(A.count-1){
            let flag = compare(A[i] , A[i+1])
            
            if flag != 0{
                if flag != store , store != 0{
                    return false
                }
                store = flag
            }
        }
        return true
    }
    
    func compare(_ lhs: Int, _ rhs: Int) -> Int{
        if lhs == rhs {
            return 0
        }
        else if lhs > rhs{
            return 1
        }
        else{
            return -1
        }        
    }
}

---

588ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
      if isIncreasing(A: A) || isDecreasing(A: A) {
          return true
      }
        return false
    }
    
    func isIncreasing(A: [Int]) -> Bool {
        for i in 0..<A.count-1 {
            if A[i] > A[i+1] {
                return false
            }
        }
        return true
    }
    
    func isDecreasing(A: [Int]) -> Bool {
        for i in 0..<A.count-1 {
            if A[i] < A[i+1] {
                return false
            }
        }
        return true
    }
}

---

590ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        var isIncrease = true
        var isDecrease = true
        for i in 1..<A.count {
            if A[i-1] > A[i] {
                isIncrease = false
                break
            }
        }
        for i in 1..<A.count {
            if A[i-1] < A[i] {
                isDecrease = false
                break
            }
        }
        return isIncrease || isDecrease
        
    }
}

---

608ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        var up = true
        var down = true
        
        for i in 1..<A.count {
            if !up || !down { }
            up = up && A[i - 1] <= A[i]
            down = down && A[i - 1] >= A[i]
        }
        
        return up || down
    }
}

---

916ms

class Solution {
    func isMonotonic(_ A: [Int]) -> Bool {
        var flag = 0
        for i in 0..<A.count-1 {
            if A[i+1] - A[i] != 0 {
                let c = A[i+1] - A[i]
                if flag * c >= 0 {
                    flag = c
                } else {
                    return false
                }
            }
        }
        return true
    }
}