blocks|key|119454|text|在C中，使用按位运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119455|#include<stdio.h>

int+add(int+x,+int+y)+{
++++int+a,+b;
++++do+{
++++++++a+=+x+&+y;
++++++++b+=+x+%5E+y;
++++++++x+=+a+<<+1;
++++++++y+=+b;
++++}+while+(a);
++++return+b;
}


int+main(+void+){
++++printf(+"2+%2B+3+=+%25d",+add(2,3));
++++return+0;
}|code-block|syntax|javascript|119456|异或(x+%5E+y)是不带进位的加法。(x+&+y)是每一位的进位输出。(x+&+y)+<<+1是每一位的进位输入。|offset|length|style|CODE|119457|循环不断增加进位，直到所有位的进位都为零。|119458|entityMap^0|0|0|3|5|I|7|Z|C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|P|$]]

In C, with bitwise operators:

<pre class="lang-c prettyprint-override"><code>#include&lt;stdio.h&gt;

int add(int x, int y) {
 int a, b;
 do {
 a = x &amp; y;
 b = x ^ y;
 x = a &lt;&lt; 1;
 y = b;
 } while (a);
 return b;
}


int main( void ){
 printf( "2 + 3 = %d", add(2,3));
 return 0;
}
</code></pre>

XOR (<code>x ^ y</code>) is addition without carry. <code>(x &amp; y)</code> is the carry-out from each bit. <code>(x &amp; y) &lt;&lt; 1</code> is the carry-in to each bit.

The loop keeps adding the carries until the carry is zero for all bits.

blocks|key|921924|text|int+add(int+a,+int+b)+{
+++const+char+*c=0;
+++return+&(&c[a])[b];
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|921925|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int add(int a, int b) {
 const char *c=0;
 return &amp;(&amp;c[a])[b];
}
</code></pre>

blocks|key|119595|text|不是吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119596|int+add(int+a,+int+b)+
{
+++return+-(-a)+-+(-b);
}|code-block|syntax|javascript|119597|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

No + right?

<pre><code>int add(int a, int b) 
{
 return -(-a) - (-b);
}
</code></pre>

blocks|key|921893|text|定义“最好”。这是一个python版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|921894|len(range(x)%2Brange(y))|code-block|syntax|javascript|921895|%2B执行列表连接，而不是加法。|offset|length|style|CODE|921896|entityMap^0|0|0|0|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Define "best". Here's a python version:

<pre><code>len(range(x)+range(y))
</code></pre>

The <code>+</code> performs list concatenation, not addition.

blocks|key|3337590|text|CMS的add()函数很漂亮。它不应该被一元否定所污染(非位操作，等同于使用加法：-y==(~y)%2B1)。下面是一个减法函数，它使用了相同的仅按位设计：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3337591|int+sub(int+x,+int+y)+{
++++unsigned+a,+b;
++++do+{
++++++++a+=+~x+&+y;
++++++++b+=++x+%5E+y;
++++++++x+=+b;
++++++++y+=+a+<<+1;
++++}+while+(a);
++++return+b;
}|code-block|syntax|javascript|3337592|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

CMS's add() function is beautiful. It should not be sullied by unary negation (a non-bitwise operation, tantamount to using addition: -y==(~y)+1). So here's a subtraction function using the same bitwise-only design:

<pre><code>int sub(int x, int y) {
 unsigned a, b;
 do {
 a = ~x &amp; y;
 b = x ^ y;
 x = b;
 y = a &lt;&lt; 1;
 } while (a);
 return b;
}
</code></pre>

blocks|key|119410|text|作弊。您可以将该数字取反，然后从第一个数字中减去它:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119411|如果做不到这一点，请查看二进制加法器是如何工作的。:)|119412|编辑:啊，我发帖后看到你的评论了。|119413|有关二进制加法的详细信息，请参阅here。|offset|length|119414|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Two%2527s_complement#Addition^0|0|0|0|G|4|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@$H|V|I|W|1|X]]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

