##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/788.html

# 788. Rotated Digits (Easy)

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].

Companies:
Google

Related Topics:
String

## Solution 1.

• class Solution {
public int rotatedDigits(int N) {
int count = 0;
for (int i = 1; i <= N; i++) {
String numStr = String.valueOf(i);
if (numStr.indexOf('3') >= 0 || numStr.indexOf('4') >= 0 || numStr.indexOf('7') >= 0)
continue;
if (numStr.indexOf('2') >= 0 || numStr.indexOf('5') >= 0 || numStr.indexOf('6') >= 0 || numStr.indexOf('9') >= 0)
count++;
}
return count;
}
}

############

class Solution {
private int[] a = new int[6];
private int[][] dp = new int[6][2];

public int rotatedDigits(int n) {
int len = 0;
for (var e : dp) {
Arrays.fill(e, -1);
}
while (n > 0) {
a[++len] = n % 10;
n /= 10;
}
return dfs(len, 0, true);
}

private int dfs(int pos, int ok, boolean limit) {
if (pos <= 0) {
return ok;
}
if (!limit && dp[pos][ok] != -1) {
return dp[pos][ok];
}
int up = limit ? a[pos] : 9;
int ans = 0;
for (int i = 0; i <= up; ++i) {
if (i == 0 || i == 1 || i == 8) {
ans += dfs(pos - 1, ok, limit && i == up);
}
if (i == 2 || i == 5 || i == 6 || i == 9) {
ans += dfs(pos - 1, 1, limit && i == up);
}
}
if (!limit) {
dp[pos][ok] = ans;
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/rotated-digits/
// Time: O(ND) where D is the count of digits in N
// Space: O(1)
class Solution {
private:
bool isGood(int N) {
bool good = false;
while (N) {
int d = N % 10;
if (d == 3 || d == 4 || d == 7) return false;
if (d == 2 || d == 5 || d == 6 || d == 9) good = true;
N /= 10;
}
return good;
}
public:
int rotatedDigits(int N) {
int cnt = 0;
for (int i = 1; i <= N; ++i) {
if (isGood(i)) ++cnt;
}
return cnt;
}
};

• class Solution:
def rotatedDigits(self, n: int) -> int:
@cache
def dfs(pos, ok, limit):
if pos <= 0:
return ok
up = a[pos] if limit else 9
ans = 0
for i in range(up + 1):
if i in (0, 1, 8):
ans += dfs(pos - 1, ok, limit and i == up)
if i in (2, 5, 6, 9):
ans += dfs(pos - 1, 1, limit and i == up)
return ans

a = [0] * 6
l = 1
while n:
a[l] = n % 10
n //= 10
l += 1
return dfs(l, 0, True)

############

class Solution(object):
def rotatedDigits(self, N):
"""
:type N: int
:rtype: int
"""
valid = [2, 5, 6, 9]
nonValid = [3, 4, 7]
def isGood(num):
for y in nonValid:
if str(y) in str(num):
return False
return any(str(x) in str(num) for x in valid)
return sum(map(int, [isGood(n) for n in range(1, N + 1)]))

• func rotatedDigits(n int) int {
a := make([]int, 6)
dp := make([][2]int, 6)
for i := range a {
dp[i] = [2]int{-1, -1}
}
l := 0
for n > 0 {
l++
a[l] = n % 10
n /= 10
}

var dfs func(int, int, bool) int
dfs = func(pos, ok int, limit bool) int {
if pos <= 0 {
return ok
}
if !limit && dp[pos][ok] != -1 {
return dp[pos][ok]
}
up := 9
if limit {
up = a[pos]
}
ans := 0
for i := 0; i <= up; i++ {
if i == 0 || i == 1 || i == 8 {
ans += dfs(pos-1, ok, limit && i == up)
}
if i == 2 || i == 5 || i == 6 || i == 9 {
ans += dfs(pos-1, 1, limit && i == up)
}
}
if !limit {
dp[pos][ok] = ans
}
return ans
}

return dfs(l, 0, true)
}