劍指Offer（java版）：從1到n整數中1出現的次數

時間 2019-11-19

原文原文鏈接

題目：輸入一個整數n，求從1到n個整數的十進制表示中1出現的次數。例如輸入12，從1到12這些整數中包含1的數字有1，10，11，和12，1一共出現了5次。html

方法一：不考慮時間效率的解法，靠它拿到Offer有點難：git

若是在面試的時候碰到這個問題，應聘者大多能想到最直觀的方法，也就是累加1到n中每一個整數1出現的次數。咱們可疑每次經過對10求餘數判斷整數的個位數字是否是1.若是這個數字大於10，除以10以後再判斷個位數字是否是1.如12，12%10=2，有0個，再12/10=1，而後1%10=1面試

基於這個思路，咱們寫出下面的代碼：算法

package cglib;spa

public class List1
{
   public int numberOf1BetweenAndN(int n){
        int number = 0;
        for(int i = 1;i<= n;i++){
            number+=numberOf1(i);
            System.out.println("number="+number);
        }
        return number;
    }
    public int numberOf1(int n){
        int number =0;
        while(n!=0){
           System.out.println("進到while");
           System.out.println("n="+n);
           System.out.println("n%10="+(n%10));
            if(n %10 == 1)
                number++;

            n = n/10;

            System.out.println("整除10後n="+n);
        }
        return number;
    }
    public static void main(String[] args){
        int n =12;
        List1 test = new List1();
        System.out.println(test.numberOf1BetweenAndN(n));
    }



    } .net

輸出：htm

進到while
n=1
n%10=1
整除10後n=0
number=1
進到while
n=2
n%10=2
整除10後n=0
number=1
進到while
n=3
n%10=3
整除10後n=0
number=1
進到while
n=4
n%10=4
整除10後n=0
number=1
進到while
n=5
n%10=5
整除10後n=0
number=1
進到while
n=6
n%10=6
整除10後n=0
number=1
進到while
n=7
n%10=7
整除10後n=0
number=1
進到while
n=8
n%10=8
整除10後n=0
number=1
進到while
n=9
n%10=9
整除10後n=0
number=1
進到while
n=10
n%10=0
整除10後n=1
進到while
n=1
n%10=1
整除10後n=0
number=2
進到while
n=11
n%10=1
整除10後n=1
進到while
n=1
n%10=1
整除10後n=0
number=4
進到while
n=12
n%10=2
整除10後n=1
進到while
n=1
n%10=1
整除10後n=0
number=5
5blog

從上述思路中，咱們對每一個數字都要作出發和求餘運算以求出該數字中1出現的次數。若是輸入數字n，n有O(logn)位，咱們須要判斷每一位是否是1，那麼它的時間複雜度是O(n*logn)。當輸入n很是大的時候，須要大量的計算，運算效率不高。面試官不會滿意這種算法。get

同理：計算1至n中數字X出現的次數

public class List1
{
   public int numberOf1BetweenAndN(int n,int x){
        int number = 0;
        for(int i = 1;i<= n;i++){
            number+=numberOf1(i,x);
            System.out.println("number="+number);
        }
        return number;
    }
    public int numberOf1(int n,int x){
        int number =0;
        while(n!=0){
           System.out.println("進到while");
           System.out.println("n="+n);
           System.out.println("n%10="+(n%10));
            if(n %10 == x)
                number++;

            n = n/10;

            System.out.println("整除10後n="+n);
        }
        return number;
    }
    public static void main(String[] args){
        int n =12;
        int x=1;
        List1 test = new List1();
        System.out.println(test.numberOf1BetweenAndN(n,x));
    }



    } 數學

方法二：從數字規律着手明顯提升時間效率的解法，能讓面試官耳目一新

1、1的數目

1. 若是第i位（自右至左，從1開始標號）上的數字爲0，則第i位可能出現1的次數由更高位決定（若沒有高位，視高位爲0），等於更高位數字X當前位數的權重10^i-1。如10345，自右至左第4位爲0，也就是千位，能出現1的次數由更高位決定，也就是1，萬位，10^4-1。

2. 若是第i位上的數字爲1，則第i位上可能出現1的次數不只受更高位影響，還受低位影響（若沒有低位，視低位爲0），等於更高位數字X當前位數的權重10^i-1+（低位數字+1）。

