[Swift]LeetCode65. 有效数字 | Valid Number

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

Validate if a given string is numeric.

Some examples:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true

Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.

Update (2015-02-10):
The signature of the C++ function had been updated. If you still see your function signature accepts a const char * argument, please click the reload button to reset your code definition.

---

验证给定的字符串是否为数字。

例如:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true

说明: 我们有意将问题陈述地比较模糊。在实现代码之前，你应当事先思考所有可能的情况。

更新于 2015-02-10:
C++函数的形式已经更新了。如果你仍然看见你的函数接收 const char * 类型的参数，请点击重载按钮重置你的代码。

---

20ms

class Solution {
    func isNumber(_ s: String) -> Bool {
        let s = s.trimmingCharacters(in: .whitespaces)
        var pointSeen = false
        var eSeen = false
        var numSeen = false
        var numAfterE = true

        for i in 0..<s.count {
            if "0" <= s[i] && s[i] <= "9" {
                numSeen = true
                numAfterE = true
            } else if s[i] == "." {
                if eSeen || pointSeen {
                    return false
                }
                pointSeen = true
            } else if s[i] == "e" {
                if eSeen || !numSeen {
                    return false
                }
                numAfterE = false
                eSeen = true
            } else if s[i] == "-" || s[i] == "+" {
                if i != 0 && s[i - 1] != "e" {
                    return false
                }
            } else {
                return false
            }
        }

        return numSeen && numAfterE
    }
}

extension String {
    subscript (i: Int) -> Character {
        return self[index(startIndex, offsetBy: i)]
    }
    
    subscript(_ range: CountableRange<Int>) -> String {
        let idx1 = index(startIndex, offsetBy: max(0, range.lowerBound))
        let idx2 = index(startIndex, offsetBy: min(self.count, range.upperBound))
        return String(self[idx1..<idx2])
    }
}

---

24ms

class Solution {
    func isNumber(_ s: String) -> Bool {
        var num = Array(s.trimmingCharacters(in: .whitespacesAndNewlines))
        guard let first = num.first else {
            return false
        }
        
        if let e = num.index(of: "e") {
            if e > 0 && e < num.count - 1 {
                return isRealNumber(Array(num[0..<e])) && isInteger(Array(num[(e+1)...]))
            } else {
                return false
            }
        } else {
            return isRealNumber(num)
        }
    }
    
    func isDigitOnly(_ num: [Character]) -> Bool {
        return num.count > 0 && !num.contains { $0 < "0" || $0 > "9" }
    }
    
    func isInteger(_ num: [Character]) -> Bool {
        guard let first = num.first else {
            return false
        }
        
        if first == "+" || first == "-" {
            return isDigitOnly(Array(num[1...]))
        } else {
            return isDigitOnly(num)
        }
    }
    
    func isFloat(_ num: [Character]) -> Bool {
        guard num.count > 1 else {
            return false 
        }
        
        if let dot = num.index(of: ".") {
            if dot == 1 && (num[0] == "+" || num[0] == "-") {
                return isDigitOnly(Array(num[(dot + 1)...]))
            }
            
            return (dot == 0 || isInteger(Array(num[0 ..< dot]))) 
                && (dot == num.count - 1 || isDigitOnly(Array(num[(dot + 1)...])))
        } else {
            return false
        }
    }
    
    func isRealNumber(_ num: [Character]) -> Bool {
        return isInteger(num) || isFloat(num)
    }
}

---

28ms

class Solution {
    enum State : Int {
        case Started
        case Integer
        case Decimal
        case Exponential
        case Invalid
    }

    var hasSeenExpSign = false
    var hasSeenDigit = false
    
    func isDigit(_ char: Character) -> Bool {
        if let _ = Int(String(char)) {
            hasSeenDigit = true
            return true
        }
        return false
    }
    
    func getNextState (_ state: State, char: Character) -> State {
        var nextState:State = .Invalid
        switch state {
        case .Started, .Integer:
            if isDigit(char) {
                return .Integer
            } else if char == "." {
                return .Decimal
            } else if char == "e" && hasSeenDigit {
                return .Exponential
            }
        case .Decimal:
            if isDigit(char)  {
                return state
            } else if char == "e" && hasSeenDigit {
                return .Exponential
            }
        case .Exponential:
            if isDigit(char)  {
                return state
            } else if (char == "-" || char == "+") && !hasSeenExpSign  {
                hasSeenExpSign = true
                return state
            }
        default:
            return .Invalid
        }
        return .Invalid
    }

    func isNumber(_ s: String) -> Bool {
        var state:State = State.Started
        var array = Array(s.trimmingCharacters(in: CharacterSet.whitespaces))        
        var i = 0
        if array.first == "+" || array.first == "-" {
            i += 1
        }
        while i < array.count {
            state = getNextState(state, char: array[i])
            if state == State.Invalid {
                return false
            }
            i += 1
        }
        if state == State.Exponential {
            return isDigit(array.last!)
        }
        return hasSeenDigit
    }
}

---

32ms

class Solution {
    func isNumber(_ s: String) -> Bool {
        //initialize
        var s = s.map{ String($0) }
        var i = 0
        var n = s.count
        var isValid = false
        //analyze
        //" " in front
        while i < n && s[i] == " " {
            i += 1
        }
        //"+/-"
        while i < n && (s[i] == "+" || s[i] == "-") {
            i += 1
        }
        //valid number
        while i < n && Int(s[i]) != nil {
            isValid = true
            i += 1
        }
        //"."
        if i < n && s[i] == "." {
            i += 1
            //check for valid number
            while i < n && Int(s[i]) != nil {
                isValid = true
                i += 1
            }
        }
        //"e"
        if i < n && isValid && s[i] == "e" {
            isValid = false
            i += 1
            //"+/-"
            while i < n && (s[i] == "+" || s[i] == "-") {
                i += 1
            }
            //check for valid numbers
            while i < n && Int(s[i]) != nil {
                isValid = true
                i += 1
            }
        }
        //check for " " in end
        while i < n && s[i] == " " {
            i += 1
        }
        return isValid && i == n
    }
}

