求教小学简便运算题1.（12.34+23.41+34.12+41.23)/(1+2+3+4）2.41.2X8.1+537X0.193.(8.5X13.3X7.2)/(1.7X1.8X1.9)4.99+99X99+99X99X995..99X20.096.如果Xa=345679Xb=,
1、原式=[(12+23+34+41)+(0.12+0.23+0.34+0.41)]/10 =[101*(0.12+0.23+0.34+0.41)]/10 =(101*1.1)/10=11.112、原式=412*0.81+537*0.19 =412*0.81+412*0.19+125*0.19 =412*1+23.75 =435.753、原式=[(5*1.7)*(7*1.9)*(4*1.8)]/(1.7*1.8*1.9) =5*7*4=1404、原式=99+99*99*100 =99+1995、原式=.9*+.1*+、题目真的有问题.是9个5不是8个.因为 所以a=*（345679）=54 b=*（345679）=45 a+b=54+45=99这可是有过程的哈,
为您推荐：
其他类似问题
（12.34+23.41+34.12+41.23)/(1+2+3+4）= 41.2X8.1+537X0.19= (8.5X13.3X7.2)/(1.7X1.8X1.9)= 99+99X99+99X99X99=
.99X20.09= 如果Xa=345679Xb=,那么a+b=a+b= 但貌似题目有问题应该是Xa=345679Xb=则：b=45所以：a+b=54+45=99
...= =..可以用计算机发...呼呼
扫描下载二维码1121人阅读
题目：输入一个整数，求该整数的二进制表达中有多少个1。
例如输入10，由于其二进制表示为1010，有两个1，因此输出2。
最初想法：
int countOne(int n)
&&& int c=0;
&& &while(n!=0)
&& &&& &c += n&1;
&& &&& &n=n&&1;
&& &printf(&%d&,c);
复杂度为 log2(n)。对n为负数时有问题，n&&1进行的是算术移位，左端补1，有数不尽的1、、、、
int countOne(int n)
&&&&& int c= 0;
&&&&& unsigned int flag = 1;
&&&&& while(flag)
&&&&&&&&&&& if(i &flag)
&&&&&&&&&&&&&&&& c++;
&&&&&&&&&& flag = flag && 1;
避免了负数进入死循环。
//以下是在网上找的方法，很神奇，很强大，就是理解有些难。
test(int n)
&&&&n = (n&0x) + ((n&&1)&0x);
&&&&n = (n&0x) + ((n&&2)&0x);
&&&&n = (n&0x0f0f0f0f) + ((n&&4)&0x0f0f0f0f);
&&&&n = (n&0x00ff00ff) + ((n&&8)&0x00ff00ff);
&&&&n = (n&0x0000ffff) + ((n&&16)&0x0000ffff);
&&&&return
没有循环，5个位运算语句，一次搞定。
比如这个例子，143的二进制表示是，这里只有8位，高位的0怎么进行与的位运算也是0，所以只考虑低位的运算，按照这个算法走一次
+---+---+---+---+---+---+---+---+
| 1 | 0 | 0 | 0 | 1 | 1 | 1 | 1 |&& &---143
+---+---+---+---+---+---+---+---+
|& 0 1& |&&0 0& |& 1 0&&|&&1 0&&|&& &---第一次运算后
+-------+-------+-------+-------+
|&&&&0 0 0 1 && |&&&&0 1 0 0&&&&|&& &---第二次运算后
+---------------+---------------+
|&&&&&&&&0 0 0 0 0 1 0 1&&&&&&&&|&& &---第三次运算后，得数为5
+-------------------------------+
这里运用了分治的思想，先计算每对相邻的2位中有几个1，再计算每相邻的4位中有几个1，下来8位，16位，32位，因为2^5＝32，所以对于32位的机器，5条位运算语句就够了。
像这里第二行第一个格子中，01就表示前两位有1个1，00表示下来的两位中没有1，其实同理。再下来01+00=0001表示前四位中有1个1，同样的10+10=0100表示低四位中有4个1，最后一步0=表示整个8位中有5个1。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：29297次
排名：千里之外
原创：17篇
转载：21篇
(1)(1)(1)(3)(4)(2)(3)(2)(5)(7)(4)(5)(1)求一个整数的二进制中1的个数(转)
&求一个整数的二进制中1的个数 收藏
题目：输入一个整数，求该整数的二进制表达中有多少个1。例如输入10，由于其二进制表示为1010，有两个1，因此输出2。
分析：这是一道很基本的考查位运算的面试题。包括微软在内的很多公司都曾采用过这道题。
一个很基本的想法是，我们先判断整数的最右边一位是不是1。接着把整数右移一位，原来处于右边第二位的数字现在被移到第一位了，再判断是不是1。这样每次
移动一位，直到这个整数变成0为止。现在的问题变成怎样判断一个整数的最右边一位是不是1了。很简单，如果它和整数1作与运算。由于1除了最右边一位以
外，其他所有位都为0。因此如果与运算的结果为1，表示整数的最右边一位是1，否则是0。
得到的代码如下：
///////////////////////////////////////////////////////////////////////
// Get how many 1s in an integer's binary expression
///////////////////////////////////////////////////////////////////////
int NumberOf1_Solution1(int i)
int count = 0;
&&&&&&&&&&&
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&
i = i && 1;
可能有读者会问，整数右移一位在数学上是和除以2是等价的。那可不可以把上面的代码中的右移运算符换成除以2呢？答案是最好不要换成除法。因为除法的效率比移位运算要低的多，在实际编程中如果可以应尽可能地用移位运算符代替乘除法。
这个思路当输入i是正数时没有问题，但当输入的i是一个负数时，不但不能得到正确的1的个数，还将导致死循环。以负数0x为例，右移一位
的时候，并不是简单地把最高位的1移到第二位变成0x，而是0xC0000000。这是因为移位前是个负数，仍然要保证移位后是个负数，
因此移位后的最高位会设为1。如果一直做右移运算，最终这个数字就会变成0xFFFFFFFF而陷入死循环。
为了避免死循环，我们可以不右移输入的数字i。首先i和1做与运算，判断i的最低位是不是为1。接着把1左移一位得到2，再和i做与运算，就能判断i的次高位是不是1……这样反复左移，每次都能判断i的其中一位是不是1。基于此，我们得到如下代码：
///////////////////////////////////////////////////////////////////////
// Get how many 1s in an integer's binary expression
///////////////////////////////////////////////////////////////////////
int NumberOf1_Solution2(int i)
int count = 0;
unsigned int flag = 1;
while(flag)
&&&&&&&&&&&
if(i & flag)
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&
flag = flag && 1;
另外一种思路是如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减去1，那么原来处在整数最右边的1就会变成0，原来在1后面的所有
的0都会变成1。其余的所有位将不受到影响。举个例子：一个二进制数1100，从右边数起的第三位是处于最右边的一个1。减去1后，第三位变成0，它后面
的两位0变成1，而前面的1保持不变，因此得到结果是1011。
我们发现减1的结果是把从最右边一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，从原来整数最右边一个1那一位
开始所有位都会变成0。如00。也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0。那么
一个整数的二进制有多少个1，就可以进行多少次这样的操作。
这种思路对应的代码如下：
///////////////////////////////////////////////////////////////////////
// Get how many 1s in an integer's binary expression
///////////////////////////////////////////////////////////////////////
int NumberOf1_Solution3(int i)
int count = 0;
&&&&&&&&&&&
&&&&&&&&&&&
i = (i - 1) &
扩展：如何用一个语句判断一个整数是不是二的整数次幂？
PS：n&(n-1)==0;//二进制数只有一位位1，则该数是2的整数次幂.
简单查表，相对来说效率也不错。
int countBits(int value){
int count=0;
int bits4[]={0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
while(value!=0){
&&&&&&&&&&&
count+=bits4[value&0xf];
value&&=4;
======================================================
这是一道《编程之美－微软技术面试心得》中的题目，问题描述如下：
对于一个字节(8bit)的变量,求其二进制表示中“1”的个数,要求算法的执行效率尽可能地高。
《编程之美》中给出了五种解法，但是实际上从 Wikipedia 上我们可以找到更优的算法。
这道题的本质相当于求二进制数的 Hamming 权重，或者说是该二进制数与 0 的 Hamming
距离，这两个概念在信息论和编码理论中是相当有名的。在二进制的情况下，它们也经常被叫做 population count 或者
popcount 问题，比如 gcc 中就提供了一个内建函数：
int __builtin_popcount (unsigned int x)
输出整型数二进制中 1 的个数。但是 GCC 的 __builtin_popcount
的实现主要是基于查表法做的，跟编程之美中解法 5 是一样的。Wikipedia
上的解法是基于分治法来做的，构造非常巧妙，通过有限次简单地算术运算就能求得结果，特别适合那些受存储空间限制的算法中使用：
#include &stdio.h&
typedef unsigned int UINT32;
const UINT32 m1& =
const UINT32 m2& =
const UINT32 m4& =
0x0f0f0f0f;& //
const UINT32 m8& =
0x00ff00& //
const UINT32 m16 = 0x0000& //
const UINT32 h01 = 0x;& // the sum
of 256 to the power of 0, 1, 2, 3
int popcount_1(UINT32 x)
& x = (x & m1) + ((x
&& 1) & m1);
& x = (x & m2) + ((x
&& 2) & m2);
& x = (x & m4) + ((x
&& 4) & m4);
& x = (x & m8) + ((x
&& 8) & m8);
& x = (x & m16) + ((x
&& 16) & m16);
int popcount_2(UINT32 x)
& x -= (x &&
m1;&&&&&&&&&&&&
//put count of each 2 bits into those 2 bits
& x = (x & m2) + ((x
&& 2) & m2); //put
count of each 4 bits into those 4 bits
& x = (x + (x
m4;&&&&&&&
//put count of each 8 bits into those 8 bits
& x += x &&
8;&&&&&&&&&&
//put count of each 16 bits into their lowest 8 bits
& x += x &&
16;&&&&&&&&&
//put count of each 32 bits into their lowest 8 bits
& return x & 0x1f;
int popcount_3(UINT32 x)
& x -= (x &&
m1;&&&&&&&&&&&&
//put count of each 2 bits into those 2 bits
& x = (x & m2) + ((x
&& 2) & m2); //put
count of each 4 bits into those 4 bits
& x = (x + (x
m4;&&&&&&&
//put count of each 8 bits into those 8 bits
& return (x * h01)
&& 24;& //
left 8 bits of x + (x&&8) +
int main()
& int i = 0x1ff12ee2;
& printf("i = %d = 0x%x\n", i, i);
& printf("popcount_1(%d) = %d\n", i,
popcount_1(i));
& printf("popcount_2(%d) = %d\n", i,
popcount_2(i));
& printf("popcount_3(%d) = %d\n", i,
popcount_3(i));
& printf("GCC's&
__builtin_popcount(%d) = %d\n", i,&
__builtin_popcount(i));
& return 0;
以上内容来源于
===========================================================
HAKMEM算法：
int Count(unsigned x)
n = (x && 1) &
n = (n && 1) &
x = (x + (x && 3)) &
x = modu(x, 63);&
说明：首先是将二进制各位三个一组，求出每组中1的个数，然后相邻两组归并，得到六个一组的1的个数，最后很巧妙的用除63取余得到了结果。
因为2^6 = 64，也就是说 x_0 + x_1 * 64 + x_2 * 64 * 64 = x_0 + x_1 + x_2
(mod 63)，这里的等号表示同余。
这个程序只需要十条左右指令，而且不访存，速度很快
本文来自CSDN博客，转载请标明出处：
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。把一个字节按位翻转排列解决方案 - C语言当前位置:& &&&把一个字节按位翻转排列解决方案把一个字节按位翻转排列解决方案&&网友分享于：&&浏览：188次把一个字节按位翻转排列例如一个字节的位排列为:。翻转即为:。用C代码高效实现。谢谢！第一次发问，也不知道自己有多少分，见笑了。------解决方案--------------------C/C++ code
#include &stdio.h&
ShowBit(unsigned int x, int n)
if (--n) ShowBit(x&&1, n);
printf(&%d&, x%2);
ReverseBit(unsigned int* pValue)
unsigned int n = *pV
n = (n&0x)&&1|(n&0xAAAAAAAA)&&1;
n = (n&0x)&&2|(n&0xCCCCCCCC)&&2;
n = (n&0x0F0F0F0F)&&4|(n&0xF0F0F0F0)&&4;
n = (n&0x00FF00FF)&&8|(n&0xFF00FF00)&&8;
n = (n&0x0000FFFF)&&16|(n&0xFFFF0000)&&16;
int main()
unsigned int x = 0x6A;
ShowBit(x, 32); printf(&\n&);
ReverseBit(&x);
ShowBit(x, 32); printf(&\n&);
------解决方案--------------------int reserv(int n){
int r = 0;
for(i=0;i&sizeof(n)*8; i++)
r |= (n&1);
------解决方案--------------------C/C++ code
int ReverseBits(int number)
int result, modV
modVal = 1 && 31;
number &&= 24;
//if reverse an Integer number, please comments this line
result = 0;
for(i = 0; i & 8; i++)
if((number & modVal) != 0)
result |= (1 && i);
number &&= 1;
int main(void)
printf(&%d&, ReverseBits(1));
------解决方案--------------------//改一下,改成动态分配,上面也有点BUG,memset应该放WHILE里去C/C++ code
#include &stdio.h&
#include &stdlib.h&
#include &string.h&
typedef struct
unsigned char bit_1 : 1;
unsigned char bit_2 : 1;
unsigned char bit_3 : 1;
unsigned char bit_4 : 1;
unsigned char bit_5 : 1;
unsigned char bit_6 : 1;
unsigned char bit_7 : 1;
unsigned char bit_8 : 1;
void Dec2Bin(int *a,char *b,int n=1) //将数据转换为N个字节,默认为1个字节
p_bit=(bit *)a;
for(j=n-1;j&=0;j--)
*b++=(p_bit+j)-&bit_8;
*b++=(p_bit+j)-&bit_7;
*b++=(p_bit+j)-&bit_6;
*b++=(p_bit+j)-&bit_5;
*b++=(p_bit+j)-&bit_4;
*b++=(p_bit+j)-&bit_3;
*b++=(p_bit+j)-&bit_2;
*b++=(p_bit+j)-&bit_1;
void StrTurn(char *str,int n=1) //将N个字节倒序排列,默认为1个字节
char *p,*q;
q=str+n*8-1;
while(p&q)
int main()
int a,i,n;
while(printf(&请输入要转换的数据和字节数:\n&),scanf(&%d%d&,&a,&n)!=0)
b=(char *)malloc(n*8+1);
memset(b,2,n*8+1);
Dec2Bin(&a,b,n);
printf(&%d的二进制形式为:\n&,a);
for(i=0;b[i]!=2;i++)
printf(&%d &,b[i]);
printf(&\n\n&);
StrTurn(b,n);
printf(&翻转后%d的二进制形式为:\n&,a);
for(i=0;b[i]!=2;i++)
printf(&%d &,b[i]);
printf(&\n\n\n&);
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有