3. 若是第i位上的數字大於1，則第i位上可能出現1的次數僅由更高位決定（若沒有高位，視高位爲0），等於（更高位數字+1）X當前位數的權重10^i-1。

2、X的數目

這裏的 X∈[1,9] ，由於 X=0 不符合下列規律，須要單獨計算。

首先要知道如下的規律：

從 1 至 10，在它們的個位數中，任意的 X 都出現了 1 次。1,2,3,4,5,6,7,8,9
從 1 至 100，在它們的十位數中，任意的 X 都出現了 10 次。10,11-19
從 1 至 1000，在它們的百位數中，任意的 X 都出現了 100 次。

依此類推，從 1 至 10 ^i ，在它們的左數第二位（右數第 i 位）中，任意的 X 都出現了 10 ^ i−1 次。

這個規律很容易驗證，這裏再也不多作說明。

接下來以 n=2593,X=5 爲例來解釋如何獲得數學公式。從 1 至 2593 中，數字 5 總計出現了 813 次，其中有 259 次出如今個位，260 次出如今十位，294 次出如今百位，0 次出如今千位。

如今依次分析這些數據，首先是個位。從 1 至 2590 中，包含了 259 個 10，所以任意的 X 都出現了 259 次。最後剩餘的三個數 2591, 2592 和 2593，由於它們最大的個位數字 3 < X，所以不會包含任何 5。（也能夠這麼看，3<X，則個位上可能出現的X的次數僅由更高位決定，等於更高位數字（259）X101-1=259）。

而後是十位。從 1 至 2500 中，包含了 25 個 100，所以任意的 X 都出現了 25×10=250 次。剩下的數字是從 2501 至 2593，它們最大的十位數字 9 > X，所以會包含所有 10 個 5。最後總計 250 + 10 = 260。（也能夠這麼看，9>X，則十位上可能出現的X的次數僅由更高位決定，等於更高位數字（25+1）X102-1=260）。

接下來是百位。從 1 至 2000 中，包含了 2 個 1000，所以任意的 X 都出現了 2×100=200 次。剩下的數字是從 2001 至 2593，它們最大的百位數字 5 == X，這時狀況就略微複雜，它們的百位確定是包含 5 的，但不會包含所有 100 個。若是把百位是 5 的數字列出來，是從 2500 至 2593，數字的個數與百位和十位數字相關，是 93+1 = 94。最後總計 200 + 94 = 294。（也能夠這麼看，5==X，則百位上可能出現X的次數不只受更高位影響，還受低位影響，等於更高位數字（2）X103-1+（93+1）=294）。

最後是千位。如今已經沒有更高位，所以直接看最大的千位數字 2 < X，因此不會包含任何 5。（也能夠這麼看，2<X，則千位上可能出現的X的次數僅由更高位決定，等於更高位數字（0）X104-1=0）。

到此爲止，已經計算出所有數字 5 的出現次數。

總結一下以上的算法，能夠看到，當計算右數第 i 位包含的 X 的個數時：

取第 i 位左邊（高位）的數字，乘以 10 ^i−1 ，獲得基礎值 a 。
取第 i 位數字，計算修正值：
1. 若是大於 X，則結果爲 a+ 10 ^ i−1 。
2. 若是小於 X，則結果爲 a 。
3. 若是等於 X，則取第 i 位右邊（低位）數字，設爲 b ，最後結果爲 a+b+1 。

相應的代碼很是簡單，效率也很是高，時間複雜度只有 O( log 10 n) 。

咱們換個角度思考，給定一個N，咱們分析1~N中的數在每一位上出現1的次數的和，看看每一位上"1"出現的個數的和由什麼決定。
1位數的狀況：在解法二中已經分析過，大於等於1的時候，有1個，小於1就沒有。
2位數的狀況：N=13,個位數出現的1的次數爲2，分別爲1和11，十位數出現1的次數爲4，分別爲10,11,12,13，因此f(N) = 2+4。N=23,個位數出現的1的次數爲3，分別爲1，11，21，十位數出現1的次數爲10，分別爲10~19，f(N)=3+10。
由此咱們發現，個位數出現1的次數不只和個位數有關，和十位數也有關，若是個位數大於等於1，則個位數出現1的次數爲十位數的數字加1；若是個位數爲0，個位數出現1的次數等於十位數數字。而十位數上出現1的次數也不只和十位數相關，也和個位數相關：若是十位數字等於1，則十位數上出現1的次數爲個位數的數字加1，假如十位數大於1，則十位數上出現1的次數爲10。
3位數的狀況：
N=123，個位出現1的個數爲13:1,11,21，…，91,101,111,121。十位出現1的個數爲20:10~19,110~119。百位出現1的個數爲24:100~123。
咱們能夠繼續分析4位數，5位數，推導出下面通常狀況：假設N，咱們要計算百位上出現1的次數，將由三部分決定：百位上的數字，百位以上的數字，百位一下的數字。

