[Swift]LeetCode385. 迷你语法分析器 | Mini Parser

原文地址：https://www.cnblogs.com/strengthen/p/10283451.html 

Given a nested list of integers represented as a string, implement a parser to deserialize it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Note: You may assume that the string is well-formed:

• String is non-empty.
• String does not contain white spaces.
• String contains only digits 0-9, [, - ,, ]. 

Example 1:

Given s = "324",

You should return a NestedInteger object which contains a single integer 324. 

Example 2:

Given s = "[123,[456,[789]]]",

Return a NestedInteger object containing a nested list with 2 elements:

1. An integer containing value 123.
2. A nested list containing two elements:
    i.  An integer containing value 456.
    ii. A nested list with one element:
         a. An integer containing value 789.

---

给定一个用字符串表示的整数的嵌套列表，实现一个解析它的语法分析器。

列表中的每个元素只可能是整数或整数嵌套列表

提示：你可以假定这些字符串都是格式良好的：

• 字符串非空
• 字符串不包含空格
• 字符串只包含数字0-9, [, - ,, ] 

示例 1：

给定 s = "324",

你应该返回一个 NestedInteger 对象，其中只包含整数值 324。 

示例 2：

给定 s = "[123,[456,[789]]]",

返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表：

1. 一个 integer 包含值 123
2. 一个包含两个元素的嵌套列表：
    i.  一个 integer 包含值 456
    ii. 一个包含一个元素的嵌套列表
         a. 一个 integer 包含值 789

---

88ms

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     public func isInteger() -> Bool
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     public func getInteger() -> Int
 *
 *     // Set this NestedInteger to hold a single integer.
 *     public func setInteger(value: Int)
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     public func add(elem: NestedInteger)
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     public func getList() -> [NestedInteger]
 * }
 */
class Solution {
    func deserialize(_ s: String) -> NestedInteger {
    if s[s.startIndex] != "[" {
        let n = Int(s)!
        let nest = NestedInteger()
        nest.setInteger(n)
        return nest
    }
    var stack = [NestedInteger]()
    var num = ""
    for c in s.characters {
        if c == "[" {
            stack.append(NestedInteger())
        } else if c == "]"{
            let last = stack.removeLast()
            if !num.isEmpty {
                let n = Int(num)!
                let nest = NestedInteger()
                nest.setInteger(n)
                last.add(nest)
                num = ""
            }
            if stack.isEmpty {
                return last
            }
            if last.isInteger() {
                stack[stack.count-1].setInteger(last.getInteger())
            } else {
                stack[stack.count-1].add(last)
            }
        } else if c == "," {
            if let n = Int(num) {
                let nest = NestedInteger()
                nest.setInteger(n)
                stack[stack.count-1].add(nest)
                num = ""
            }
        } else {
            num.append(c)
        }
    }
    return NestedInteger()
  }    
}

---

100ms

extension String {
    func digitInt(offset: String.Index) -> Int {
        return Int(self[offset].unicodeScalars.first!.value - "0".unicodeScalars.first!.value)
    }
}

fileprivate let one2nine = CharacterSet(charactersIn: "123456789")
fileprivate let zero2nine = CharacterSet(charactersIn: "0123456789")

class Solution {
    
    //listOrInt:    list | integer
    //list:         [ listOrInt (, listOrInt)* ]
    //integer:      -? (1-9)?(0-9)*
    
    private func consumeListOrInt(offset: String.Index, s: String) -> (parsed: NestedInteger, offset: String.Index)? {
        if let consumedList = consumeList(offset: offset, s: s) {
            return consumedList
        }
        if let consumedInt = consumeInt(offset: offset, s: s) {
            return consumedInt
        }
        return nil
    }
    
    private func consumeList(offset: String.Index, s: String) -> (parsed: NestedInteger, offset: String.Index)? {
        guard s[offset] == "[" else {
            return nil
        }
        
        let result = NestedInteger()
        var newOffset = s.index(after: offset)
        if let firstElem = consumeListOrInt(offset: newOffset, s: s) {
            result.add(firstElem.parsed)
            newOffset = firstElem.offset
            while true {
                guard s[newOffset] == "," else {
                    break
                }
                newOffset = s.index(after: newOffset)
                guard let elem = consumeListOrInt(offset: newOffset, s: s) else {
                    break
                }
                newOffset = elem.offset
                result.add(elem.parsed)
            }
        }
        
        guard s[newOffset] == "]" else {
            return nil;
        }
        return (result, s.index(after: newOffset))
    }
    
    private func consumeInt(offset: String.Index, s: String) -> (parsed: NestedInteger, offset: String.Index)? {
        let result = NestedInteger()
        var integer: Int = 0
        var positive = true
        var newOffset = offset
        if s[offset] == "-" {
            positive = false
            newOffset = s.index(after: offset)
        }
        guard newOffset < s.endIndex else {
            return nil
        }
        if s[newOffset] == "0" {
            result.setInteger(0)
            return (result, s.index(after: newOffset))
        }
        guard one2nine.contains(s[newOffset].unicodeScalars.first!) else {
            return nil
        }
        integer = s.digitInt(offset: newOffset) * (positive ? 1 : -1)
        newOffset = s.index(after: newOffset)
        while true {
            guard newOffset < s.endIndex else {
                break
            }
            guard zero2nine.contains(s[newOffset].unicodeScalars.first!) else {
                break
            }
            integer = integer * 10 + s.digitInt(offset: newOffset) * (positive ? 1 : -1)
            newOffset = s.index(after: newOffset)
        }
        result.setInteger(integer)
        return (result, newOffset)
    }
    
    func deserialize(_ s: String) -> NestedInteger {
        guard let (parsed, offset) = consumeListOrInt(offset: s.startIndex, s: s) else {
            fatalError()
        }
        if offset != s.endIndex {
            fatalError()
        }
        return parsed
    }
}

---

10120ms

class Solution {
    func deserialize(_ s: String) -> NestedInteger {
        if s.count == 0 {return NestedInteger()}
        if s[0] != "[" {return NestedInteger(Int(atoi(s)))}
        if s.count <= 2 {return NestedInteger()}
        var res:NestedInteger = NestedInteger()
        var start:Int = 1
        var cnt:Int = 0
        for i in 1..<s.count
        {
            if cnt == 0 && (s[i] == "," || i == s.count - 1)
            {
                res.add(deserialize(s.subString(start, i - start)))
                start = i + 1
            }
            else if s[i] == "[" {cnt += 1}
            else if s[i] == "]" {cnt -= 1}
        }
        return res
    }
}

extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
}