# [ACCEPTED]-How to add two numbers without using ++ or + or another arithmetic operator-bit-manipulation

Score: 99

This is something I have written a while 4 ago for fun. It uses a two's complement representation and 3 implements addition using repeated shifts 2 with a carry bit, implementing other operators 1 mostly in terms of addition.

#include <stdlib.h> /* atoi() */
#include <stdio.h>  /* (f)printf */
#include <assert.h> /* assert() */

int add(int x, int y) {
int carry = 0;
int result = 0;
int i;

for(i = 0; i < 32; ++i) {
int a = (x >> i) & 1;
int b = (y >> i) & 1;
result |= ((a ^ b) ^ carry) << i;
carry = (a & b) | (b & carry) | (carry & a);
}

return result;
}

int negate(int x) {
}

int subtract(int x, int y) {
}

int is_even(int n) {
return !(n & 1);
}

int divide_by_two(int n) {
return n >> 1;
}

int multiply_by_two(int n) {
return n << 1;
}

int multiply(int x, int y) {
int result = 0;

if(x < 0 && y < 0) {
return multiply(negate(x), negate(y));
}

if(x >= 0 && y < 0) {
return multiply(y, x);
}

while(y > 0) {
if(is_even(y)) {
x = multiply_by_two(x);
y = divide_by_two(y);
} else {
}
}

return result;
}

int main(int argc, char **argv) {
int from = -100, to = 100;
int i, j;

for(i = from; i <= to; ++i) {
assert(0 - i == negate(i));
assert(((i % 2) == 0) == is_even(i));
assert(i * 2 == multiply_by_two(i));
if(is_even(i)) {
assert(i / 2 == divide_by_two(i));
}
}

for(i = from; i <= to; ++i) {
for(j = from; j <= to; ++j) {
assert(i + j == add(i, j));
assert(i - j == subtract(i, j));
assert(i * j == multiply(i, j));
}
}

return 0;
}
Score: 53

Or, rather than Jason's bitwise approach, you 15 can calculate many bits in parallel - this 14 should run much faster with large numbers. In 13 each step figure out the carry part and 12 the part that is sum. You attempt to add 11 the carry to the sum, which could cause 10 carry again - hence the loop.

while a != 0:
#      v carry portion| v sum portion
a, b = ((a & b) << 1),  (a ^ b)
print b, a
return b

when you add 9 1 and 3, both numbers have the 1 bit set, so 8 the sum of that 1+1 carries. The next step 7 you add 2 to 2 and that carries into the 6 correct sum four. That causes an exit

2 2
4 0
4

Or 5 a more complex example

66 270
4 332
8 328
16 320
336

Edit: For it to work easily 4 on signed numbers you need to introduce 3 an upper limit on a and b

while a != 0:
#      v carry portion| v sum portion
a, b = ((a & b) << 1),  (a ^ b)
a &= 0xFFFFFFFF
b &= 0xFFFFFFFF
print b, a
return b

Try it on

to see 2 a single bit carry up through the entire 1 range and overflow over 32 iterations

4294967294 2
4294967292 4
4294967288 8
...
4294901760 65536
...
2147483648 2147483648
0 0
0L
Score: 21
{
while (b)
{
int carry = a & b;
a = a ^ b;
b = carry << 1;
}
return a;
}

0

Score: 18

You could transform an adder circuit into an algorithm. They 1 only do bitwise operations =)

Score: 8

Well, to implement an equivalent with boolean 3 operators is quite simple: you do a bit-by-bit 2 sum (which is an XOR), with carry (which 1 is an AND). Like this:

int sum(int value1, int value2)
{
int result = 0;
int carry = 0;
{
int bit1 = value1 & mask;
int bit2 = value2 & mask;
result |= mask & (carry ^ bit1 ^ bit2);
carry = ((bit1 & bit2) | (bit1 & carry) | (bit2 & carry)) << 1;
}
return result;
}
Score: 7

You've already gotten a couple bit manipulation 9 answers. Here's something different.

In 8 C, arr[ind] == *(arr + ind). This lets us do slightly confusing 7 (but legal) things like int arr = { 3, 1, 4, 5 }; int val = 0[arr];.