Cheat. You could negate the number and subtract it from the first :)

Failing that, look up how a binary adder works. :)

EDIT: Ah, saw your comment after I posted.

Details of binary addition are <a href="https://en.wikipedia.org/wiki/Two%27s_complement#Addition" rel="nofollow noreferrer">here</a>.

blocks|key|119573|text|请注意，这适用于被称为ripple-carry+adder的加法器，它可以工作，但性能不是最优的。大多数内置于硬件中的二进制加法器都是某种形式的快速加法器，例如carry-look-ahead+adder。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|119574|如果您将carry_in设置为0，我的波纹进位加法器适用于无符号整数和2的补码整数，如果carry_in设置为1，则适用于1的补码整数。我还添加了标志来显示加法时的下溢或溢出。|119575|#define+BIT_LEN+32
#define+ADD_OK+0
#define+ADD_UNDERFLOW+1
#define+ADD_OVERFLOW+2

int+ripple_add(int+a,+int+b,+char+carry_in,+char*+flags)+{
++++int+result+=+0;
++++int+current_bit_position+=+0;
++++char+a_bit+=+0,+b_bit+=+0,+result_bit+=+0;

++++while+((a+%7C%7C+b)+&&+current_bit_position+<+BIT_LEN)+{
++++++++a_bit+=+a+&+1;
++++++++b_bit+=+b+&+1;
++++++++result_bit+=+(a_bit+%5E+b_bit+%5E+carry_in);
++++++++result+%7C=+result_bit+<<+current_bit_position%2B%2B;
++++++++carry_in+=+(a_bit+&+b_bit)+%7C+(a_bit+&+carry_in)+%7C+(b_bit+&+carry_in);
++++++++a+>>=+1;
++++++++b+>>=+1;
++++}

++++if+(current_bit_position+<+BIT_LEN)+{
++++++++*flags+=+ADD_OK;
++++}
++++else+if+(a_bit+&+b_bit+&+~result_bit)+{
++++++++*flags+=+ADD_UNDERFLOW;
++++}
++++else+if+(~a_bit+&+~b_bit+&+result_bit)+{
++++++++*flags+=+ADD_OVERFLOW;
++++}
++++else+{
++++++++*flags+=+ADD_OK;
++++}

++++return+result;
}|code-block|syntax|javascript|119576|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Adder_(electronics)#Ripple-carry_adder)|1|https://en.wikipedia.org/wiki/Carry-lookahead_adder^0|B|I|0|28|M|1|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

Note, this would be for an adder known as a <a href="https://en.wikipedia.org/wiki/Adder_(electronics)#Ripple-carry_adder" rel="nofollow noreferrer">ripple-carry adder</a>, which works, but does not perform optimally. Most binary adders built into hardware are a form of fast adder such as a <a href="https://en.wikipedia.org/wiki/Carry-lookahead_adder" rel="nofollow noreferrer">carry-look-ahead adder</a>.

My ripple-carry adder works for both unsigned and 2's complement integers if you set carry_in to 0, and 1's complement integers if carry_in is set to 1. I also added flags to show underflow or overflow on the addition.

<pre class="lang-c prettyprint-override"><code>#define BIT_LEN 32
#define ADD_OK 0
#define ADD_UNDERFLOW 1
#define ADD_OVERFLOW 2

int ripple_add(int a, int b, char carry_in, char* flags) {
 int result = 0;
 int current_bit_position = 0;
 char a_bit = 0, b_bit = 0, result_bit = 0;

 while ((a || b) &amp;&amp; current_bit_position &lt; BIT_LEN) {
 a_bit = a &amp; 1;
 b_bit = b &amp; 1;
 result_bit = (a_bit ^ b_bit ^ carry_in);
 result |= result_bit &lt;&lt; current_bit_position++;
 carry_in = (a_bit &amp; b_bit) | (a_bit &amp; carry_in) | (b_bit &amp; carry_in);
 a &gt;&gt;= 1;
 b &gt;&gt;= 1;
 }

 if (current_bit_position &lt; BIT_LEN) {
 *flags = ADD_OK;
 }
 else if (a_bit &amp; b_bit &amp; ~result_bit) {
 *flags = ADD_UNDERFLOW;
 }
 else if (~a_bit &amp; ~b_bit &amp; result_bit) {
 *flags = ADD_OVERFLOW;
 }
 else {
 *flags = ADD_OK;
 }

 return result;
}
</code></pre>

