[Swift]LeetCode1021. 删除最外层的括号 | Remove Outermost Parentheses

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

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

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

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

A valid parentheses string is either empty (""), "(" + A + ")", or A + B, where A and B are valid parentheses strings, and +represents string concatenation.  For example, "", "()", "(())()", and "(()(()))" are all valid parentheses strings.

A valid parentheses string S is primitive if it is nonempty, and there does not exist a way to split it into S = A+B, with A and Bnonempty valid parentheses strings.

Given a valid parentheses string S, consider its primitive decomposition: S = P_1 + P_2 + ... + P_k, where P_i are primitive valid parentheses strings.

Return S after removing the outermost parentheses of every primitive string in the primitive decomposition of S.

Example 1:

Input: "(()())(())"
Output: "()()()"
Explanation: 
The input string is "(()())(())", with primitive decomposition "(()())" + "(())".
After removing outer parentheses of each part, this is "()()" + "()" = "()()()".

Example 2:

Input: "(()())(())(()(()))"
Output: "()()()()(())"
Explanation: 
The input string is "(()())(())(()(()))", with primitive decomposition "(()())" + "(())" + "(()(()))".
After removing outer parentheses of each part, this is "()()" + "()" + "()(())" = "()()()()(())".

Example 3:

Input: "()()"
Output: ""
Explanation: 
The input string is "()()", with primitive decomposition "()" + "()".
After removing outer parentheses of each part, this is "" + "" = "". 

Note:

1. S.length <= 10000
2. S[i] is "(" or ")"
3. S is a valid parentheses string

---

有效括号字符串为空 ("")、"(" + A + ")" 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 "(()(()))" 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + ... + P_k，其中 P_i 是有效括号字符串原语。

对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

示例 1：

输入："(()())(())"
输出："()()()"
解释：
输入字符串为 "(()())(())"，原语化分解得到 "(()())" + "(())"，
删除每个部分中的最外层括号后得到 "()()" + "()" = "()()()"。

示例 2：

输入："(()())(())(()(()))"
输出："()()()()(())"
解释：
输入字符串为 "(()())(())(()(()))"，原语化分解得到 "(()())" + "(())" + "(()(()))"，
删除每隔部分中的最外层括号后得到 "()()" + "()" + "()(())" = "()()()()(())"。

示例 3：

输入："()()"
输出：""
解释：
输入字符串为 "()()"，原语化分解得到 "()" + "()"，
删除每个部分中的最外层括号后得到 "" + "" = ""。

提示：

1. S.length <= 10000
2. S[i] 为 "(" 或 ")"
3. S 是一个有效括号字符串

---

24ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        guard !S.isEmpty else { return "" }
        var result = [Character]()
        var inSub = true, backCount = 0
        let s = Array(S)
    
        for i in 1..<s.count {
            if s[i] == "(" {
                if inSub {
                    backCount += 1
                    result.append("(")
                } else {
                    inSub = true
                    backCount = 0
                }           
                continue
        }
            
            if s[i] == ")" {
                backCount -= 1                
                if backCount == -1 {
                    inSub = false
                } else {
                    result.append(")")
                }
                continue
            }
        }
        return String(result)
     }
}

---

28ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        var chars = Array(S)
        var count = 0
        var previousCount = 0
        var resultArray = [Character]()
        
        for i in 0..<chars.count {
            previousCount = count
            if chars[i] == "(" {
                count += 1
            } else if chars[i] == ")" {
                count -= 1
            }
            if count != 0 && previousCount != 0 {
                resultArray.append(chars[i])
            }
        }
        let result = String(resultArray)
        return result
    }
}

---

32ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String
    {
        var oc = 0
        var temp = ""
        var ret = ""
        for c in S
        {
            if c == "(" { oc += 1 }
            else { oc -= 1 }
            
            temp += String(c)
            if oc == 0 {
                ret += self.helper(temp)
                temp = ""
            }
        }
        return ret
    }
    
    private func helper(_ S: String) -> String
    {
        guard S.count > 0 else { return S }
        
        var ret = S
        if let idx = ret.index(of: "(") { ret.remove(at: idx) }
        if let idx = ret.lastIndex(of: ")") { ret.remove(at: idx) }
        return ret
    }
}

