摘要：計算階乘中尾部零的個數(shù)描述計算出階乘中尾部零的個數(shù)樣例，故返回分析對數(shù)字做質(zhì)數(shù)分解，例如，可以知道能夠在尾部產(chǎn)生零的只有質(zhì)數(shù)和質(zhì)數(shù)的乘積由于是階乘，質(zhì)數(shù)的個數(shù)明顯大于質(zhì)數(shù)的個數(shù)特別需要注意的是，類似，數(shù)字里面是有的指數(shù)的因而，總的個數(shù)應(yīng)當(dāng)是

計算出n階乘中尾部零的個數(shù)

11！ = 39916800，故返回2

對數(shù)字做質(zhì)數(shù)分解，例如20=225，可以知道能夠在尾部產(chǎn)生零的只有質(zhì)數(shù)2和質(zhì)數(shù)5的乘積

由于是階乘，質(zhì)數(shù)2的個數(shù)明顯大于質(zhì)數(shù)5的個數(shù)

特別需要注意的是，類似25=5*5，數(shù)字里面是有5的指數(shù)的

因而，總的個數(shù)應(yīng)當(dāng)是n/5 + n/(55) + n/(55*5) + ...

fun trailingZeors(n: Long): Long {
    var num : Long = n / 5
    var zeroNums : Long = num
    while (num > 0){
        num /= 5
        zeroNums += num
    }

    return zeroNums
}

public long trailingZeros(long n) {
    long num = n / 5;
    long zeroNums = num;
    while (num > 0)
    {
        num /= 5;
        zeroNums += num;
    }

    return zeroNums;
}

給一個整數(shù)n. 從 1 到 n 按照下面的規(guī)則打印每個數(shù)：

如果這個數(shù)被3整除，打印fizz

如果這個數(shù)被5整除，打印buzz

如果這個數(shù)能同時被3和5整除，打印fizz buzz

比如 n = 15, 返回一個字符串?dāng)?shù)組：
[
"1", "2", "fizz",
"4", "buzz", "fizz",
"7", "8", "fizz",
"buzz", "11", "fizz",
"13", "14", "fizz buzz"
]

邏輯清晰簡單，并無值得分析之處

fun fizzBuzz(n : Int) : Array
{
    var output : Array = Array(n, {""})

    for (i in 1..n)
    {
        if (i % 3 == 0 && i % 5 == 0)
        {
            output[i-1] = "fizz buzz"
        }
        else if (i % 3 == 0)
        {
            output[i-1] = "fizz"
        }
        else if (i % 5 == 0)
        {
            output[i-1] = "buzz"
        }
        else
        {
            output[i-1] = i.toString()
        }
    }

    return output
}

public List fizzBuzz(int n) {
    // write your code here
    List output = new ArrayList<>();
    for (int i=1; i<=n; i++)
    {
        if (i % 3 == 0 && i % 5 == 0)
        {
            output.add("fizz buzz");
        }
        else if (i % 3 == 0)
        {
            output.add("fizz");
        }
        else if (i % 5 == 0)
        {
            output.add("buzz");
        }
        else
        {
            output.add(String.valueOf(i));
        }
    }

    return output;
}

給定一個排序的整數(shù)數(shù)組和一個要查找的整數(shù)target，用O(logn)的時間查找到target第一次出現(xiàn)的下標(biāo)（從0開始），如果target不存在于數(shù)組中，返回-1

在數(shù)組 [1, 2, 3, 3, 4, 5, 10] 中二分查找3，返回2

簡單的二分查找問題，無須分析

fun binarySearch(nums : IntArray, target : Int) : Int
{
    var start = 0
    var end = nums.size

    while (end - start > 1)
    {
        var mid = (end + start) / 2

        when
        {
            nums[mid] > target ->
                end = mid
            nums[mid] < target ->
                start = mid
            else ->
                return mid
        }
    }

    return when(target)
    {
        nums[start] -> start
        nums[end] -> end
        else -> -1
    }
}

計算數(shù)字k在0到n中的出現(xiàn)的次數(shù)，k可能是0~9的一個值

例如n=12，k=1，在 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]，我們發(fā)現(xiàn)1出現(xiàn)了5次 (1, 10, 11, 12)

假設(shè)一個數(shù)n=4324，先考慮低位上的規(guī)律（先不計入千位）

只考慮個位數(shù)上的出現(xiàn)次數(shù)(n>10)，則可以按照0~9，10~19來劃分，每10個數(shù)字出現(xiàn)1次，記為$$1*10^0$$

只考慮十位數(shù)和個位數(shù)的出現(xiàn)次數(shù)(n>100)，則除了個位數(shù)上的出現(xiàn)次數(shù)，在十位數(shù)上，還會出現(xiàn)10次重復(fù)，即10+10*1=20，記為$$2*10^1$$

只考慮百位數(shù)和十位、各位數(shù)的出現(xiàn)次數(shù)(n>1000)，則在百位數(shù)上會出現(xiàn)100次重復(fù)，同時，前面討論的重復(fù)次數(shù)會再增加十倍，即100+20*10,記為$$3*10^2$$

再考慮千位本身，此時千位數(shù)字為4

若k<4，那么在千位上會出現(xiàn)1000次重復(fù)

若k=4，那么在千位上會出現(xiàn)324+1次重復(fù)

若k>4，那么在前為上不會出現(xiàn)重復(fù)

其它數(shù)字規(guī)律以此類推

fun digitCounts(k : Int, n : Int) : Int
{
    var num = n
    var sum = 0

    while (num > 0)
    {
        val len = num.toString().length - 1
        val base = Math.pow(10.0, len.toDouble()).toInt()

        sum += len * (base / 10) * (num / base)

        if (k > 0 && num / base > k)
        {
            sum += base
        }
        else if (k > 0 && num / base == k)
        {
            sum += num % base + 1
        }

        num %= base
    }

    //計算式對0不通用，需要再+1
    if (k == 0)
    {
        sum += 1
    }

    return sum
}

public int digitCounts(int k, int n) {
    int sum = 0;

    while (n > 0)
    {
        int len = String.valueOf(n).length() - 1;
        int base = (int)Math.pow(10, len);

        sum += len * (base / 10) * (n / base);

        if (k > 0 && n / base > k)
        {
            sum += base;
        }
        else if (k > 0 && n / base == k)
        {
            sum += n % base + 1;
        }

        n %= base;
    }

    //計算式對0不通用，需要再+1
    if (k == 0)
    {
        sum += 1;
    }

    return sum;
}