[Swift]LeetCode788. 旋转数字 | Rotated Digits

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

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

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

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

X is a good number if after rotating each digit individually by 180 degrees, we get a valid number that is different from X.  Each digit must be rotated - we cannot choose to leave it alone.

A number is valid if each digit remains a digit after rotation. 0, 1, and 8 rotate to themselves; 2 and 5 rotate to each other; 6 and 9 rotate to each other, and the rest of the numbers do not rotate to any other number and become invalid.

Now given a positive number N, how many numbers X from 1 to N are good?

Example:
Input: 10
Output: 4
Explanation: 
There are four good numbers in the range [1, 10] : 2, 5, 6, 9.
Note that 1 and 10 are not good numbers, since they remain unchanged after rotating.

Note:

• N  will be in range [1, 10000].

---

我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后，我们仍可以得到一个有效的，且和 X 不同的数。要求每位数字都要被旋转。

如果一个数的每位数字被旋转以后仍然还是一个数字， 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己；2 和 5 可以互相旋转成对方；6 和 9 同理，除了这些以外其他的数字旋转以后都不再是有效的数字。

现在我们有一个正整数 N, 计算从 1 到 N 中有多少个数 X 是好数？

示例:
输入: 10
输出: 4
解释: 
在[1, 10]中有四个好数： 2, 5, 6, 9。
注意 1 和 10 不是好数, 因为他们在旋转之后不变。

注意:

• N 的取值范围是 [1, 10000]。

---

Runtime: 8 ms

Memory Usage: 18.8 MB

class Solution {
    func rotatedDigits(_ N: Int) -> Int {
        var res:Int = 0
        var dp:[Int] = [Int](repeating:0,count:N + 1)
        for i in 0...N
        {
            if i < 10
            {
                if i == 0 || i == 1 || i == 8
                {
                    dp[i] = 1                
                }
                else if i == 2 || i == 5 || i == 6 || i == 9
                {
                    dp[i] = 2
                    res += 1
                }
            }
            else
            {
                var a:Int = dp[i / 10]
                var b:Int = dp[i % 10]
                if a == 1 && b == 1
                {
                    dp[i] = 1
                }
                else if a >= 1 && b >= 1
                {
                    dp[i] = 2
                    res += 1
                }                
            }
        }
        return res
    }
}

---

12ms

class Solution {

    func rotatedDigits(_ N: Int) -> Int {
        var count = 0
        for n in 1...N {
            if good(n, false) { count += 1 }
        }
        return count
    }
    
    func good(_ n : Int, _ flag: Bool) -> Bool {
        if n == 0 { return flag }
        let d = n%10
        if d == 3 || d == 4 || d == 7 { return false }
        if d == 0 || d == 1 || d == 8 { return good(n/10, flag) }
        return good(n/10, true)   
    }
}

---

16ms

class Solution {
    func rotatedDigits(_ N: Int) -> Int {
        var count = 0
        
        for numRaw in 0...N {
            var containDifferent = false
            var containInvalid = false
            
            var num = numRaw
            while num > 0 {
                let dig = num % 10
                num = num / 10

                switch (dig) {
                    case 0,1,8:
                        break
                    case 2,5,6,9:
                        containDifferent = true
                    case 3,4,7:
                        containInvalid = true
                    default:
                        break;
                }
                
                if containInvalid {
                    break
                }
            }

            if containDifferent && !containInvalid {
                count += 1
            }
        }

        return count
    }
}

---

24ms

class Solution {
  func rotatedDigits(_ N: Int) -> Int {
    var dp = Array(repeating: 0, count: N + 1)
    var goodNumCount = 0
    
    for num in 0...N {
      if num <= 9 {
        if num == 2 || num == 5 || num == 6 || num == 9 {
          dp[num] = 2
          goodNumCount += 1
        } else if num == 0 || num == 1 || num == 8 {
          dp[num] = 1
        }
      } else {
        let prevDigits = dp[num / 10]
        let lastDigit = dp[num % 10]
        
        if prevDigits == 1 && lastDigit == 1 {
          dp[num] = 1
        } else if prevDigits >= 1 && lastDigit >= 1 {
          dp[num] = 2
          goodNumCount += 1
        }
      }
    }
    
    return goodNumCount
  }
}

---

28ms

class Solution {
    var rotations = [0, 1, 5, -1, -1, 2, 9, -1, 8, 6]
    
    func rotatedDigits(_ N: Int) -> Int {
        guard N != 0 else { return 0 }
        
        var count = 0
        for i in 1...N {
            count += isGood(i) ? 1 : 0
        }
        
        return count
    }
    
    func isGood(_ n: Int) -> Bool {
        var newNr = 0
        var multiply = 1
        var workingN = n
        var d = 0
        
        while workingN != 0 {
            d = workingN % 10
            if rotations[d] == -1 { return false }
            
            newNr = rotations[d] * multiply + newNr
            workingN /= 10
            multiply *= 10
        }
        
        return n != newNr
    }
}

---

40ms

class Solution {
    private let dict: [Int: Int] = [0: 0, 1: 1, 8: 8, 2: 5, 5: 2, 9: 6, 6: 9]
    func rotatedDigits(_ N: Int) -> Int {
        guard N > 1 else { return 0 }
        var curNum = N
        var changed: Bool = false
        while curNum > 0 {
            let digit = curNum % 10
            let changedDigit = dict[digit] ?? -1
            if changedDigit == -1 {
                return rotatedDigits(N - 1)
            } else if digit != changedDigit {
                changed = true
            }
            curNum /= 10
        }
        return (changed ? 1 : 0) + rotatedDigits(N - 1)
    }
}

---

56ms

class Solution {
    func rotatedDigits(_ N: Int) -> Int {
        var c : Set<Int> = [2,5,6,9]
        var k : Set<Int> = [0,1,8]
        var ans = 0
        for i in 1 ... N {
            var j = i
            var cn = 0, kn = 0
            var valid = true
            while j > 0 {
                let d = j%10
                if c.contains(d) {
                    cn += 1
                } else if k.contains(d) {
                    kn += 1
                } else {
                    valid = false
                    break
                }
                j = j/10
            }
            if valid && cn > 0 {
                ans += 1
            }
        }
        return ans
    }
}

---

68ms

class Solution {
    func rotatedDigits(_ N: Int) -> Int {
        if N == 0 {
            return 0
        }
        var count = 0
        for i in 1...N {
            if checkIfCanBeRotated(String(i)) {
                count += 1
            }
        }
        return count
    }
    
    func checkIfCanBeRotated(_ str: String) -> Bool {
        var res = false
        for s in str {
            if s == "2" || s == "5" || s == "6" || s == "9" {
                res = true
            } else if s == "3" || s == "4" || s == "7" {
                return false
            }
        }
        return res 
    }
}

---

196ms

class Solution {
    func rotatedDigits(_ N: Int) -> Int {
        let invalid: Set<Character> = Set(["3", "4", "7"])
        let diff: Set<Character> = Set(["2", "5", "6", "9"])
        var res = 0

        for i in 1...N {
            let lookup = Set(Array(String(i)))
            //确定两个集合是否没有共同的值
            if lookup.isDisjoint(with: invalid) && !lookup.isDisjoint(with: diff) {
                res += 1
            }
        }

        return res
    }
}