[Swift]LeetCode394. 字符串解码 | Decode String

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

Given an encoded string, return it's decoded string.

The encoding rule is: k[encoded_string], where the encoded_stringinside the square brackets is being repeated exactly k times. Note that kis guaranteed to be a positive integer.

You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.

Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won't be input like 3a or 2[4].

Examples:

s = "3[a]2[bc]", return "aaabcbc".
s = "3[a2[c]]", return "accaccacc".
s = "2[abc]3[cd]ef", return "abcabccdcdcdef".

---

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k，例如不会出现像 3a 或 2[4] 的输入。

示例:

s = "3[a]2[bc]", 返回 "aaabcbc".
s = "3[a2[c]]", 返回 "accaccacc".
s = "2[abc]3[cd]ef", 返回 "abcabccdcdcdef".

---

12ms

class Solution {
    func decodeString(_ s: String) -> String {
        var k:Int = 0
        return DFS(s, &k)        
    }
    
    func DFS(_ s:String,_ k:inout Int) -> String
    {
        var ans:String = String()
        var cnt:Int = 0
        while(k < s.count)
        {
            if s[k] >= "0" && s[k] <= "9"
            {
                cnt = cnt*10 + (s[k].ascii - 48)
                k += 1
            }
            else if s[k] == "["
            {
                k += 1
                var tem:String = DFS(s, &k)
                for i in 0..<cnt
                {
                    ans += tem
                    cnt = 0
                }
            }
            else if s[k] == "]"
            {
                k += 1
                return ans
            }
            else
            {
                ans.append(s[k])
                k += 1
            }
        }
        return ans        
    }
}

extension String {        
    //subscript函数可以检索数组中的值
    //直接按照索引方式截取指定索引的字符
    subscript (_ i: Int) -> Character {
        //读取字符
        get {return self[index(startIndex, offsetBy: i)]}
    }
}

//Character扩展方法  
extension Character  
{  
  //属性：ASCII整数值(定义小写为整数值)
   var ascii: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}

---

12ms

class Solution {
    func decodeString(_ s: String) -> String {
        var i = 0
        return String(de(Array(s),&i))
    }
    
    let zv = "0".unicodeScalars.first!.value, nv = "9".unicodeScalars.first!.value
    
    func de(_ c: [Character], _ i: inout Int) -> [Character]{
        var num = 0
        var ans = [Character]()
        while i < c.count && c[i] != "]" {
            let iv = c[i].unicodeScalars.first!.value
            if iv<=nv && iv>=zv {
                num = num*10 + Int(iv-zv)
            } else if c[i] == "[" {
                i+=1
                let re = de(c, &i)
                for j in  0..<num {
                    ans += re
                }
                num=0
                
            } else {
                ans.append(c[i])
            }
            i+=1
        }
        return ans
    }
}

---

12ms

import Foundation
class Solution {
    func decodeString(_ s: String) -> String {
    var numOfLeft:Int = 0;
    var tempStack:[Character] = [Character]();
    var resultString:String = String();
    
    func toStringWhenRight()->String{//遇到不是数字就停止
        var tempStr = ""
        var tempNum = ""
        var result = ""
        while tempStack[tempStack.count-1] != "[" {
            let temp = String.init(tempStack.popLast()!)
            tempStr = temp + tempStr;
        }
        tempStack.removeLast()
        while (tempStack.count>0&&tempStack[tempStack.count-1]>="0"&&tempStack[tempStack.count-1]<="9"){
            let temp = String.init(tempStack.popLast()!)
            tempNum = temp + tempNum;
            // print(tempStack.count)
        }
        let bound = (tempNum as NSString).integerValue
        for _ in 1...bound{
            result += tempStr
        }
        //读取其余的字母
        while (tempStack.count>0&&tempStack[tempStack.count-1]>="a"&&tempStack[tempStack.count-1]<="z"){
            let str = String.init(tempStack.popLast()!)
            result =  str + result;
        }
        numOfLeft -= 1;
        return result
    }
    for char in s{
        if(char == "["){
            numOfLeft+=1;
            tempStack.append(char);
        }else if(char=="]"){
            if(numOfLeft == 1){
                resultString += toStringWhenRight();
            }else if(numOfLeft > 1){
                tempStack.append(contentsOf: toStringWhenRight());
            }else{fatalError("something strange hanppens")}
        }else{
            tempStack.append(char);
        }
    }
    resultString += String.init(tempStack);
    return resultString;
  }
}