---

36ms

class Solution {
  
    func isNumber(_ s: String) -> Bool {
      let trimmed = s.trimmingCharacters(in: .whitespaces)
      guard trimmed.count > 0 else { return false }
      if let index = Array(trimmed).index(of: "e"), (index == 0 || index == trimmed.count-1) {
        return false
      }
      let c = trimmed.trimmingCharacters(in: .whitespaces).components(separatedBy: "e")
      if let index = c.index(of: "e"), (index == 0 || index == c.count-1) {
        return false
      }
      switch c.count {
        case 1 : return isValidFloating(c[0])
        case 2 : return isValidFloating(c[0]) && isValidInteger(c[1])
        default: return false
      }
    }
  
  func isValidInteger(_ s: String) -> Bool {
    guard s.count > 0 else { return true }
    let s = Array(s).map{String($0)}
    guard s.count > 1 else { return Int(s[0]) != nil && s[0] != "-" && s[0] != "+" }
    if Int(s[0]) == nil && s[0] != "-" && s[0] != "+" {
      return false
    }
    for i in 1..<s.count {
      if Int(s[i]) == nil { return false }
    }
    return true
  }
  
  func isValidFloating(_ s: String) -> Bool {
    guard s.count > 0 else { return false }
    let s = Array(s).map{String($0)}
    guard s.count > 1 else { return Int(s[0]) != nil && s[0] != "-" && s[0] != "+" && s[0] != "." }
    if Int(s[0]) == nil && s[0] != "-" && s[0] != "+" && s[0] != "." {
      return false
    }
    var foundPoint = s[0] == "."
    var foundDigit = Int(s[0]) != nil
    for i in 1..<s.count {
      if s[i] == "." {
        if foundPoint { return false }
        foundPoint = true
      } else if Int(s[i]) == nil { 
        return false 
      } else {
        foundDigit = true
      }
    }
    return foundDigit
  }
}

---

40ms

class Solution {
    func isNumber(_ s: String) -> Bool {
        var decimal = s
    
    decimal = decimal.trimmingCharacters(in: CharacterSet(charactersIn: " "))
    
    if decimal.contains("e"), decimal.components(separatedBy: CharacterSet(charactersIn: "e")).count == 2{
        if decimal.split(separator: "e").count == 2{
            let lhs = decimal.split(separator: "e")[0]
            let rhs = decimal.split(separator: "e")[1]
            if !rhs.contains("."){
                if let newLHS = Double(lhs){
                    if let newRHS = Int(rhs){
                        return true
                    }
                }
            }
        }
    }else{
        if let number = Double(decimal){
            return true
        }
    }
    return false
    }
}

---

44ms

class Solution {
    
    let digits = Set("0123456789")
    
    func isNumber(_ s: String) -> Bool {
        var sTrimmed = s.trimmingCharacters(in: .whitespacesAndNewlines)
        guard sTrimmed.first ?? " " != "e" && sTrimmed.last ?? " " != "e" else {
            return false
        }
        var eAppeared = false
        for char in sTrimmed {
            if char == "e" {
                guard !eAppeared else {
                    return false
                }
                eAppeared = true
            }
        }
        var parts = sTrimmed.split(separator: "e").map{ Array($0) }
        print(parts)
        guard parts.count > 0 && parts.count <= 2 else {
            return false
        }
        for i in 0..<parts.count {
            var pointAppeared = false
            var digitsAppeared = false
            for j in 0..<parts[i].count {
                let char = parts[i][j]
                if !digits.contains(char) {
                    if char == "-" || char == "+" {
                        guard j == 0 else {
                            return false
                        }
                    } else if char == "." {
                        guard i == 0 && !pointAppeared else {
                            return false
                        }
                        pointAppeared = true
                    } else {
                        return false
                    }
                } else {
                    digitsAppeared = true
                }
            }
            guard digitsAppeared else {
                return false
            }
        }
        return true
    }
}

---

56ms

class Solution {
    func isNumber(_ s: String) -> Bool {
        let str = s.trimmingCharacters(in: CharacterSet(charactersIn: " "))
        
        guard str.count > 0 && str != "." else {
            return false
        }
        
        if let _ = Double(str) {
            return true
        }
        
        let vals = str.components(separatedBy: "e")
        if vals.count > 2 {
            return false
        }
        
        let invalids = [".", "-.", "+.", "-", "+"]
        if invalids.contains(vals.first!) {
            return false
        }
        
        func isMyDigit(_ ss: String, _ sign: Bool, _ single: Bool) -> Bool {
            
            if !sign && (ss.contains("-") || ss.contains("+")) {
                return false
            }
            
            if !single && (ss == "+" || ss == "-") {
                return false
            }
            
            for (i, v) in ss.enumerated() {
                if (v >= "0" && v <= "9") || (i == 0 && (v == "-" || v == "+")) {
                    continue
                }
                return false
            }
            return true
        }
        
        if vals.count == 2 {
            if vals.first!.count == 0 || vals.last!.count == 0 || !isMyDigit(vals.last!, true, false) {
                return false
            }
        }
        
        let dots = vals.first!.components(separatedBy: ".")
        if dots.count > 2 {
            return false
        }
        
        if !isMyDigit(dots.first!, true, true) {
            return false
        }
        
        if dots.count == 2 && !isMyDigit(dots.last!, false, false) {
            return false
        }
        
        return true
    }
}