So we can define 6 a custom add function (without explicit 5 use of an arithmetic operator) thusly:

unsigned int add(unsigned int const a, unsigned int const b)
{
/* this works b/c sizeof(char) == 1, by definition */
char * const aPtr = (char *)a;
return (int) &(aPtr[b]);
}

Alternately, if 4 we want to avoid this trick, and if by arithmetic 3 operator they include |, &, and ^ (so direct 2 bit manipulation is not allowed) , we can 1 do it via lookup table:

typedef unsigned char byte;

{ 0, 1, 2, /*...*/, 255 },
{ 1, 2, /*...*/, 255, 0 },
{ 2, /*...*/, 255, 0, 1 },
/*...*/
{ 254, 255, 0, 1, /*...*/, 253 },
{ 255, 0, 1, /*...*/, 253, 254 },
};

{ 0, 0, 0, /*...*/, 0 },
{ 0, 0, /*...*/, 0, 1 },
{ 0, /*...*/, 0, 1, 1 },
/*...*/
{ 0, 0, 1, /*...*/, 1 },
{ 0, 1, 1, /*...*/, 1 },
};

void add_byte(byte const a, byte const b, byte * const sum, byte * const carry)
{
}

unsigned int add(unsigned int a, unsigned int b)
{
unsigned int sum;
unsigned int carry;
byte * const aBytes = (byte *) &a;
byte * const bBytes = (byte *) &b;
byte * const sumBytes = (byte *) &sum;
byte * const carryBytes = (byte *) &carry;

byte const test[4] = { 0x12, 0x34, 0x56, 0x78 };
byte BYTE_0, BYTE_1, BYTE_2, BYTE_3;

/* figure out endian-ness */
if (0x12345678 == *(unsigned int *)test)
{
BYTE_0 = 3;
BYTE_1 = 2;
BYTE_2 = 1;
BYTE_3 = 0;
}
else
{
BYTE_0 = 0;
BYTE_1 = 1;
BYTE_2 = 2;
BYTE_3 = 3;
}

/* assume 4 bytes to the unsigned int */

if (carryBytes[BYTE_0] == 1)
{
if (sumBytes[BYTE_1] == 255)
{
sumBytes[BYTE_1] = 0;
carryBytes[BYTE_1] = 1;
}
else
{
}
}

if (carryBytes[BYTE_1] == 1)
{
if (sumBytes[BYTE_2] == 255)
{
sumBytes[BYTE_2] = 0;
carryBytes[BYTE_2] = 1;
}
else
{
}
}

if (carryBytes[BYTE_2] == 1)
{
if (sumBytes[BYTE_3] == 255)
{
sumBytes[BYTE_3] = 0;
carryBytes[BYTE_3] = 1;
}
else
{
}
}

return sum;
}
Score: 6

All arithmetic operations decompose to bitwise 2 operations to be implemented in electronics, using 1 NAND, AND, OR, etc. gates.

Score: 6

For unsigned numbers, use the same addition 3 algorithm as you learned in first class, but 2 for base 2 instead of base 10. Example for 1 3+2 (base 10), i.e 11+10 in base 2:

1         ‹--- carry bit
0 1 1     ‹--- first operand (3)
+ 0 1 0     ‹--- second operand (2)
-------
1 0 1     ‹--- total sum (calculated in three steps)
Score: 4

If you're feeling comedic, there's always 5 this spectacularly awful approach for adding 4 two (relatively small) unsigned integers. No 3 arithmetic operators anywhere in your code.

In 2 C#:

static uint JokeAdder(uint a, uint b)
{
string result = string.Format(string.Format("{{0,{0}}}{{1,{1}}}", a, b), null, null);
return result.Length;
}

In C, using stdio (replace snprintf with 1 _snprintf on Microsoft compilers):

#include <stdio.h>
unsigned int JokeAdder(unsigned int a, unsigned int b)
{
return snprintf(NULL, 0, "%*.*s%*.*s", a, a, "", b, b, "");
}
Score: 3

Here is a compact C solution. Sometimes 1 recursion is more readable than loops.