blocks|key|3337799|text|使用位运算符的Java解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3337800|//+Recursive+solution
public+static+int+addR(int+x,+int+y)+{

++++if+(y+==+0)+return+x;
++++int+sum+=+x+%5E+y;+//SUM+of+two+integer+is+X+XOR+Y
++++int+carry+=+(x+&+y)+<<+1;++//CARRY+of+two+integer+is+X+AND+Y
++++return+addR(sum,+carry);
}

//Iterative+solution
public+static+int+addI(int+x,+int+y)+{

++++while+(y+!=+0)+{
++++++++int+carry+=+(x+&+y);+//CARRY+is+AND+of+two+bits
++++++++x+=+x+%5E+y;+//SUM+of+two+bits+is+X+XOR+Y
++++++++y+=+carry+<<+1;+//shifts+carry+to+1+bit+to+calculate+sum
++++}
++++return+x;
}|code-block|syntax|javascript|3337801|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Java solution with bitwise operators:

<pre><code>// Recursive solution
public static int addR(int x, int y) {

 if (y == 0) return x;
 int sum = x ^ y; //SUM of two integer is X XOR Y
 int carry = (x &amp; y) &lt;&lt; 1; //CARRY of two integer is X AND Y
 return addR(sum, carry);
}

//Iterative solution
public static int addI(int x, int y) {

 while (y != 0) {
 int carry = (x &amp; y); //CARRY is AND of two bits
 x = x ^ y; //SUM of two bits is X XOR Y
 y = carry &lt;&lt; 1; //shifts carry to 1 bit to calculate sum
 }
 return x;
}
</code></pre>

blocks|key|120003|text|基于Go的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|120004|func+add(a+int,+b+int)+int+{

for+{
++++carry+:=+(a+&+b)+<<+1
++++a+=+a+%5E+b
++++b+=+carry+
++++if+b+==+0+{
++++++++break
++++}
}

return+a+

}|code-block|syntax|javascript|120005|同样的解决方案可以在Python中实现，如下所示，但Python中的数字表示存在一些问题，Python中的整数超过32位。因此，我们将使用掩码来获取最后32位。|120006|例如:如果我们不使用掩码，我们将不会得到数字(-1,1)的结果。|120007|def+add(a,b):+++
++++mask+=+0xffffffff

++++while+b+&+mask:
++++++++carry+=+a+&+b
++++++++a+=+a+%5E+b
++++++++b+=+carry+<<+1

++++return+(a+&+mask)|120008|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Go based solution

<pre><code>func add(a int, b int) int {

for {
 carry := (a &amp; b) &lt;&lt; 1
 a = a ^ b
 b = carry 
 if b == 0 {
 break
 }
}

return a 

}
</code></pre>

same solution can be implemented in Python as follows, but there is some problem about number represent in Python, Python has more than 32 bits for integers. so we will use a mask to obtain the last 32 bits. 

Eg: if we don't use mask we won't get the result for numbers (-1,1)

<pre><code>def add(a,b): 
 mask = 0xffffffff

 while b &amp; mask:
 carry = a &amp; b
 a = a ^ b
 b = carry &lt;&lt; 1

 return (a &amp; mask)
</code></pre>

blocks|key|119379|text|为什么不像第二个数字一样频繁地递增满足第一个数字呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119380|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Why not just incremet the first number as often, as the second number?

