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.

• Java
• C++
• Python
• Go

• 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)
  }
  

All Problems

All Solutions