if (b == 0) return a;
return add(a ^ b, (a & b) << 1);
}
Score: 1
short int ripple_adder(short int a, short int b)
{
short int i, c, s, ai, bi;

c = s = 0;

for (i=0; i<16; i++)
{
ai = a & 1;
bi = b & 1;

s |= (((ai ^ bi)^c) << i);
c = (ai & bi) | (c & (ai ^ bi));

a >>= 1;
b >>= 1;
}
s |= (c << i);
return s;
}

0

Score: 1
#include<stdio.h>

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

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

0

Score: 1
## to add or subtract without using '+' and '-' ##
#include<stdio.h>
#include<conio.h>
#include<process.h>

void main()
{
int sub,a,b,carry,temp,c,d;

clrscr();

printf("enter a and b:");
scanf("%d%d",&a,&b);

c=a;
d=b;
while(b)
{
carry=a&b;
a=a^b;
b=carry<<1;
}

temp=~d+1;  //take 2's complement of b and add it with a
sub=c+temp;
printf("diff(%d,%d):%d\n",c,d,temp);
getch();
}

0

Score: 0

The following would work.

x - (-y)

0

Score: 0

Code to implement add,multiplication without 2 using +,* operator; for subtraction pass 1's 1 complement +1 of number to add function

#include<stdio.h>

unsigned int add(unsigned int x,unsigned int y)
{
int carry=0;
while (y != 0)
{

carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;
}
int multiply(int a,int b)
{
int res=0;
int i=0;
int large= a>b ? a :b ;
int small= a<b ? a :b ;
for(i=0;i<small;i++)
{
}
return res;
}
int main()
{
printf("Sum :: %u,Multiply is :: %d",add(7,15),multiply(111,111));
return 0;
}
Score: 0

This can be done recursively:

{
if (b == 0)
return a;

int sum = a ^ b; // add without carrying
int carry = (a & b) << 1; // carry, but don’t add
}

or iteratively:

{
int sum, carry;

do
{
sum = a ^ b; // add without carrying
carry = (a & b) << 1; // carry, but don’t add

a = sum;
b = carry;
} while (b != 0);

return a;
}

0

Score: 0

The question asks how to add two numbers 16 so I don't understand why all the solutions 15 offers the addition of two integers? What 14 if the two numbers were floats i.e. 2.3 + 1.8 are 13 they also not considered numbers? Either 12 the question needs to be revised or the 11 answers.

For floats I believe the numbers 10 should be broken into their components i.e. 2.3 = 2 + 0.3 then 9 the 0.3 should be converted to an integer representation 8 by multiplying with its exponent factor 7 i.e 0.3 = 3 * 10^-1 do the same for the other number and 6 then add the integer segment using one of 5 the bit shift methods given as a solution 4 above handling situations for carry over 3 to the unit digits location i.e. 2.7 + 3.3 = 6.0 = 2+3+0.7+0.3 = 2 + 3 + 7x10^-1 + 3x10^-1 = 2 + 3 + 10^10^-1 (this 2 can be handled as two separate additions 1 2+3=5 and then 5+1=6)

Score: 0

With given answers above, it can be done 1 in single line code:

int add(int a, int b) {
return (b == 0) ? a : add(a ^ b, (a & b) << 1);
}
Score: 0

You can use double negetive to add two integers 1 for example:

int sum2(int a, int b){
return -(-a-b);
}
Score: 0

Without using any operators adding two integers 1 can be done in different ways as follows:

int sum_of_2 (int a, int b){
int sum=0, carry=sum;
sum =a^b;
carry = (a&b)<<1;
return (b==0)? a: sum_of_2(sum, carry);
}
// Or you can just do it in one line as follows:
int sum_of_2 (int a, int b){
return (b==0)? a: sum_of_2(a^b, (a&b)<<1);
}
// OR you can use the while loop instead of recursion function as follows
int sum_of_2 (int a, int b){
if(b==0){
return a;
}
while(b!=0){
int sum = a^b;
int carry = (a&b)<<1;
a= sum;
b=carry;
}
return a;
}

More Related questions