blocks|key|3337441|text|在汇编程序中，加法被实现为单条指令，而不是位操作的某种组合，原因是它很难实现。你必须担心从一个给定的低位到下一个高位的进位。这是机器在硬件中快速完成的东西，但即使用C语言，你也不能在软件中快速完成。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3337442|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The reason ADD is implememted in assembler as a single instruction, rather than as some combination of bitwise operations, is that it is hard to do. You have to worry about the carries from a given low order bit to the next higher order bit. This is stuff that the machines do in hardware fast, but that even with C, you can't do in software fast.

blocks|key|4183294|text|这是一个可移植的单行、三元和递归解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4183295|int+add(int+x,+int+y)+{
++++return+y+==+0+?+x+:+add(x+%5E+y,+(x+&+y)+<<+1);
}|code-block|syntax|javascript|4183296|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a portable one-line ternary and recursive solution. 

<pre><code>int add(int x, int y) {
 return y == 0 ? x : add(x ^ y, (x &amp; y) &lt;&lt; 1);
}
</code></pre>

blocks|key|3337667|text|在编码面试中，我认为这是问题18.1。我的python解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3337668|def+foo(a,+b):
"""iterate+through+a+and+b,+count+iteration+via+a+list,+check+len"""
++++x+=+[]
++++for+i+in+range(a):
++++++++++++x.append(a)
++++for+i+in+range(b):
++++++++++++x.append(b)
++++print+len(x)|code-block|syntax|javascript|3337669|这种方法使用迭代，因此时间复杂度不是最优的。我认为最好的方法是在较低的级别上使用按位操作。|3337670|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I saw this as problem 18.1 in the coding interview.
My python solution:

<pre class="lang-py prettyprint-override"><code>def foo(a, b):
"""iterate through a and b, count iteration via a list, check len"""
 x = []
 for i in range(a):
 x.append(a)
 for i in range(b):
 x.append(b)
 print len(x)
</code></pre>

This method uses iteration, so the time complexity isn't optimal.
I believe the best way is to work at a lower level with bitwise operations.

blocks|key|4183279|text|在python中使用位运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4183280|def+sum_no_arithmetic_operators(x,y):
++++while+True:
++++++++carry+=+x+&+y
++++++++x+=+x+%5E+y
++++++++y+=+carry+<<+1
++++++++if+y+==+0:
++++++++++++break
++++return+x|code-block|syntax|javascript|4183281|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In python using bitwise operators:

<pre><code>def sum_no_arithmetic_operators(x,y):
 while True:
 carry = x &amp; y
 x = x ^ y
 y = carry &lt;&lt; 1
 if y == 0:
 break
 return x
</code></pre>

blocks|key|119537|text|将两个整数相加并不是那么困难；在线上有很多二进制加法的例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119538|一个更具挑战性的问题是浮点数！在http://pages.cs.wisc.edu/~smoler/x86text/lect.notes/arith.flpt.html上有一个例子|offset|length|119539|entityMap|0|LINK|mutability|MUTABLE|url|http://pages.cs.wisc.edu/~smoler/x86text/lect.notes/arith.flpt.html^0|0|G|1V|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Adding two integers is not that difficult; there are many examples of binary addition online.

A more challenging problem is floating point numbers! There's an example at <a href="http://pages.cs.wisc.edu/~smoler/x86text/lect.notes/arith.flpt.html" rel="nofollow noreferrer">http://pages.cs.wisc.edu/~smoler/x86text/lect.notes/arith.flpt.html</a>

blocks|key|119695|text|您可以使用位移位和and运算来完成此操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119696|#include+<stdio.h>

