数字

1、整型数V的二进制中1的个数

//普通解法：除以2，看余数

int Count(int v)

{

    int num = 0;

    while(v)

    {

        if(v % 2 == 1)

            ++ num;

        v /= 2;

    }

    return num;

}

 

//使用位移

int Count(int v)

{

    int num = 0;

    while(v)

    {

        num += v & 1;

        v >>= 1;

    }

    return num;

}

位移的思路，当输入i是正数时没有问题，但当输入的i是一个负数时，不但不能得到正确的1的个数，还将导致死循环。以负数0x80000000为例，右移一位的时候，并不是简单地把最高位的1移到第二位变成0x40000000，而是0xC0000000。这是因为移位前是个负数，仍然要保证移位后是个负数，因此移位后的最高位会设为1。如果一直做右移运算，最终这个数字就会变成0xFFFFFFFF而陷入死循环。
为了避免死循环，我们可以不右移输入的数字i。首先i和1做与运算，判断i的最低位是不是为1。接着把1左移一位得到2，再和i做与运算，就能判断i的次高位是不是1……这样反复左移，每次都能判断i的其中一位是不是1。基于此，我们得到如下代码：

int Count1(int v)

{

    int num = 0;

    unsigned int flag = 1;

    while(flag)

    {

        if(v & flag)

            ++ num;

        flag <<= 1;

    }

    return num;

}

整数A 和B 的二进制表示中有多少位是不同的？
把两个整数 A, B 异或, 然后又回归到判断 1 的个数

int Count(int a,int b)

{

    int num = 0;

    int v = a ^ b;

    while(v)

    {

       v &= (v-1);

       num++;

    }

    return num;

}

整数n，判断它是否为2的方幂（即二进制中只有一个1）
解答：n>0 &&(n&(n-1)==0)
原理：由于2的N次方的数二进制表示是第1位为1，其余为0，而x-1（假如x为2的N次方）得到的数的二进制表示恰恰是第1位为0，其余为1，两者相与，得到的结果就为0，否则结果肯定不为0

2、N的阶乘中末尾有几个0

如果N!= K×10M，且K不能被10整除，那么N!末尾有M个0。再考虑对N!进行质因数分解，N!=（2^x）×（3^y）×（5^z）…，由于10 = 2×5，所以M只跟X和Z相关，每一对2和5相乘可以得到一个10，于是M = min（X, Z）。不难看出X大于等于Z，因为能被2整除的数出现的频率比能被5整除的数高得多，所以把公式简化为M = Z。问题相当于求N!中有质因数5的个数

//直接计算i（i=1,2,...,N）的因式分解中5的指数

int numberOfFive(int N)

{

    int ret = 0;

    for(int i =1; i <= N; i++)

    {

        int j = i;

        while(j%5 ==0)

        {

            ret++;

            j /= 5;

        }

    }

    return ret;

}

 

// N!中含有质因数5的个数： Z = [N/5] +[N/5^2] + [N/5^3]+...

int numberOfFive2(int N)

{

    int ret = 0;

    while(N)

    {

        ret += N / 5;

        N /= 5;

    }

    return ret;

}

N!的二进制表示中最低位1的位置。给定一个整数N，求N!二进制表示的最低位1在第几位？例如：给定N=3，N!=6，那么N!的二进制表示（110）的最低位1在第二位。
这个问题实际上等同于求N!含有质因数2的个数。即答案等于N!含有质因数2的个数加1。
N!中含有质因数2的个数，等于 N/2 + N/4 + N/8 + N/16 + …

int lowestOne(int N)

{

    int ret = 0;

    while(N)

    {

        N >>= 1;

        ret += N;

    }

    return ret;

}

3、1的个数

给定一个整数n，求从1到n这n个整数的十进制表示中1出现的次数。
例如输入12，从1到12这些整数中包含1 的数字有1，10，11和12，1一共出现了5次。

//统计一个整数的十进制表示中1出现的次数  

unsigned intCountOneInAInteger(unsignedint n) 

{ 

    unsigned int count = 0; 

    while(n) 

    { 

        if(n % 10 == 1) 

            count++; 

        n /= 10; 

    } 

    return count; 

} 

//统计从1到n这n个整数的十进制表示中1出现的次数 

unsigned intCountOneBitween1AndN_Solution1(unsignedint n) 

{ 

    unsigned int count = 0; 

    for(unsigned int i = 1; i <= n; i++) 

        count += CountOneInAInteger(i); //穷举法  

    return count; 

} 

 

//优化的算法，来自《编程之美》，比较麻烦，只能看明白  

unsigned intCountOneBitween1AndN_Solution2(unsignedint n) 