---

36ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        var s = S.characters.map{String($0)}
        var temp = [String]()
        var hold = ""
        var openCount = 0
        var closeCount = 0
        var i = 0
        while i < s.count{
            if s[i] == "("{
                hold += s[i]
                openCount += 1
            }else if hold.count != 0 && s[i] == ")"{
                hold += ")"
                closeCount += 1
            }
            if hold.count != 0 && closeCount == openCount{
                temp.append(hold)
                openCount = 0
                closeCount = 0
                hold = ""
            }
            i += 1
        }
        
        var answer = ""
        for pair in temp{
                let startIndex  = pair.index(pair.startIndex, offsetBy: 1)
                let endIndex = pair.index(pair.endIndex, offsetBy: -1)
                answer += String(pair[startIndex..<endIndex])
        }
        
        return answer
    }
}

---

Runtime: 40 ms

Memory Usage: 19.5 MB

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        var ret:String = String()
        var bal:Int = 0
        var cur:String = String()
        for c in S
        {
            if c == "("
            {
                bal += 1
            }
            else
            {
                bal -= 1
            }
            cur.append(c)
            if bal == 0
            {
                ret += cur.subString(1, cur.count - 2)
                cur = String()
            }
        }
        return ret    
    }
}

extension String {
    // 截取字符串：指定索引和字符数
    // - 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]) 
    }  
}

---

48ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        if S.count == 0 {
            return ""
        }
        var s = Array(S)
        var sk = [Character]()
        var otherSk = [Character]()
        var anOtherSK = [Character]()
        while s.isEmpty == false {
            if sk.isEmpty {
                if anOtherSK.isEmpty {
                    anOtherSK.append(s.removeLast())
                } else {
                    if s.last == "(" {
                        s.popLast()
                        anOtherSK.popLast()
                        continue
                    }
                }
            }
            if sk.isEmpty && s.last == "(" {
                continue
            }
            
            if let a = s.popLast() {
                sk.append(a)
                otherSk.append(a)
            }
            if sk.last == "(" {
                sk.popLast()
                sk.popLast()
            }
        }
        return String(otherSk.reversed())
    }
}

---

52ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
        let S = Array(S)
        var stack: [Character] = []
        var res: [String] = []
        var prev = 0
        for (i, ch) in S.enumerated() {
            if ch == "(" || ch == "[" || ch == "{" {
               stack.append(ch) 
            }
            
            if ch == ")" || ch == "}"  || ch == "]"  {
                stack.remove(at: stack.count - 1)
            }
            
            if stack.count == 0 {
               res.append(String(S[prev...i]))
                prev = i + 1
            }
        }
    
        return res.reduce("", {res, str in return res + String(String(str.dropFirst()).dropLast())})
    }
}

---

72ms

class Solution {
    func removeOuterParentheses(_ S: String) -> String {
    let parentheses = Array(S)
    var groups = [[String]]()
    let stack = Stack<String>()
    var startIndex = 0
    var result = ""
    for (index, parenthese) in parentheses.enumerated() {
      if stack.isEmpty() && index == 0 {
        stack.push(String(parenthese))
      } else {
        if let element = stack.top?.element, element != String(parenthese) {
          stack.pop()
        } else {
          stack.push(String(parenthese))
        }
      }
      if stack.isEmpty() {
        groups.append(Array(parentheses[startIndex...index]).map{ String($0) })
        startIndex = index + 1
      }
    }
    
    for group in groups {
      let simplified = Array(group.dropFirst().dropLast())
      result += simplified.joined()
    }
    
    return result
  }
}

final class Stack<Element> {
  
  var top: Node<Element>?
  
  @discardableResult
  func pop() -> Element? {
    guard let topNode = top else { return nil }
    top = topNode.next
    return topNode.element
  }
  
  func push(_ element: Element) {
    if let topNode = top {
      let newTop = Node(element)
      newTop.next = topNode
      top = newTop
    } else {
      top = Node(element)
    }
  }
  
  func isEmpty() -> Bool {
    return top == nil
  }
}

extension Stack {
  
  final class Node<Element> {
    
    var element: Element?
    var next: Node<Element>?
    
    init(_ element: Element) {
      self.element = element
    }
  }
}