int+main()
{
++++unsigned+int+x+=+3,+y+=+1,+sum,+carry;
++++sum+=+x+%5E+y;+//+Ex+-+OR+x+and+y
++++carry+=+x+&+y;+//+AND+x+and+y
++++while+(carry+!=+0)+{
++++++++carry+=+carry+<<+1;+//+left+shift+the+carry
++++++++x+=+sum;+//+initialize+x+as+sum
++++++++y+=+carry;+//+initialize+y+as+carry
++++++++sum+=+x+%5E+y;+//+sum+is+calculated
++++++++carry+=+x+&+y;+/*+carry+is+calculated,+the+loop+condition+is
++++++++++++++++++++++++evaluated+and+the+process+is+repeated+until
++++++++++++++++++++++++carry+is+equal+to+0.
++++++++++++++++++++++++*/
++++}
++++printf("%25d\n",+sum);+//+the+program+will+print+4
++++return+0;
}|code-block|syntax|javascript|119697|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can do it using bit-shifting and the AND operation. 

<pre class="lang-c prettyprint-override"><code>#include &lt;stdio.h&gt;

int main()
{
 unsigned int x = 3, y = 1, sum, carry;
 sum = x ^ y; // Ex - OR x and y
 carry = x &amp; y; // AND x and y
 while (carry != 0) {
 carry = carry &lt;&lt; 1; // left shift the carry
 x = sum; // initialize x as sum
 y = carry; // initialize y as carry
 sum = x ^ y; // sum is calculated
 carry = x &amp; y; /* carry is calculated, the loop condition is
 evaluated and the process is repeated until
 carry is equal to 0.
 */
 }
 printf("%d\n", sum); // the program will print 4
 return 0;
}
</code></pre>

blocks|key|921978|text|实现的方式与我们在纸上进行二进制加法的方式相同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|921979|int+add(int+x,+int+y)
{
++++int+t1_set,+t2_set;
++++int+carry+=+0;
++++int+result+=+0;
++++int+mask+=+0x1;

++++while+(mask+!=+0)+{
++++++++t1_set+=+x+&+mask;
++++++++t2_set+=+y+&+mask;
++++++++if+(carry)+{
+++++++++++if+(!t1_set+&&+!t2_set)+{
+++++++++++++++carry+=+0;
+++++++++++++++result+%7C=+mask;
+++++++++++}+else+if+(t1_set+&&+t2_set)+{
+++++++++++++++result+%7C=+mask;
+++++++++++}
++++++++}+else+{
+++++++++++if+((t1_set+&&+!t2_set)+%7C%7C+(!t1_set+&&+t2_set))+{
++++++++++++++++result+%7C=+mask;
+++++++++++}+else+if+(t1_set+&&+t2_set)+{
++++++++++++++++carry+=+1;
+++++++++++}
++++++++}
++++++++mask+<<=+1;
++++}
++++return+(result);
}|code-block|syntax|javascript|921980|速度方面的改进如下：|921981|int+add_better+(int+x,+int+y)
{
++int+b1_set,+b2_set;
++int+mask+=+0x1;
++int+result+=+0;
++int+carry+=+0;

++while+(mask+!=+0)+{
++++++b1_set+=+x+&+mask+?+1+:+0;
++++++b2_set+=+y+&+mask+?+1+:+0;
++++++if+(+(b1_set+%5E+b2_set)+%5E+carry)
++++++++++result+%7C=+mask;
++++++carry+=+(b1_set+&++b2_set)+%7C+(b1_set+&+carry)+%7C+(b2_set+&+carry);
++++++mask+<<=+1;
++}
++return+(result);
}|921982|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Implemented in same way as we might do binary addition on paper.



<pre class="lang-c prettyprint-override"><code>int add(int x, int y)
{
 int t1_set, t2_set;
 int carry = 0;
 int result = 0;
 int mask = 0x1;

 while (mask != 0) {
 t1_set = x &amp; mask;
 t2_set = y &amp; mask;
 if (carry) {
 if (!t1_set &amp;&amp; !t2_set) {
 carry = 0;
 result |= mask;
 } else if (t1_set &amp;&amp; t2_set) {
 result |= mask;
 }
 } else {
 if ((t1_set &amp;&amp; !t2_set) || (!t1_set &amp;&amp; t2_set)) {
 result |= mask;
 } else if (t1_set &amp;&amp; t2_set) {
 carry = 1;
 }
 }
 mask &lt;&lt;= 1;
 }
 return (result);
}
</code></pre>

