只用位运算来实现整数的加减乘除四则运算 (转载,还没有来得及整理!!!!)
2016-08-18 15:27
615 查看
听同学百度二面中,不准用四则运算操作符来实现四则运算。一想就想到了计算机组成原理上学过的。位运算的思想可以应用到很多地方,这里简单的总结一下用位运算来实现整数的四则运算。
首先回忆计算机组成原理学过的内容,数字在机器ALU运算逻辑单元内部是以补码形式进行运算的,因为补码有两个优势:
1、能做到符号位和数值部分一起运算,这样无需单独考虑符号。
2、能把减法运算转化为加法运算来处理。
3、补码的没有正0和负0之分,所以表示范围比原码和反码多1个。
我们现在关注二进制加法。发现一个特点。
位的异或运算跟求'和'的结果一致:
异或 1^1=0 1^0=1 0^0=0
求和 1+1=0 1+0=1 0+0=0
位的与运算跟求'进位‘的结果一致:
位与 1&1=1 1&0=0 0&0=0
进位 1+1=1 1+0=0 0+0=0
于是我们决定用异或运算和与运算来表示加法。下面是两种形式的实现。
[cpp]
view plain
copy
int add(int a, int b) //递归形式
{
if(b==0) //递归结束条件:如果右加数为0,即不再有进位了,则结束。
return a;
int s = a^b;
int c = (a&b)<<1; //进位左移1位,达到进位的目的。
return add(s, c); //再把'和'和'进位'相加。递归实现。
}
[cpp]
view plain
copy
int add(int a, int b) //非递归形式
{
int s, c;
while(b != 0)
{
s = a^b;
c = (a&b)<<1;
a = s;
b = c;
}
return a;
}
于是有办法做减法了:先把减数求负,然后做加法。
[b][cpp]
view plain
copy
int negtive(int i)
{
return add(~i, 1);
}
[cpp]
view plain
copy
int subtraction(int a, int b) //减法运算:利用求负操作和加法操作
{
return add(a, negtive(b));
}
[cpp]
view plain
copy
int getsign(int i) //取一个数的符号,看是正还是负
{
return (i>>31);
}
int bepositive(int i) //将一个数变为正数,如果本来就是正,则不变;如果是负,则变为相反数。注意对于-2147483648,求负会溢出。
{
if(i>>31)
return negtive(i);
else
return i;
}
[cpp]
view plain
copy
int multiply(int a, int b)
{
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);//先把乘数和被乘数变为正数
b = bepositive(b);
int ans = 0;
while(b)
{
ans = add(ans, a);
b = subtraction(b, 1);
}
if(flag)
ans = negtive(ans);
return ans;
}
这一过程就是根据乘数的每一位为0或1时,将被乘数错位的加在积上。时间复杂度为O(logN)。
[cpp]
view plain
copy
int multiply(int a, int b)
{
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);
b = bepositive(b);
int ans = 0;
while(b)
{
if(b&1)
ans = add(ans, a);
a = (a<<1); //把a错位加在积上
b = (b>>1); //从最低位开始依次判断b的每一位
}
if(flag)
ans = negtive(ans);
return ans;
}
[cpp]
view plain
copy
int division(int a, int b)
{
if(b==0)
return 0;
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);
b = bepositive(b);
int n = 0;
a = subtraction(a, b);
while(a>=0)
{
n = add(n, 1);
a = subtraction(a, b);
}
if(flag)
n = negtive(n);
return n;
}
[cpp]
view plain
copy
int divide(int dividend, int divisor) {
bool flag = true;
if(getsign(dividend) == getsign(divisor)) //积的符号判定
flag = false;
unsigned int x = bepositive(dividend);
unsigned int y = bepositive(divisor);
int ans=0;
int i=31;
while(i>=0)
{
//比较x是否大于y*(1<<i)=(y<<i),避免直接比较,因为不确定y*(1<<i)是否溢出
if( (x>>i) >= y) //如果够减
{
ans = add(ans, (1<<i));
x = subtraction(x, (y<<i));
}
i = subtraction(i, 1);
}
if(flag)
ans = negtive(ans);
return ans;
}
注意细节:
1、注意考虑除法运算的特殊情况:除数不为0。
2、int整型的表示范围是-2147483648~+2147483647。所以在求负的时候,有一个数-2147483648是不可以求负的,因为int无法表示+2147483648这个数。对于乘法运算,如果出现了这个数,运算就会溢出。对于除法操作,如果被除数是-2147483648,那么不能直接求负。所以最好采用无符号数来进行运算。
3、2^31,2^30,......,64,32,16,8,4,2,1。为什么尝试用这样的倍数做减法就能把所有除数都减去呢?从二进制数的角度来看,这些权值就可以构成所有的整数,组成倍数不会有遗漏。从折半的思想来看,这样是一个逐步折半细化的过程。
有了上面的四则运算,再扩展别的运算就很容易了。
1、利用递归来代替循环结构;
2、利用&&与运算的特性来代替if结构。
[cpp]
view plain
copy
int add(int n, int &sum)
{
n && add(n-1, sum);
return (sum += n);
}
或者
[cpp]
view plain
copy
int sum(int n)
{
int k;
((1 == n)&&(k = 1)) || (k = sum(n-1) + n);
return k;
}
加法运算:
[cpp]
view plain
copy
int AddWithoutArithmetic(int num1,int num2)
{
if(num2==0) return num1;//没有进位的时候完成运算
int sum,carry;
sum=num1^num2;//完成第一步没有进位的加法运算
carry=(num1&num2)<<1;//完成第二步进位并且左移运算
return AddWithoutArithmetic(sum,carry);//进行递归,相加
}
简化一下:
[cpp]
view plain
copy
int Add(int a,int b)
{
return b ? Add(a^b,(a&b)<<1) : a;
/*if(b)
return Add(a^b,(a&b)<<1);
else
return a;*/
}
上面的思路就是先不计进位相加,然后再与进位相加,随着递归,进位会变为0,递归结束。
非递归的版本如下:
[cpp]
view plain
copy
int Add(int a, int b)
{
int ans;
while(b)
{ //直到没有进位
ans = a^b; //不带进位加法
b = ((a&b)<<1); //进位
a = ans;
}
return a;
}
减法运算:
[cpp]
view plain
copy
//这个和加法一样了,首先取减数的补码,然后相加。
int negtive(int a) //取补码
{
return Add(~a, 1);
}
int Sub(int a, int b)
{
return Add(a, negtive(b));
}
正数乘法运算:
[cpp]
view plain
copy
//正数乘法运算
int Pos_Multiply(int a,int b)
{
int ans = 0;
while(b)
{
if(b&1)
ans = Add(ans, a);
a = (a<<1);
b = (b>>1);
}
return ans;
}
整数除法(正整数)
[cpp]
view plain
copy
//除法就是由乘法的过程逆推,依次减掉(如果x够减的)y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。
int Pos_Div(int x,int y)
{
int ans=0;
for(int i=31;i>=0;i--)
{
//比较x是否大于y的(1<<i)次方,避免将x与(y<<i)比较,因为不确定y的(1<<i)次方是否溢出
if((x>>i)>=y)
{
ans+=(1<<i);
x-=(y<<i);
}
}
return ans;
}
完整的实现:
[cpp]
view plain
copy
// 加减乘除位运算
// 程序中实现了比较大小、加减乘除运算。所有运算都用位操作实现
// 在实现除法运算时,用了从高位到低位的减法
// 具体如下,算法也比较简单,所以没有作注释
#include<iostream>
#include<cstdio>
using namespace std;
int Add(int a, int b)
{
int ans;
while(b)
{ //直到没有进位
ans = a^b; //不带进位加法
b = ((a&b)<<1); //进位
a = ans;
}
return a;
}
//这个和加法一样了,首先取减数的补码,然后相加。
int negtive(int a) //取补码
{
return Add(~a, 1);
}
int Sub(int a, int b)
{
return Add(a, negtive(b));
}
// 判断正负
int ispos( int a )
{ //正
return (a&0xFFFF) && !(a&0x8000);
}
int isneg( int a )
{ //负
return a&0x8000;
}
int iszero( int a )
{ //0
return !(a&0xFFFF);
}
//正数乘法运算
int Pos_Multiply(int a,int b)
{
int ans = 0;
while(b)
{
if(b&1)
ans = Add(ans, a);
a = (a<<1);
b = (b>>1);
}
return ans;
}
//乘法运算
int Multiply(int a,int b)
{
if( iszero(a) || iszero(b) )
return 0;
if( ispos(a) && ispos(b) )
return Pos_Multiply(a, b);
if( isneg(a) )
{
if( isneg(b) )
{
return Pos_Multiply( negtive(a), negtive(b) );
}
return negtive( Pos_Multiply( negtive(a), b ) );
}
return negtive( Pos_Multiply(a, negtive(b)) );
}
//除法就是由乘法的过程逆推,依次减掉(如果x够减的)y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。
int Pos_Div(int x,int y)
{
int ans=0;
for(int i=31;i>=0;i--)
{
//比较x是否大于y的(1<<i)次方,避免将x与(y<<i)比较,因为不确定y的(1<<i)次方是否溢出
if((x>>i)>=y)
{
ans+=(1<<i);
x-=(y<<i);
}
}
return ans;
}
//除法运算
int MyDiv( int a, int b )
{
if( iszero(b) )
{
cout << "Error" << endl;
exit(1);
}
if( iszero(a) )
return 0;
if( ispos(a) )
{
if( ispos(b) )
return Pos_Div(a, b);
return negtive( Pos_Div( a, negtive(b)) );
}
if( ispos(b) )
return negtive( Pos_Div( negtive(a), b ) );
return Pos_Div( negtive(a), negtive(b) );
}
// 比较两个正数的大小(非负也可)
int isbig_pos( int a, int b )
{ //a>b>0
int c = 1;
b = (a^b);
if( iszero(b) )
return 0;
while( b >>= 1 )
{
c <<= 1;
}
return (c&a);
}
// 比较两个数的大小
int isbig( int a, int b )
{ //a>b
if( isneg(a) )
{
if( isneg(b) )
{
return isbig_pos( negtive(b), negtive(a) );
}
return 0;
}
if( isneg(b) )
return 1;
return isbig_pos(a, b);
}
扩展:在不使用*、/、+、-、%操作符的情况下,如何求一个数的1/3?(用C语言实现)
使用位操作符并实现“+”操作
[cpp]
view plain
copy
// 替换加法运算符
int add(int x , int y)
{
int res;
while(y) // 直到没有进位 http://blog.csdn.net/ojshilu/article/details/11179911
{
res = x^y; // 不带进位的加法
y = ((x&y)<<1); // 进位
x = res;
}
return x;
}
int divideby3(int num)
{
int sum = 0;
while(num > 3)
{
sum = add(num>>2 , sum);
num = add(num>>2 , num&3);
}
if(num == 3)
sum = add(sum , 1);
return sum;
}
原理:n = 4 * a + b; n / 3 = a + (a + b) / 3; 然后 sum += a, n = a + b 并迭代; 当 a == 0 (n < 4)时,sum += floor(n / 3); i.e. 1, if n == 3, else 0
本文转载:http://blog.csdn.net/ojshilu/article/details/11179911
http://blog.csdn.net/hackbuteer1/article/details/7390093
首先回忆计算机组成原理学过的内容,数字在机器ALU运算逻辑单元内部是以补码形式进行运算的,因为补码有两个优势:
1、能做到符号位和数值部分一起运算,这样无需单独考虑符号。
2、能把减法运算转化为加法运算来处理。
3、补码的没有正0和负0之分,所以表示范围比原码和反码多1个。
问题一: 位运算实现加法
不管是十进制加法还是二进制加法,其加的的过程在每一位看分为‘和’、‘进位’两个部分。‘和’要留在当前位,‘进位’加入到下一位。我们现在关注二进制加法。发现一个特点。
位的异或运算跟求'和'的结果一致:
异或 1^1=0 1^0=1 0^0=0
求和 1+1=0 1+0=1 0+0=0
位的与运算跟求'进位‘的结果一致:
位与 1&1=1 1&0=0 0&0=0
进位 1+1=1 1+0=0 0+0=0
于是我们决定用异或运算和与运算来表示加法。下面是两种形式的实现。
[cpp]
view plain
copy
int add(int a, int b) //递归形式
{
if(b==0) //递归结束条件:如果右加数为0,即不再有进位了,则结束。
return a;
int s = a^b;
int c = (a&b)<<1; //进位左移1位,达到进位的目的。
return add(s, c); //再把'和'和'进位'相加。递归实现。
}
[cpp]
view plain
copy
int add(int a, int b) //非递归形式
{
int s, c;
while(b != 0)
{
s = a^b;
c = (a&b)<<1;
a = s;
b = c;
}
return a;
}
问题二: 位运算实现减法
减法其实是用加法来实现的。在ALU中,当我求a-b,其实是求[a-b]补。因为有[a-b]补=[a]补 - 补= [a]补+[-b]补。所以我就要先求出-b。求一个数的负的操作是将其连符号位一起取反然后加1。于是有办法做减法了:先把减数求负,然后做加法。
[b][cpp]
view plain
copy
int negtive(int i)
{
return add(~i, 1);
}
[cpp]
view plain
copy
int subtraction(int a, int b) //减法运算:利用求负操作和加法操作
{
return add(a, negtive(b));
}
问题三: 位运算实现乘法
乘法操作时即使用补码也要需要考虑符号位了,所以我要先把符号拿出来单独计算。为了方便,先引入两个工具函数,[cpp]
view plain
copy
int getsign(int i) //取一个数的符号,看是正还是负
{
return (i>>31);
}
int bepositive(int i) //将一个数变为正数,如果本来就是正,则不变;如果是负,则变为相反数。注意对于-2147483648,求负会溢出。
{
if(i>>31)
return negtive(i);
else
return i;
}
做乘法的第一种思路:
很直观,就是用循环加法替代乘法。a*b,就是把a累加b次。时间复杂度为O(N)。[cpp]
view plain
copy
int multiply(int a, int b)
{
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);//先把乘数和被乘数变为正数
b = bepositive(b);
int ans = 0;
while(b)
{
ans = add(ans, a);
b = subtraction(b, 1);
}
if(flag)
ans = negtive(ans);
return ans;
}
做乘法的第二种思路:
在二进制数上做乘法,如下图:这一过程就是根据乘数的每一位为0或1时,将被乘数错位的加在积上。时间复杂度为O(logN)。
[cpp]
view plain
copy
int multiply(int a, int b)
{
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);
b = bepositive(b);
int ans = 0;
while(b)
{
if(b&1)
ans = add(ans, a);
a = (a<<1); //把a错位加在积上
b = (b>>1); //从最低位开始依次判断b的每一位
}
if(flag)
ans = negtive(ans);
return ans;
}
问题四: 位运算实现除法
做除法的第一种思路:
也比较直观,从被除数上减去除数,看能减多少次之后变得不够减。时间复杂度为O(N)。[cpp]
view plain
copy
int division(int a, int b)
{
if(b==0)
return 0;
bool flag = true;
if(getsign(a) == getsign(b)) //积的符号判定
flag = false;
a = bepositive(a);
b = bepositive(b);
int n = 0;
a = subtraction(a, b);
while(a>=0)
{
n = add(n, 1);
a = subtraction(a, b);
}
if(flag)
n = negtive(n);
return n;
}
做除法的第二种思路:
第一种方法实在太慢了。减法得减的快一些,不能一个一个减,于是采用类似二分法的思路,从除数*最大倍数开始测试,如果比被除数小,则要减去。下一回让除数的倍数减少为上一次倍数的一半,这样的直到倍数为1时,就能把被除数中所有的除数减去,并得到商。时间复杂度降低到O(logN)。[cpp]
view plain
copy
int divide(int dividend, int divisor) {
bool flag = true;
if(getsign(dividend) == getsign(divisor)) //积的符号判定
flag = false;
unsigned int x = bepositive(dividend);
unsigned int y = bepositive(divisor);
int ans=0;
int i=31;
while(i>=0)
{
//比较x是否大于y*(1<<i)=(y<<i),避免直接比较,因为不确定y*(1<<i)是否溢出
if( (x>>i) >= y) //如果够减
{
ans = add(ans, (1<<i));
x = subtraction(x, (y<<i));
}
i = subtraction(i, 1);
}
if(flag)
ans = negtive(ans);
return ans;
}
注意细节:
1、注意考虑除法运算的特殊情况:除数不为0。
2、int整型的表示范围是-2147483648~+2147483647。所以在求负的时候,有一个数-2147483648是不可以求负的,因为int无法表示+2147483648这个数。对于乘法运算,如果出现了这个数,运算就会溢出。对于除法操作,如果被除数是-2147483648,那么不能直接求负。所以最好采用无符号数来进行运算。
3、2^31,2^30,......,64,32,16,8,4,2,1。为什么尝试用这样的倍数做减法就能把所有除数都减去呢?从二进制数的角度来看,这些权值就可以构成所有的整数,组成倍数不会有遗漏。从折半的思想来看,这样是一个逐步折半细化的过程。
有了上面的四则运算,再扩展别的运算就很容易了。
附加问题:只用加法实现1+2+3+...+n,
(循环、判断语句也不用)1、利用递归来代替循环结构;
2、利用&&与运算的特性来代替if结构。
[cpp]
view plain
copy
int add(int n, int &sum)
{
n && add(n-1, sum);
return (sum += n);
}
或者
[cpp]
view plain
copy
int sum(int n)
{
int k;
((1 == n)&&(k = 1)) || (k = sum(n-1) + n);
return k;
}
加法运算:
[cpp]
view plain
copy
int AddWithoutArithmetic(int num1,int num2)
{
if(num2==0) return num1;//没有进位的时候完成运算
int sum,carry;
sum=num1^num2;//完成第一步没有进位的加法运算
carry=(num1&num2)<<1;//完成第二步进位并且左移运算
return AddWithoutArithmetic(sum,carry);//进行递归,相加
}
简化一下:
[cpp]
view plain
copy
int Add(int a,int b)
{
return b ? Add(a^b,(a&b)<<1) : a;
/*if(b)
return Add(a^b,(a&b)<<1);
else
return a;*/
}
上面的思路就是先不计进位相加,然后再与进位相加,随着递归,进位会变为0,递归结束。
非递归的版本如下:
[cpp]
view plain
copy
int Add(int a, int b)
{
int ans;
while(b)
{ //直到没有进位
ans = a^b; //不带进位加法
b = ((a&b)<<1); //进位
a = ans;
}
return a;
}
减法运算:
[cpp]
view plain
copy
//这个和加法一样了,首先取减数的补码,然后相加。
int negtive(int a) //取补码
{
return Add(~a, 1);
}
int Sub(int a, int b)
{
return Add(a, negtive(b));
}
正数乘法运算:
[cpp]
view plain
copy
//正数乘法运算
int Pos_Multiply(int a,int b)
{
int ans = 0;
while(b)
{
if(b&1)
ans = Add(ans, a);
a = (a<<1);
b = (b>>1);
}
return ans;
}
整数除法(正整数)
[cpp]
view plain
copy
//除法就是由乘法的过程逆推,依次减掉(如果x够减的)y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。
int Pos_Div(int x,int y)
{
int ans=0;
for(int i=31;i>=0;i--)
{
//比较x是否大于y的(1<<i)次方,避免将x与(y<<i)比较,因为不确定y的(1<<i)次方是否溢出
if((x>>i)>=y)
{
ans+=(1<<i);
x-=(y<<i);
}
}
return ans;
}
完整的实现:
[cpp]
view plain
copy
// 加减乘除位运算
// 程序中实现了比较大小、加减乘除运算。所有运算都用位操作实现
// 在实现除法运算时,用了从高位到低位的减法
// 具体如下,算法也比较简单,所以没有作注释
#include<iostream>
#include<cstdio>
using namespace std;
int Add(int a, int b)
{
int ans;
while(b)
{ //直到没有进位
ans = a^b; //不带进位加法
b = ((a&b)<<1); //进位
a = ans;
}
return a;
}
//这个和加法一样了,首先取减数的补码,然后相加。
int negtive(int a) //取补码
{
return Add(~a, 1);
}
int Sub(int a, int b)
{
return Add(a, negtive(b));
}
// 判断正负
int ispos( int a )
{ //正
return (a&0xFFFF) && !(a&0x8000);
}
int isneg( int a )
{ //负
return a&0x8000;
}
int iszero( int a )
{ //0
return !(a&0xFFFF);
}
//正数乘法运算
int Pos_Multiply(int a,int b)
{
int ans = 0;
while(b)
{
if(b&1)
ans = Add(ans, a);
a = (a<<1);
b = (b>>1);
}
return ans;
}
//乘法运算
int Multiply(int a,int b)
{
if( iszero(a) || iszero(b) )
return 0;
if( ispos(a) && ispos(b) )
return Pos_Multiply(a, b);
if( isneg(a) )
{
if( isneg(b) )
{
return Pos_Multiply( negtive(a), negtive(b) );
}
return negtive( Pos_Multiply( negtive(a), b ) );
}
return negtive( Pos_Multiply(a, negtive(b)) );
}
//除法就是由乘法的过程逆推,依次减掉(如果x够减的)y^(2^31),y^(2^30),...y^8,y^4,y^2,y^1。减掉相应数量的y就在结果加上相应的数量。
int Pos_Div(int x,int y)
{
int ans=0;
for(int i=31;i>=0;i--)
{
//比较x是否大于y的(1<<i)次方,避免将x与(y<<i)比较,因为不确定y的(1<<i)次方是否溢出
if((x>>i)>=y)
{
ans+=(1<<i);
x-=(y<<i);
}
}
return ans;
}
//除法运算
int MyDiv( int a, int b )
{
if( iszero(b) )
{
cout << "Error" << endl;
exit(1);
}
if( iszero(a) )
return 0;
if( ispos(a) )
{
if( ispos(b) )
return Pos_Div(a, b);
return negtive( Pos_Div( a, negtive(b)) );
}
if( ispos(b) )
return negtive( Pos_Div( negtive(a), b ) );
return Pos_Div( negtive(a), negtive(b) );
}
// 比较两个正数的大小(非负也可)
int isbig_pos( int a, int b )
{ //a>b>0
int c = 1;
b = (a^b);
if( iszero(b) )
return 0;
while( b >>= 1 )
{
c <<= 1;
}
return (c&a);
}
// 比较两个数的大小
int isbig( int a, int b )
{ //a>b
if( isneg(a) )
{
if( isneg(b) )
{
return isbig_pos( negtive(b), negtive(a) );
}
return 0;
}
if( isneg(b) )
return 1;
return isbig_pos(a, b);
}
扩展:在不使用*、/、+、-、%操作符的情况下,如何求一个数的1/3?(用C语言实现)
使用位操作符并实现“+”操作
[cpp]
view plain
copy
// 替换加法运算符
int add(int x , int y)
{
int res;
while(y) // 直到没有进位 http://blog.csdn.net/ojshilu/article/details/11179911
{
res = x^y; // 不带进位的加法
y = ((x&y)<<1); // 进位
x = res;
}
return x;
}
int divideby3(int num)
{
int sum = 0;
while(num > 3)
{
sum = add(num>>2 , sum);
num = add(num>>2 , num&3);
}
if(num == 3)
sum = add(sum , 1);
return sum;
}
原理:n = 4 * a + b; n / 3 = a + (a + b) / 3; 然后 sum += a, n = a + b 并迭代; 当 a == 0 (n < 4)时,sum += floor(n / 3); i.e. 1, if n == 3, else 0
本文转载:http://blog.csdn.net/ojshilu/article/details/11179911
http://blog.csdn.net/hackbuteer1/article/details/7390093
相关文章推荐
- 只用位运算来实现整数的加减乘除四则运算
- 正整数加减乘除四则混合运算求值方法 java实现
- 只用位运算来实现整数的加减乘除四则运算
- 只用位运算实现整数的加减乘除运算
- 只用位运算实现整数的加减乘除运算
- 用位运算实现两个整数的加减乘除运算
- linux shell 实现 四则运算(整数及浮点) 简单方法
- 用位运算实现四则运算之加减乘除
- inux shell 实现 四则运算(整数及浮点) 简单方法
- 使用“位运算”实现“四则运算”之加减乘除
- linux shell 实现 四则运算(整数及浮点) 简单方法
- 大整数四则运算算法与实现(C++)
- 用位运算实现四则运算之加减乘除(用位运算求一个数的1/3)
- java实现大整数的四则运算
- 用位运算实现四则运算之加减乘除
- 大整数类的实现包含了加减乘除运算
- 位运算---只使用位运算实现整数的加减乘除
- 位运算实现整数的加减乘除
- LeetCode主题整理(3)实现加减乘除运算
- 算法--两种方法实现一个Add函数,让两个整数相加,但是不能使用+、-、*、/等四则运算符。