{ 

    unsigned int count = 0; 

    unsigned int factor = 1; //计算每一位上出现1的次数，从个位开始  

    //每一位上出现1的次数与它的高位数字、低位数字、以及自身都有关系  

    //比如12345，如果计算百位上出现1的次数，这要考虑高位数字12，以及低位数字45有关  

    unsigned int lowNum = 0;   //低位数字  

    unsigned int highNum = 0;  //高位数字  

    unsigned int curNum = 0;   //当前位  

    while(n / factor != 0) 

    { 

        lowNum = n - (n / factor) *factor; 

        highNum = n / (factor * 10); 

        curNum = (n / factor) % 10;    

        switch(curNum) 

        { 

        case 0: //当前位的数字为 0  

            count += highNum * factor; //只与高位有关   

            break; 

        case 1: 

            count += highNum * factor + lowNum+ 1; //与高位低位都有关  

            break; 

        default: 

            count += (highNum + 1) * factor;//与高位有关  

            break; 

        } 

        factor *= 10; //计算下一位  

    } 

    return count; 

} 

4、最大公约数

//辗转相除法：f(x, y)= f(y, x % y)（y>0）

int gcd(int x,int y)

{

    if(y == 0)

        return x;

    else return gcd(y, x%y);

}

 

//辗转相减法：f(x, y)= f(x-y, y)（x>y）

int gcd(int x,int y)

{

    if(x < y)

        return gcd(y, x);

    if(y == 0)

        return x;

    else

        return gcd(x - y, y);

}

 

/*

x is even, y is even, f(x, y) =2 * f(x>>1, y>>1)

x is even, y is odd, f(x,y) =f(x>>1, y)

x is odd, y is even, f(x,y) =f(x, y>>1)

x is odd, y is odd, f(x,y) =f(y, x-y)

*/

int gcd(int x,int y)

{

    if(x < y)

        return gcd(y, x);

    if(y == 0)

        return x;

    else

    {

        if(IsEven(x))

        {

            if(IsEven(y))

                return (gcd(x >> 1, y >> 1) << 1);

            else

                return gcd(x >> 1, y);

        }

        else

        {

            if(IsEven(y))

                return gcd(x, y >>1);

            else

                return gcd(y, x - y);

        }

    }

}

5、判断一个自然数N是否是某个数的平方。当然不能使用开方sqrt()函数运算。

方法1：遍历从1到N的数字，求取平方并和N进行比较。如果平方小于N，则继续遍历；如果等于N，则成功退出；如果大于N，则失败退出。时间复杂度为O(n)。

方法2：使用二分查找法，对1到N之间的数字进行判断。复杂度为O(logN)。

unsigned int sqrt(unsigned int x)

{

    // x的最大值不超过max*max

    unsigned int max = (1 << (sizeof(x)/2*8))-1;//65535

    if (max*max < x) return max;

   

    unsigned int low = 0;

    unsigned int high = max-1;

   

    unsigned int mid = 0;

    while(1)

    {

        mid = (low+high)/2;

        if (x < mid * mid)

            high = mid-1;

        else if((mid+1)*(mid+1) <= x)

            low = mid+1;

        else //if(mid *mid <= x && x < (mid+1)*(mid+1))

            break;

    }

   

    return  mid;

}

方法3：由于(n+1)^2 = n^2 + 2n + 1 = ...= 1 + (2*1 +1) + (2*2 + 1) + ... + (2*n + 1)
注意到这些项构成了等差数列（每项之间相差2），所以我们可以比较 N-1， N - 1 - 3， N - 1 - 3 - 5 ... 和0的关系。如果大于0，则继续减；如果等于0，则成功退出；如果小于 0，则失败退出。
复杂度为O(n)。不过方法3中利用加减法替换掉了方法1中的乘法，所以速度会更快些。

int square(int n) 

{ 

    int i = 1; 

    n = n - i; 

    while(n > 0) 

    { 

        i += 2;  

        n -= i; 

    } 

    if(n == 0)        //是某个数的平方  

        return 1; 

    else                //不是某个数的平方  

        return 0; 

}

6、怎么能随即生成m个数，让其和等于n？

题目：假设生成26个非负随机数，要求其和是301，求程序生成此列数字
 
解法一：关于此种算法原理，可以假想是一根长301单位的绳子，然后随即在其上面截25个点，于是得到26根子绳，这26根子绳之和恰好就是绳子总长301。
于是可以：
1 初始化27的数组
2 该数组0位和26位分别为0和301，其他位置填充0到301之间的随机数字
3 对数组排序
4 数组相邻数字相减，所得的26个差值即为所求数列。

解法二：这种方案利用了非负这个不显眼的条件，思路非常简单，就是将1随机加到一个26位数组中，随机301次，有点剑走偏锋，另辟蹊径。