Improved for speed would be below::

<pre class="lang-c prettyprint-override"><code>int add_better (int x, int y)
{
 int b1_set, b2_set;
 int mask = 0x1;
 int result = 0;
 int carry = 0;

 while (mask != 0) {
 b1_set = x &amp; mask ? 1 : 0;
 b2_set = y &amp; mask ? 1 : 0;
 if ( (b1_set ^ b2_set) ^ carry)
 result |= mask;
 carry = (b1_set &amp; b2_set) | (b1_set &amp; carry) | (b2_set &amp; carry);
 mask &lt;&lt;= 1;
 }
 return (result);
}
</code></pre>

blocks|key|3337722|text|我自己在C#中解决这个问题，并不能让所有的测试用例都通过。然后我遇到了this。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3337723|下面是C#+6中的一个实现：|3337724|public+int+Sum(int+a,+int+b)+=>+b+!=+0+?+Sum(a+%5E+b,+(a+&+b)+<<+1)+:+a;|code-block|syntax|javascript|3337725|entityMap|0|LINK|mutability|MUTABLE|url|http://www.geeksforgeeks.org/add-two-numbers-without-using-arithmetic-operators/^0|Z|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Was working on this problem myself in C# and couldn't get all test cases to pass. I then ran across <a href="http://www.geeksforgeeks.org/add-two-numbers-without-using-arithmetic-operators/" rel="nofollow">this</a>.

Here is an implementation in C# 6:

<pre><code>public int Sum(int a, int b) =&gt; b != 0 ? Sum(a ^ b, (a &amp; b) &lt;&lt; 1) : a;
</code></pre>

blocks|key|119856|text|这是我在Python上的实现。当我们知道字节(或位)的数量时，它工作得很好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|119857|def+summ(a,+b):
++++#for+4+bytes(or+4*8+bits)
++++max_num+=+0xFFFFFFFF
++++while+a+!=+0:
++++++++a,+b+=+((a+&+b)+<<+1),++(a+%5E+b)
++++++++if+a+>+max_num:
++++++++++++b+=+(b&max_num)+
++++++++++++break
++++return+b|code-block|syntax|javascript|119858|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It is my implementation on Python. It works well, when we know the number of bytes(or bits).

<pre class="lang-py prettyprint-override"><code>def summ(a, b):
 #for 4 bytes(or 4*8 bits)
 max_num = 0xFFFFFFFF
 while a != 0:
 a, b = ((a &amp; b) &lt;&lt; 1), (a ^ b)
 if a &gt; max_num:
 b = (b&amp;max_num) 
 break
 return b
</code></pre>

blocks|key|4183260|text|如果输入具有相反的符号，则投票最多的答案将不起作用。然而，下面的内容将会。我曾经在一个地方作弊，但只是为了保持代码的整洁。欢迎提出任何改善建议|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4183261|def+add(x,+y):
if+(x+>=+0+and+y+>=+0)+or+(x+<+0+and+y+<+0):
++++return+_add(x,+y)
else:
++++return+__add(x,+y)


def+_add(x,+y):
if+y+==+0:
++++return+x
else:
++++return+_add((x+%5E+y),+((x+&+y)+<<+1))


def+__add(x,+y):
if+x+<+0+<+y:
++++x+=+_add(~x,+1)
++++if+x+>+y:
++++++++diff+=+-sub(x,+y)
++++else:
++++++++diff+=+sub(y,+x)
++++return+diff
elif+y+<+0+<+x:
++++y+=+_add(~y,+1)
++++if+y+>+x:
++++++++diff+=+-sub(y,+x)
++++else:
++++++++diff+=+sub(y,+x)
++++return+diff
else:
++++raise+ValueError("Invalid+Input")


