41-剑指 Offer 43. 1～n 整数中 1 出现的次数

题目

输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。

例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。

示例 1：

输入：n = 12
输出：5

示例 2：

输入：n = 13
输出：6

限制：1 <= n < 2^31

---

思路

计算原则：先计算个位数上1的个数，再计算十位数上1的个数，之后再计算百位数上1的个数......由低位向高位逐位计算各个位上1的个数，最后将其全部相加即可。

如何计算各个位上1的个数？

①定义一个bit变量，表示要计算哪一位上1的个数，对应关系如下：

计算哪个位上1的个数	bit
个位	1
十位	10
百位	100
千位	1000
......	......

②定义一个cur变量，表示bit位上当前的值，cur = (n / bit) % 10。

cur的右边表示低位，用low表示，low = n % bit。

cur的左边表示高位，用high表示，high = n / bit / 10。

③计算在bit位上一共有多少个1：

cur > 1：强行将cur固定为1，再计算：bit位上1的个数 = (high + 1) * bit。

cur == 1：要进行分类讨论，再计算：bit位上1的个数 = (high * bit) + (low + 1)。

cur == 0：强行将cur固定为1，再计算：bit位上1的个数 = high * bit。

④循环利用上述公式，由低位向高位逐位计算各个位上1的个数，最后将其全部相加得到sum即可。

例：n = 501222

• 计算个位上1的个数：bit = 1。

1. cur = (n / bit) % 10 = (501222 / 1) % 10 = 2。
2. low = n % bit = 501222 % 1 = 0。
3. high = n / bit / 10 = 501222 / 1 / 10 = 50122。
4. 此时cur > 1，强行将cur固定为1，再计算个位上1的个数 = (high + 1) * bit = (50122 + 1) * 1 = 50123。

• 计算十位上1的个数：bit = 10。

1. cur = (n / bit) % 10 = (501222 / 10) % 10 = 2。
2. low = n % bit = 501222 % 10 = 2。
3. high = n / bit / 10 = 501222 / 10 / 10 = 5012。
4. 此时cur > 1，强行将cur固定为1，再计算个位上1的个数 = (high + 1) * bit = (5012 + 1) * 10 = 50130。

• 计算百位上1的个数：bit = 100。

1. cur = (n / bit) % 10 = (501222 / 100) % 10 = 2。
2. low = n % bit = 501222 % 100 = 22。
3. high = n / bit / 10 = 501222 / 100 / 10 = 501。
4. 此时cur > 1，强行将cur固定为1，再计算百位上1的个数 = (high + 1) * bit = (501 + 1) * 100 = 50200。

• 计算千位上1的个数：bit = 1000。

1. cur = (n / bit) % 10 = (501222 / 1000) % 10 = 1。
2. low = n % bit = 501222 % 1000 = 222。
3. high = n / bit / 10 = 501222 / 1000 / 10 = 50。
4. 此时cur == 1，要进行分类讨论，再计算千位上1的个数 = (high * bit) + (low + 1) = (50 * 1000) + (222 + 1) = 50000 + 223 = 50223。

• 计算万位上1的个数：bit = 10000。

1. cur = (n / bit) % 10 = (501222 / 10000) % 10 = 0。
2. low = n % bit = 501222 % 10000 = 1222。
3. high = n / bit / 10 = 501222 / 10000 / 10 = 5。
4. 此时cur == 0，强行将cur固定为1，再计算万位上1的个数 = high * bit = 5 * 10000 = 50000。

• 计算十万位上1的个数：bit = 100000。

1. cur = (n / bit) % 10 = (501222 / 100000) % 10 = 5。
2. low = n % bit = 501222 % 100000 = 1222。
3. high = n / bit / 10 = 501222 / 100000 / 10 = 0.501222 约= 0。
4. 此时cur > 1，强行将cur固定为1，再计算百位上1的个数 = (high + 1) * bit = (0 + 1) * 100000 = 100000。

1～501222这501222个整数的十进制表示中1出现的次数sum = 50123 + 50130 + 50200 + 50223 + 50000 + 100000 = 350676。

---

代码

class Solution {
    /**
     * 几个变量计算：cur = (n / bit) % 10, low = n % bit, high = n / bit / 10
     * 几个公式：
     * cur > 1 => (high + 1) * bit
     * cur == 1 => (high * bit) + (1 + low)
     * cur == 0 => high * bit
     * @param n
     * @return
     */
    public int countDigitOne(int n) {
        long bit = 1; //用int的话可能会有溢出风险
        long sum = 0; //计算最终的结果

        while(bit <= n) {
            long cur = (n / bit) % 10;
            long low = n % bit;
            long high = n / bit / 10;

            if(cur > 1) {
                sum += (high + 1) * bit;
            } else if(cur == 1) {
                sum += (high * bit) + (1 + low);
            } else {
                sum += high * bit;
            }
            bit = bit * 10;
        }
        return (int)sum;
    }
}

public class JZ43 {
    /**
     * 几个变量计算：cur = (n / bit) % 10, low = n % bit, high = n / bit / 10
     * 几个公式：
     * cur > 1 => (high + 1) * bit
     * cur == 1 => (high * bit) + (1 + low)
     * cur == 0 => high * bit
     * @param n
     * @return
     */
    public static void main(String[] args) {
        System.out.println(countDigitOne(501222));
    }

    public static int countDigitOne(int n) {
        long bit = 1; //用int的话可能会有溢出风险
        long sum = 0; //计算最终的结果

        while(bit <= n) {
            long cur = (n / bit) % 10;
            long low = n % bit;
            long high = n / bit / 10;

            if(cur > 1) {
                sum += (high + 1) * bit;
            } else if(cur == 1) {
                sum += (high * bit) + (1 + low);
            } else {
                sum += high * bit;
            }
            bit = bit * 10;
        }
        return (int)sum;
    }
}