[Swift]LeetCode443. 压缩字符串 | String Compression

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

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

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

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

Given an array of characters, compress it in-place.

The length after compression must always be smaller than or equal to the original array.

Every element of the array should be a character (not int) of length 1.

After you are done modifying the input array in-place, return the new length of the array.

Follow up:
Could you solve it using only O(1) extra space?

Example 1:

Input:
["a","a","b","b","c","c","c"]

Output:
Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]

Explanation:
"aa" is replaced by "a2". "bb" is replaced by "b2". "ccc" is replaced by "c3".

Example 2:

Input:
["a"]

Output:
Return 1, and the first 1 characters of the input array should be: ["a"]

Explanation:
Nothing is replaced.

Example 3:

Input:
["a","b","b","b","b","b","b","b","b","b","b","b","b"]

Output:
Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].

Explanation:
Since the character "a" does not repeat, it is not compressed. "bbbbbbbbbbbb" is replaced by "b12".
Notice each digit has it's own entry in the array.

Note:

1. All characters have an ASCII value in [35, 126].
2. 1 <= len(chars) <= 1000.

---

给定一组字符，使用原地算法将其压缩。

压缩后的长度必须始终小于或等于原数组长度。

数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。

在完成原地修改输入数组后，返回数组的新长度。

进阶：
你能否仅使用O(1) 空间解决问题？

示例 1：

输入：
["a","a","b","b","c","c","c"]

输出：
返回6，输入数组的前6个字符应该是：["a","2","b","2","c","3"]

说明：
"aa"被"a2"替代。"bb"被"b2"替代。"ccc"被"c3"替代。

示例 2：

输入：
["a"]

输出：
返回1，输入数组的前1个字符应该是：["a"]

说明：
没有任何字符串被替代。

示例 3：

输入：
["a","b","b","b","b","b","b","b","b","b","b","b","b"]

输出：
返回4，输入数组的前4个字符应该是：["a","b","1","2"]。

说明：
由于字符"a"不重复，所以不会被压缩。"bbbbbbbbbbbb"被“b12”替代。
注意每个数字在数组中都有它自己的位置。

注意：

1. 所有字符都有一个ASCII值在[35, 126]区间内。
2. 1 <= len(chars) <= 1000。

---

 60ms

class Solution {
    let intToChar : Array<Character> = ["0","1","2","3","4","5","6","7","8","9"]
    func compress(_ chars: inout [Character]) -> Int {
        if chars.count < 2 {
            return chars.count
        }
        var result = ""
        result.append(chars[0])
        var count = 1
        for i in 1..<chars.count {
            if chars[i] == chars[ i - 1]{
                count += 1
            } else {
                if count != 1 {
                    result += getCountStr(count)
                }
                count = 1
                result.append(chars[i])
            }
        }
        if count > 1 {
            result += getCountStr(count)
        }
         chars = Array<Character>(result)
        return chars.count
    }
    private func getCountStr(_ num : Int) -> String {
        var count = num
        var str = ""
        if count < 10 {
            str.append(intToChar[count])
        } else {
            while count > 0 {
                if str.isEmpty {
                    str.append(intToChar[count % 10])
                } else {
                    str.insert(intToChar[count % 10], at: str.startIndex)
                }
                count /= 10
            }
        }
        return str
    }
}

---

92ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        var len = 0, cnt = 1
        for i in 0..<chars.count {
            if i+1 == chars.count || chars[i] != chars[i+1] {
                chars[len] = chars[i]
                len += 1

                if cnt > 1 {
                    for ch in String(cnt) {
                        chars[len] = ch
                        len += 1
                    }
                    cnt = 1
                }
            } else {
                cnt += 1
            }
        }

        return len
    }
}

---

96ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        if chars.count <= 1 {
            return chars.count
        }
        var nextIndex = 1
        var count = 1
        var curChar = chars[0]
        var i = 1
        var l = chars.count
        while i < l {
            let tmpChar = chars[i]
            if curChar == tmpChar {
                count += 1
                if i != chars.count - 1 {
                    i += 1
                    continue
                }
            }
            if count > 1 {
                let str = "\(count)"
                var tmplist = [Character]()
                for char in str {
                    tmplist.append(char)
                }
                if i == l - 1, tmpChar == curChar {
                   chars[nextIndex ... i] = tmplist[0 ... tmplist.count-1]
                }else{
                   chars[nextIndex ... i - 1] = tmplist[0 ... tmplist.count-1]
                }
                
                i = nextIndex + tmplist.count + 1
                l = chars.count
                nextIndex = i
            }else{
                i += 1
            }
            nextIndex = i
            curChar = tmpChar
            count = 1
        }
        return chars.count
    }
}

---

104ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        
        var front = 0
        var back = 0

        while back < chars.count {
            chars[front] = chars[back]

            var count = 0
            while back < chars.count, chars[back] == chars[front] {
                count = count + 1
                back = back + 1
            }

            if count > 1 {
                let replacing = "\(count)".map { $0 }
                chars.replaceSubrange(front+1..<front+1+replacing.count, with: replacing)
                front = front + 1 + replacing.count
            } else {
                front = front + 1
            }
        }

        return front        
    }
}

---

108ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        if chars.isEmpty { return 0 }
        var left = 0, count = 1, lastVal = chars[0]

        func helper(_ v: Character, _ c: Int) {
            chars[left] = v
            left += 1
            if c < 2 {
                return
            }
            let arr = Array("\(c)")
            for t in arr {
                chars[left] = t
                left += 1
            }
        }

        for i in 1 ..< chars.count {
            let char = chars[i]
            if char == lastVal {
                count += 1
            } else {
                helper(lastVal, count)
                count = 1
                lastVal = char
            }
        }

        if count > 0 {
            helper(lastVal, count)
        }

        return left
    }
}

---

120ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        guard chars.count > 1 else {
            return chars.count
        }
        let len = chars.count
        var i = 0
        var j = 1
        var count = 1
        
        while j < len {
            let one = chars[i]
            count = 1
            while j < len &&  one == chars[j] {
                j += 1
                count += 1
            }
            
            if count != 1 {
                let countArr = Array(String(count))
                for char in countArr {
                    print(char)
                    i += 1
                    chars[i] = char
                }
            }
            
            if j < len {
                i += 1
                chars[i] = chars[j]
                j += 1
            }
            
        }
        
        return i + 1
    }
}

---

156ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        if chars.isEmpty { return 0 }
        var left = 0, count = 1, lastVal = chars[0]

        func helper(_ v: Character, _ c: Int) {
            chars[left] = v
            left += 1
            if c < 2 {
                return
            }
            let arr = Array("\(c)")
            for t in arr {
                chars[left] = t
                left += 1
            }
        }

        for i in 1 ..< chars.count {
            let char = chars[i]
            if char == lastVal {
                count += 1
            } else {
                helper(lastVal, count)
                count = 1
                lastVal = char
            }
        }

        if count > 0 {
            helper(lastVal, count)
        }

        return left
    }
}

---

168ms

class Solution {
    func compress(_ chars: inout [Character]) -> Int {
        var index = 0, currentCount = 0
        
        for i in 0..<chars.count {
            currentCount += 1
            
            if i + 1 == chars.count || chars[i] != chars[i + 1] {
                chars[index] = chars[i]
                
                if currentCount != 1 {
                    chars.replaceSubrange(index + 1...currentCount.length + index, with: Array(String(currentCount)))
                }
                
                index += currentCount == 1 ? 1 : 1 + currentCount.length
                currentCount = 0
            }
        }
        
        return index
    }
}

extension Int {
    var length: Int {
        return String(self).count
    }
}