def+sub(x,+y):
if+y+>+x:
++++raise+ValueError('y+must+be+less+than+x')
while+y+>+0:
++++b+=+~x+&+y
++++x+%5E=+y
++++y+=+b+<<+1
return+x|code-block|syntax|javascript|4183262|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The most voted answer will not work if the inputs are of opposite sign. The following however will. I have cheated at one place, but only to keep the code a bit clean. Any suggestions for improvement welcome

<pre class="lang-py prettyprint-override"><code>def add(x, y):
if (x &gt;= 0 and y &gt;= 0) or (x &lt; 0 and y &lt; 0):
 return _add(x, y)
else:
 return __add(x, y)


def _add(x, y):
if y == 0:
 return x
else:
 return _add((x ^ y), ((x &amp; y) &lt;&lt; 1))


def __add(x, y):
if x &lt; 0 &lt; y:
 x = _add(~x, 1)
 if x &gt; y:
 diff = -sub(x, y)
 else:
 diff = sub(y, x)
 return diff
elif y &lt; 0 &lt; x:
 y = _add(~y, 1)
 if y &gt; x:
 diff = -sub(y, x)
 else:
 diff = sub(y, x)
 return diff
else:
 raise ValueError("Invalid Input")


def sub(x, y):
if y &gt; x:
 raise ValueError('y must be less than x')
while y &gt; 0:
 b = ~x &amp; y
 x ^= y
 y = b &lt;&lt; 1
return x
</code></pre>

blocks|key|926694|text|这是C%2B%2B的解决方案，你可以在我的github上找到它：https://github.com/CrispenGari/Add-Without-Integers-without-operators/blob/master/main.cpp|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|926695|int+add(int+a,+int+b){
+++while(b!=0){
++++++int+sum+=+a%5Eb;+//+add+without+carrying
++++++int+carry+=+(a&b)<<1;+//+carrying+without+adding
++++++a=+sum;
++++++b=+carry;
++++}
+++return+a;
+}
+//+the+function+can+be+writen+as+follows+:
+int+add(int+a,+int+b){
+++++if(b==0){
++++++++return+a;+//+any+number+plus+0+=+that+number+simple!
++++}
++++int+sum+=+a+%5E+b;//+adding+without+carrying;
++++int+carry+=+(a+&+b)<<1;+//+carry,+without+adding
++++return+add(sum,+carry);
++}|code-block|syntax|javascript|926696|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/CrispenGari/Add-Without-Integers-without-operators/blob/master/main.cpp^0|S|2I|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Here is the solution in C++, you can find it on my github here: <a href="https://github.com/CrispenGari/Add-Without-Integers-without-operators/blob/master/main.cpp" rel="nofollow noreferrer">https://github.com/CrispenGari/Add-Without-Integers-without-operators/blob/master/main.cpp</a>

<pre><code>int add(int a, int b){
 while(b!=0){
 int sum = a^b; // add without carrying
 int carry = (a&amp;b)&lt;&lt;1; // carrying without adding
 a= sum;
 b= carry;
 }
 return a;
 }
 // the function can be writen as follows :
 int add(int a, int b){
 if(b==0){
 return a; // any number plus 0 = that number simple!
 }
 int sum = a ^ b;// adding without carrying;
 int carry = (a &amp; b)&lt;&lt;1; // carry, without adding
 return add(sum, carry);
 }
</code></pre>

blocks|key|922141|text|This+can+be+done+using+Half+Adder.
Half+Adder+is+method+to+find+sum+of+numbers+with+single+bit.
A+++B++++SUM+++CARRY+++A+&+B++++A+%5E+B
0+++0++++0+++++0++++++++0+++++++++0
0+++1++++1+++++0++++++++0+++++++++1
1+++0++++1+++++0++++++++0+++++++++1
1+++1++++0+++++1++++++++0+++++++++0