若是百位上的數字爲0，則百位上出現1的次數僅由更高位決定，好比12013，百位出現1的狀況爲100~199,1100~1199,2100~2199，…，11100~11199，共1200個。等於更高位數字乘以當前位數，即12 * 100。
若是百位上的數字大於1，則百位上出現1的次數僅由更高位決定，好比12213，百位出現1的狀況爲100~199,1100~1199,2100~2199，…，11100~11199，12100~12199共1300個。等於更高位數字加1乘以當前位數，即（12 + 1）*100。
若是百位上的數字爲1，則百位上出現1的次數不只受更高位影響，還受低位影響。例如12113，受高位影響出現1的狀況：100~199,1100~1199,2100~2199，…，11100~11199，共1200個，但它還受低位影響，出現1的狀況是12100~12113，共114個，等於低位數字113+1。

package cglib;

public class jiekou {

   public int NumberOfXBetween1AndN_Solution(int n,int x) {
        if(n<0||x<1||x>9)
            return 0;
        int high,low,curr,tmp,i = 1;
        high = n;
        int total = 0;
        System.out.println("n="+n);
        System.out.println("x="+x);
        while(high!=0){
           System.out.println("while中i="+i);
           System.out.println("while中high="+high);
            high = n/(int)Math.pow(10, i);// 獲取第i位的高位
            System.out.println("獲取第"+i+"位的高位 high="+high);
            tmp = n%(int)Math.pow(10, i);
            System.out.println("獲取第"+i+"位的餘數 tmp="+tmp);
            curr = tmp/(int)Math.pow(10, i-1);// 獲取第i位
            System.out.println("獲取第"+i+"位 curr="+curr);
            low = tmp%(int)Math.pow(10, i-1);// 獲取第i位的低位
            System.out.println("獲取第"+i+"位的低位 low="+low);
            System.out.println("x="+x);
            if(curr==x){
                total+= high*(int)Math.pow(10, i-1)+low+1;
                System.out.println("curr==x");
                System.out.println("total="+total);
            }else if(curr<x){
                total+=high*(int)Math.pow(10, i-1);
                System.out.println("curr<x");
                System.out.println("total="+total);
            }else{
                total+=(high+1)*(int)Math.pow(10, i-1);
                System.out.println("curr>x");
                System.out.println("total="+total);
            }
            i++;
        }
        return total;
   }


    /**
     * @param args
     */
   public static void main(String[] args) {
       jiekou p=new jiekou();
       System.out.println(p.NumberOfXBetween1AndN_Solution(123,1));
       }
    }

輸出：

n=123
x=1
while中i=1
while中high=123
獲取第1位的高位 high=12
獲取第1位的餘數 tmp=3
獲取第1位 curr=3
獲取第1位的低位 low=0
x=1
curr>x
total=13
while中i=2
while中high=12
獲取第2位的高位 high=1
獲取第2位的餘數 tmp=23
獲取第2位 curr=2
獲取第2位的低位 low=3
x=1
curr>x
total=33
while中i=3
while中high=1
獲取第3位的高位 high=0
獲取第3位的餘數 tmp=123
獲取第3位 curr=1
獲取第3位的低位 low=23
x=1
curr==x
total=57
57

或者：

public class Problem32 { public static void main(String[] args) { Problem32 p=new Problem32(); System.out.println(p.countOne(123)); } public long countOne(long n) { long count = 0; long i = 1; long current = 0,after = 0,before = 0; while((n / i) != 0) { current = (n / i) % 10; //當前位數字 before = n / (i * 10); //高位數字 after = n - (n / i) * i; //低位數字 if (current > 1) count = count + (before + 1) * i; else if (current == 0) count = count + before * i; else if(current == 1) count = count + before * i + after + 1; i = i * 10; } return count; } }