[Swift]LeetCode420. 强密码检验器 | Strong Password Checker

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

A password is considered strong if below conditions are all met:

1. It has at least 6 characters and at most 20 characters.
2. It must contain at least one lowercase letter, at least one uppercase letter, and at least one digit.
3. It must NOT contain three repeating characters in a row ("...aaa..." is weak, but "...aa...a..." is strong, assuming other conditions are met).

Write a function strongPasswordChecker(s), that takes a string s as input, and return the MINIMUM change required to make s a strong password. If s is already strong, return 0.

Insertion, deletion or replace of any one character are all considered as one change.

---

一个强密码应满足以下所有条件：

1. 由至少6个，至多20个字符组成。
2. 至少包含一个小写字母，一个大写字母，和一个数字。
3. 同一字符不能连续出现三次 (比如 "...aaa..." 是不允许的, 但是 "...aa...a..." 是可以的)。

编写函数 strongPasswordChecker(s)，s 代表输入字符串，如果 s 已经符合强密码条件，则返回0；否则返回要将 s 修改为满足强密码条件的字符串所需要进行修改的最小步数。

插入、删除、替换任一字符都算作一次修改。

---

Runtime: 4 ms

Memory Usage: 19.5 MB

class Solution {
    func strongPasswordChecker(_ s: String) -> Int {
        var digitNum = 0
        var upperNum = 0
        var lowerNum = 0

        var repeatArr = Array<Int>()
        var lastChar = 0
        var repeatnum = 1
        for c in s.unicodeScalars{
            let num = c.value
            if num >= 48 && num < 58{
                digitNum += 1
            }
            if num >= 65 && num < 91{
                upperNum += 1
            }
            if num >= 97 && num < 123{
                lowerNum += 1
            }
            if num == lastChar{
                repeatnum += 1
            }else{
                if repeatnum >= 3{
                    repeatArr.append(repeatnum)
                }
                repeatnum = 1
            }
            lastChar = Int(num)
        }
        if repeatnum >= 3{
            repeatArr.append(repeatnum)
        }
        //补全三种字符需要的步骤 （插入，替换）
        var step1 = 0
        step1 += digitNum == 0 ? 1:0
        step1 += upperNum == 0 ? 1:0
        step1 += lowerNum == 0 ? 1:0

        //插入
        if s.count < 6{
            //不满6位 与 种类不齐都可以通过 插入同时结局 所以 取大值
            return max(step1,6-s.count)
        }
        //大于6位只进行替换 和 删除，两者互斥 所以求和
        else{
            //至少需要的删除操作
            let deleteStep = (s.count - 20) > 0 ? s.count - 20 : 0
            var deleteStepTemp = deleteStep
            for i in 0...2{
                if deleteStepTemp < (i+1){
                    break
                }
                for index in 0..<repeatArr.count{
                    if deleteStepTemp < (i+1){
                        break
                    }
                    let num = repeatArr[index]
                    if num % 3 == i && num >= 3{
                        repeatArr[index] = num - i - 1
                        deleteStepTemp -= (i + 1)
                    }
                }
            }
            //需要通过替换消除3连的部署（每n个数相连 需要替换n/3个）
            var changeStep = 0
            for i in 0..<repeatArr.count{
                let num = repeatArr[i]
                changeStep += num/3
            }
            //消除3连的替换changeStep步数 和 step1步数 可以同事满足 所以取大值
            var res = max(changeStep,step1)
            //总步数 = 必须删除的步数 + 需要替换的步数
            res = deleteStep + res
            return res
        }
    }
}

---

Runtime: 8 ms

Memory Usage: 19.5 MB

class Solution {
    func strongPasswordChecker(_ s: String) -> Int {
        var requiredChar:Int = GetRequiredChar(s)
        if s.count < 6
        {
            return max(requiredChar, 6 - s.count)
        }
        var replace:Int = 0
        var oned:Int = 0
        var twod:Int = 0

        var i:Int = 0
        var arrS:[Character] = Array(s)
        while(i < s.count)
        {
            var len:Int = 1
            while(i + len < s.count && arrS[i + len] == arrS[i + len - 1])
            {
                len += 1
            }
            if len >= 3
            {
                replace += len / 3
                if len % 3 == 0 {oned += 1}
                if len % 3 == 1 {twod += 2}
            }
            i += len
        }
        if s.count <= 20
        {
            return max(requiredChar, replace)
        }
        var deleteCount:Int = s.count - 20
        replace -= min(deleteCount, oned)
        replace -= min(max(deleteCount - oned, 0), twod) / 2
        replace -= max(deleteCount - oned - twod, 0) / 3
        return deleteCount + max(requiredChar, replace)
    }

    func GetRequiredChar(_ s:String) -> Int
    {
        var lowercase:Int = 1
        var uppercase:Int = 1
        var digit:Int = 1
        for c in s
        {
            if c >= "a" && c <= "z" {lowercase = 0}
            else if c >= "A" && c <= "Z" {uppercase = 0}
            else if c >= "0" && c <= "9" {digit = 0}
        }
        return lowercase + uppercase + digit
    }
}