---

16ms

class Solution {
   
    func decodeString(_ str: String) -> String {
        // stores the ascii values of the characters
        var stack: [String] = []

        // used to store the formed number of times
        var number: Int? = 0

        // running index in str
        var index = 0
        while index < str.count {
            let ch = str[index]

            if ch.isNumeric() {
                number = (number ?? 0) * 10 + ch.numericValue()!
            } else if ch == "[" {
                if let number = number {
                    stack.append(String(number))
                }
                number = nil
                stack.append(String(ch))
            } else if ch == "]" {
                number = nil
                // decode the string and push on to stack
                var values = [String]()
                var times = 0
                while let top = stack.last {
                    if top == "[" {
                        // removes the square bracket
                        stack.removeLast()

                        // remove the number
                        times = Int(stack.removeLast())!

                        break
                    } else {
                        values.insert(stack.removeLast(), at: 0)
                    }
                }

                stack.append(decodeString(times, values))
            } else {
                number = nil
                // any other character
                stack.append(String(ch))
            }

            index += 1
        }

        let result = stack.reduce("") { $0 + $1 }
        return result
    }

    func decodeString(_ times: Int, _ values: [String]) -> String {
        let str = values.reduce("", +)
        var result = ""
        for _ in 0..<times {
            result += str
        }

        return result
    }
        
}
        
extension String {
    
    subscript (i: Int) -> Character {
        return self[index(startIndex, offsetBy: i)]
    }
    
    func subString(from: Int, to: Int) -> String {
        guard from <= to else {
            return ""
        }
        
        let startIndex = self.index(self.startIndex, offsetBy: from)
        let endIndex = self.index(self.startIndex, offsetBy: to)
        return String(self[startIndex...endIndex])
    }
    
    func subString(from: Int) -> String {
        let startIndex = self.index(self.startIndex, offsetBy: from)
        return String(self.suffix(from: startIndex))
    }
    
    func asciiValues() -> [Int] {
        return Array(self.utf16).map { Int($0) }
    }
    
    mutating func lTrim() {
        if let trailingSpacesRange = self.range(of: "^\s+", options: .regularExpression) {
            self.replaceSubrange(trailingSpacesRange, with: "")
        }
    }
    
    mutating func rTrim() {
        if let trailingSpacesRange = self.range(of: "\s+$", options: .regularExpression) {
            self.replaceSubrange(trailingSpacesRange, with: "")
        }
    }
    
}

struct AsciiValue {
    static let zero = Int(Character("0").unicodeScalars.first?.value ?? 0)
    static let nine = Int(Character("9").unicodeScalars.first?.value ?? 0)
    static let lowercaseCaseA = Int(Character("a").unicodeScalars.first?.value ?? 0)
    static let lowercaseCaseZ = Int(Character("z").unicodeScalars.first?.value ?? 0)
    static let capitalCaseA = Int(Character("A").unicodeScalars.first?.value ?? 0)
    static let capitalCaseZ = Int(Character("Z").unicodeScalars.first?.value ?? 0)
    static let openBracket = Int(Character("(").unicodeScalars.first?.value ?? 0)
    static let closeBracket = Int(Character(")").unicodeScalars.first?.value ?? 0)
    static let openSquareBracket = Int(Character("[").unicodeScalars.first?.value ?? 0)
    static let closeSquareBracket = Int(Character("]").unicodeScalars.first?.value ?? 0)
    static let openCurlyBracket = Int(Character("{").unicodeScalars.first?.value ?? 0)
    static let closeCurlyBracket = Int(Character("}").unicodeScalars.first?.value ?? 0)
    static let exponent = Int(Character("e").unicodeScalars.first?.value ?? 0)
    static let plus = Int(Character("+").unicodeScalars.first?.value ?? 0)
    static let minus = Int(Character("-").unicodeScalars.first?.value ?? 0)
    static let star = Int(Character("*").unicodeScalars.first?.value ?? 0)
    static let forwardSlash = Int(Character("/").unicodeScalars.first?.value ?? 0)
    static let decimal = Int(Character(".").unicodeScalars.first?.value ?? 0)
}

