Welcome to Subscribe On Youtube

233. Number of Digit One

Description

Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.

 

Example 1:

Input: n = 13
Output: 6

Example 2:

Input: n = 0
Output: 0

 

Constraints:

• 0 <= n <= 109

Solutions

simple digital dp problem (or it can be solved by finding a rule)

• Java
• C++
• Python
• Go
• C#
• TypeScript

• class Solution {
      private int[] a = new int[12];
      private int[][] dp = new int[12][12];
  
      public int countDigitOne(int n) {
          int len = 0;
          while (n > 0) {
              a[++len] = n % 10;
              n /= 10;
          }
          for (var e : dp) {
              Arrays.fill(e, -1);
          }
          return dfs(len, 0, true);
      }
  
      private int dfs(int pos, int cnt, boolean limit) {
          if (pos <= 0) {
              return cnt;
          }
          if (!limit && dp[pos][cnt] != -1) {
              return dp[pos][cnt];
          }
          int up = limit ? a[pos] : 9;
          int ans = 0;
          for (int i = 0; i <= up; ++i) {
              ans += dfs(pos - 1, cnt + (i == 1 ? 1 : 0), limit && i == up);
          }
          if (!limit) {
              dp[pos][cnt] = ans;
          }
          return ans;
      }
  }
  

• class Solution {
  public:
      int a[12];
      int dp[12][12];
  
      int countDigitOne(int n) {
          int len = 0;
          while (n) {
              a[++len] = n % 10;
              n /= 10;
          }
          memset(dp, -1, sizeof dp);
          return dfs(len, 0, true);
      }
  
      int dfs(int pos, int cnt, bool limit) {
          if (pos <= 0) {
              return cnt;
          }
          if (!limit && dp[pos][cnt] != -1) {
              return dp[pos][cnt];
          }
          int ans = 0;
          int up = limit ? a[pos] : 9;
          for (int i = 0; i <= up; ++i) {
              ans += dfs(pos - 1, cnt + (i == 1), limit && i == up);
          }
          if (!limit) {
              dp[pos][cnt] = ans;
          }
          return ans;
      }
  };
  

• class Solution:
      def countDigitOne(self, n: int) -> int:
          @cache
          def dfs(pos, cnt, limit):
              if pos <= 0:
                  return cnt
              up = a[pos] if limit else 9
              ans = 0
              for i in range(up + 1):
                  ans += dfs(pos - 1, cnt + (i == 1), limit and i == up)
              return ans
  
          a = [0] * 12
          l = 1
          while n:
              a[l] = n % 10
              n //= 10
              l += 1
          return dfs(l, 0, True)
  
  

• func countDigitOne(n int) int {
  	a := make([]int, 12)
  	dp := make([][]int, 12)
  	for i := range dp {
  		dp[i] = make([]int, 12)
  		for j := range dp[i] {
  			dp[i][j] = -1
  		}
  	}
  	l := 0
  	for n > 0 {
  		l++
  		a[l] = n % 10
  		n /= 10
  	}
  	var dfs func(int, int, bool) int
  	dfs = func(pos, cnt int, limit bool) int {
  		if pos <= 0 {
  			return cnt
  		}
  		if !limit && dp[pos][cnt] != -1 {
  			return dp[pos][cnt]
  		}
  		up := 9
  		if limit {
  			up = a[pos]
  		}
  		ans := 0
  		for i := 0; i <= up; i++ {
  			t := cnt
  			if i == 1 {
  				t++
  			}
  			ans += dfs(pos-1, t, limit && i == up)
  		}
  		if !limit {
  			dp[pos][cnt] = ans
  		}
  		return ans
  	}
  	return dfs(l, 0, true)
  }
  

• public class Solution {
      public int CountDigitOne(int n) {
          if (n <= 0) return 0;
          if (n < 10) return 1;
          return CountDigitOne(n / 10 - 1) * 10 + n / 10 + CountDigitOneOfN(n / 10) * (n % 10 + 1) + (n % 10 >= 1 ? 1 : 0);
      }
      
      private int CountDigitOneOfN(int n) {
          var count = 0;
          while (n > 0)
          {
              if (n % 10 == 1) ++count;
              n /= 10;
          }
          return count;
      }
  }
  

• function countDigitOne(n: number): number {
      const s = n.toString();
      const m = s.length;
      const f: number[][] = Array.from({ length: m }, () => Array(m).fill(-1));
      const dfs = (i: number, cnt: number, limit: boolean): number => {
          if (i >= m) {
              return cnt;
          }
          if (!limit && f[i][cnt] !== -1) {
              return f[i][cnt];
          }
          const up = limit ? +s[i] : 9;
          let ans = 0;
          for (let j = 0; j <= up; ++j) {
              ans += dfs(i + 1, cnt + (j === 1 ? 1 : 0), limit && j === up);
          }
          if (!limit) {
              f[i][cnt] = ans;
          }
          return ans;
      };
      return dfs(0, 0, true);
  }
  
  

All Problems

All Solutions