We+can+observe+here+that+SUM+=+A+%5E+B+and+CARRY+=+A+&+B
We+know+CARRY+is+always+added+at+1+left+position+from+where+it+was+
generated.
so+now+add+(+CARRY+<<+1+)+in+SUM,+and+repeat+this+process+until+we+get+
Carry+0.

int+Addition(+int+a,+int+b)
{
+if(B==0)
++++return+A;
+Addition(+A+%5E+B,+(A+&+B)+<<1+)
}

let's+add+7+(0111)+and+3+(0011)+answer+will+be+10+(1010)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|922142|unstyled|922143|A+=+0100和B=+0110|ordered-list-item|922144|A+=+0010和B=+1000|922145|A+=+1010和B=+0000最终答案是A。|922146|922147|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|S|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|T|8|@]|9|@]|A|$]]|$1|M|3|-4|5|E|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|E|7|V|8|@]|9|@]|A|$]]]|O|$]]

<pre><code>This can be done using Half Adder.
Half Adder is method to find sum of numbers with single bit.
A B SUM CARRY A &amp; B A ^ B
0 0 0 0 0 0
0 1 1 0 0 1
1 0 1 0 0 1
1 1 0 1 0 0

We can observe here that SUM = A ^ B and CARRY = A &amp; B
We know CARRY is always added at 1 left position from where it was 
generated.
so now add ( CARRY &lt;&lt; 1 ) in SUM, and repeat this process until we get 
Carry 0.

int Addition( int a, int b)
{
 if(B==0)
 return A;
 Addition( A ^ B, (A &amp; B) &lt;&lt;1 )
}

let's add 7 (0111) and 3 (0011) answer will be 10 (1010)
</code></pre>
<ol>
<li>A = 0100 and B = 0110</li>
<li>A = 0010 and B = 1000</li>
<li>A = 1010 and B = 0000
final answer is A.</li>
</ol>

blocks|key|922158|text|我在Swift中实现了这一点，我相信有人会从中受益|type|unstyled|depth|inlineStyleRanges|entityRanges|data|922159|+++var+a+=+3
+++var+b+=+5
+++var+sum+=+0
+++var+carry+=+0

+++while+(b+!=+0)+{
++++++sum+=+a+%5E+b
++++++carry+=+a+&+b
++++++a+=+sum
++++++b+=+carry+<<+1
+++}

+++print+(sum)|code-block|syntax|javascript|922160|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I implemented this in Swift, I am sure someone will benefit from
<pre><code> var a = 3
 var b = 5
 var sum = 0
 var carry = 0

 while (b != 0) {
 sum = a ^ b
 carry = a &amp; b
 a = sum
 b = carry &lt;&lt; 1
 }

 print (sum)
</code></pre>

blocks|key|4183110|text|Python代码：(1)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4183111|add+=+lambda+a,b+:+-(-a)-(-b)|code-block|syntax|javascript|4183112|使用带有'-‘运算符的lambda函数|4183113|(2)|4183114|add=+lambda+a,b+:+len(list(map(lambda+x:x,(i+for+i+in+range(-a,b)))))|4183115|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Python codes:
(1)

<pre><code>add = lambda a,b : -(-a)-(-b)
</code></pre>

use lambda function with '-' operator

(2)

<pre><code>add= lambda a,b : len(list(map(lambda x:x,(i for i in range(-a,b)))))
</code></pre>

A friend and I are going back and forth with brain-teasers and I have no idea how to solve this one. My assumption is that it's possible with some bitwise operators, but not sure.

What is the best way to add two numbers without using the + operator?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我和一个朋友正在用脑筋急转弯，我不知道如何解决这个问题。我的假设是可以使用一些按位运算符，但不确定。

问不使用+运算符将两个数字相加的最佳方法是什么？
EN

回答 24

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不使用+运算符将两个数字相加的最佳方法是什么？EN

回答 24

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问不使用+运算符将两个数字相加的最佳方法是什么？
EN