extension Character {

    func isAlpha() -> Bool {
        switch self {
        case "a"..."z":
            return true
        case "A"..."Z":
            return true
        default:
            return false
        }
    }

    func isHexaAlpha() -> Bool {
        switch self {
        case "a"..."f":
            return true
        case "A"..."F":
            return true
        default:
            return false
        }
    }

    func isNumeric() -> Bool {
        switch self {
        case "0"..."9":
            return true
        default:
            return false
        }
    }

    func isAlphaNumeric() -> Bool {
        return isAlpha() || isNumeric()
    }

    func numericValue() -> Int? {
        guard let unicodeScalar = unicodeScalars.first else {
            return nil
        }
        return Int(unicodeScalar.value) - AsciiValue.zero
    }

    var asciiValue: Int {
        return Int(self.unicodeScalars.first!.value)
    }
}

---

20ms

class Solution {
    func decodeString(_ s: String) -> String {
        var strArr = [String]()
        var numIndex = 0
        
        for i in 0..<s.count {
            var strItmeIndex = s.index(s.endIndex, offsetBy: -(i + 1))
            var strItme = String.init(s[strItmeIndex])
            if strItme != "["{

                if self.isPurnInt(string: strItme){
                    var numStr:String = strItme

                    while  self.isPurnInt(string: strArr.last!){
                        numStr =  numStr + strArr.last!
                        strArr.remove(at: strArr.count - 1)
                    }
                    if i != s.count - 1{
                        strArr.append(numStr)
                    }else{
                        var strItmeInt:Int = Int(numStr)!
                        var strNew:String = ""
                        for j in 0..<strItmeInt{
                            strNew = strNew + strArr.last!;
                        }
                        strArr.remove(at: strArr.count - 1)
                        strArr.append(strNew)
                    }
                    
                    
                }else{
                    if strArr.count > 0 && self.isPurnInt(string: strArr.last!) {
                        var strItmeInt:Int = Int(strArr.last!)!
                        strArr.remove(at: strArr.count - 1)
                        var strNew:String = ""
                        for j in 0..<strItmeInt{
                            strNew = strNew + strArr.last!;
                        }
                      strArr.remove(at: strArr.count - 1)
                      strArr.append(strNew)
                    }
                    strArr.append(strItme)
                }
            }else{
        
                var strNew:String = ""
                
                if strArr.count > 0 && self.isPurnInt(string: strArr.last!) {
                    var strItmeInt:Int = Int(strArr.last!)!
                    strArr.remove(at: strArr.count - 1)
                    for j in 0..<strItmeInt{
                        strNew = strNew + strArr.last!;
                    }
                    strArr.remove(at: strArr.count - 1)
                    strArr.append(strNew)
                }
                strNew = ""
            
                while strArr.last != "]"{
                    strNew = strNew + strArr.last!;
                    strArr.remove(at: strArr.count - 1)
                }
                strArr.remove(at: strArr.count - 1)
                strArr.append(strNew)
            }
        }
        var result:String = ""
        for k in 0..<strArr.count{
            result =  strArr[k] + result
        }
       
        return result
    }
    
    func isPurnInt(string: String) -> Bool {
        let scan: Scanner = Scanner(string: string)
        var val:Int = 0
        return scan.scanInt(&val) && scan.isAtEnd        
    }
}

---

20ms

class Solution {
    func decodeString(_ s: String) -> String {
        var nums = [Int]()
        var words = [String]()
        let chars = Array(s)
        var curNum = 0
        var result = ""
        
        for char in s {
            if char == "[" {
                nums.append(curNum)
                words.append("")
                curNum = 0
            } else if char == "]" {
                var wordToAdd = String(repeating: words.popLast()!, count: nums.popLast()!)
                if words.count > nums.count {
                    wordToAdd = words.popLast()! + wordToAdd
                }
                
                if let prevWord = words.popLast() {
                    words.append(prevWord + wordToAdd)
                } else {
                    result.append(contentsOf: wordToAdd)
                }
            } else if let num = Int(String(char)) {
                curNum = curNum * 10 + num
            } else {
                if nums.count == 0 {
                    result.append(char)
                } else {
                    let prevWord = words.popLast() ?? ""
                    words.append(prevWord + String(char))
                }
            }
        }        
        return result
    }
}