Subtraction without minus sign

Question

How can i do subtraction of integers in C without using either the unary or binary '-' operator?

Or can we do the same for other data types like float/double?

Answer 1

have a look at the two's complement

Answer 2

Given that encoding integers to support two's complement is not mandated in C, iterate until done. If they want you to jump through flaming hoops, no need to be efficient about it!

int subtract(int a, int b)
{
  if ( b < 0 )
    return a+abs(b);
  while (b-- > 0)
    --a;
  return a;
}

Silly question... probably silly interview!

Answer 3

If you want to do it for floats, start from a positive number and change its sign bit like so:

float f = 3;
*(int*)&f |= 0x80000000;
// now f is -3.
float m = 4 + f; 
// m = 1

You can also do this for doubles using the appropriate 64 bit integer. in visual studio this is __int64 for instance.

Answer 4

int a = 34;
int b = 50;

You can convert b to negative value using negation and adding 1:

int c = a + (~b + 1);

printf("%d\n", c);

-16

This is two's complement sign negation. Processor is doing it when you use '-' operator when you want to negate value or subtrackt it.

Converting float is simpler. Just negate first bit (shoosh gave you example how to do this).

EDIT:

Ok, guys. I give up. Here is my compiler independent version:

#include <stdio.h>

unsigned int adder(unsigned int a, unsigned int b) {
    unsigned int loop = 1;
    unsigned int sum  = 0;
    unsigned int ai, bi, ci;

    while (loop) {
        ai = a & loop;
        bi = b & loop;
        ci = sum & loop;
        sum = sum ^ ai ^ bi;      // add i-th bit of a and b, and add carry bit stored in sum i-th bit
        loop = loop << 1;
        if ((ai&bi)|(ci&ai)|(ci&bi)) sum = sum^loop; // add carry bit
    }

    return sum;
}

unsigned int sub(unsigned int a, unsigned int b) {
    return adder(a, adder(~b, 1));    // add negation + 1 (two's complement here)
}


int main() {
    unsigned int a = 35;
    unsigned int b = 40;

    printf("%u - %u = %d\n", a, b, sub(a, b)); // printf function isn't compiler independent here

    return 0;
}

I'm using unsigned int so that any compiler will treat it the same.

If you want to subtract negative values, then do it that way:

 unsgined int negative15 = adder(~15, 1);

Now we are completly independent of signed values conventions. In my approach result all ints will be stored as two's complement - so you have to be careful with bigger ints (they have to start with 0 bit).

Answer 5

For subtracting in C two integers you only need:

int subtract(int a, int b)
{
    return a + (~b) + 1;
}

I don't believe that there is a simple an elegant solution for float or double numbers like for integers. So you can transform your float numbers in arrays and apply an algorithm similar with one simulated here

Answer 6

I suppose this

b - a = ~( a + ~b)

Answer 7

Take a look here: Add/Subtract using bitwise operators

Answer 8

As the question asked for integers not ints, you could implement a small interpreter than uses Church numerals.

Answer 9

Assembly (accumulator) style:

int result = a;
result -= b;

Answer 10

+ No bit setting

+ Language independent

+ Independent of number type (int, float, etc)

- Requires a>b (ie positive result)

- Almost certainly not your C homework answer (which is likely to be about bits)

a - b = c
restricting ourselves to the number space 0 
       (a - b) mod(a+b) = c mod(a+b)
a mod(a+b) - b mod(a+b) = c mod(a+b)

simplifying the second term:

(-b).mod(a+b) = (a+b-b).mod(a+b)
              = a.mod(a+b)

substituting:

a.mod(a+b) + a.mod(a+b) = c.mod(a+b)
2a.mod(a+b) = c.mod(a+b)

if b>a, then b-a>0, so:

c.mod(a+b) = c
c = 2a.mod(a+b)

So, if a is always greater than b, then this would work.

Answer 11

• + No bit setting
• + Language independent
• + Can be adjusted for different number types (int, float, etc)
• - Almost certainly not your C homework answer (which is likely to be about bits)

Expand a-b:

a-b = a + (-b)
    = a + (-1).b

Manufacture -1:

float:             pi = asin(1.0);
(with    minusone_flt = sin(3.0/2.0*pi);
math.h)           or  = cos(2.0*pi)
                  or  = log10(0.1)
complex: minusone_cpx = (0,1)**2; // i squared
integer: minusone_int = 0; minusone_int--; // or convert one of the floats above

Answer 12

Pontus is right, 2's complement is not mandated by the C standard (even if it is the de facto hardware standard). +1 for Phil's creative answers; here's another approach to getting -1 without using the standard library or the -- operator.

C mandates three possible representations, so you can sniff which is in operation and get a different -1 for each:

negation= ~1;
if (negation+1==0)                 /* one's complement arithmetic */
    minusone= ~1;
else if (negation+2==0)            /* two's complement arithmetic */
    minusone= ~0;
else                               /* sign-and-magnitude arithmetic */
    minusone= ~0x7FFFFFFE;

r= a+b*minusone;

The value 0x7FFFFFFFE would depend on the width (number of ‘value bits’) of the type of integer you were interested in; if unspecified, you have more work to find that out!

Answer 13

Create a lookup table for every possible case of int-int!

Answer 14

        int num1, num2, count = 0;
        Console.WriteLine("Enter two numebrs");
        num1 = int.Parse(Console.ReadLine());
        num2 = int.Parse(Console.ReadLine());
        if (num1 < num2)
        {
            num1 = num1 + num2;
            num2 = num1 - num2;
            num1 = num1 - num2;
        }
        for (; num2 < num1; num2++)
        {
            count++;
        }
        Console.WriteLine("The diferrence is " + count);

Answer 15

Not tested. Without using 2's complement:

#include <stdlib.h>
#include <stdio.h>
int sillyNegate(int x) {
   if (x <= 0)
     return abs(x);
   else {
     // setlocale(LC_ALL, "C"); // if necessary.
     char buffer[256];
     snprintf(buffer, 255, "%c%d", 0x2d, x);
     sscanf(buffer, "%d", &x);
     return x;
   }
}

Assuming the length of an int is much less than 255, and the snprintf/sscanf round-trip won't produce any unspecified behavior (right? right?).

The subtraction can be computed using a - b == a + (-b).

---

Alternative:

#include <math.h>
int moreSillyNegate(int x) {
   return x * ilogb(0.5);  // ilogb(0.5) == -1;
}

---

Answer 16

void main() { int a=5; int b=7;

while(b--)a--; printf("sud=%d",a);

}

Answer 17

This would work using integer overflow:

#include<limits.h>    
int subtractWithoutMinusSign(int a, int b){
         return a + (b * (INT_MAX + INT_MAX + 1));
}

This also works for floats (assuming you make a float version…)