Subtraction without minus sign in C

Question

How can I subtract two integers in C without the - operator?

Answer 1

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 2

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 3

• + 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(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 4

+ 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 <= c < (a+b):

       (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 5

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 6

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 7

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 8

I suppose this

b - a = ~( a + ~b)

Answer 9

Assembly (accumulator) style:

int result = a;
result -= b;

Answer 10

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 11

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…)

Answer 12

For the maximum range of any data type , one's complement provide the negative value decreased by 1 to any corresponding value. ex:
~1 --------> -2
~2---------> -3
and so on... I will show you this observation using little code snippet

#include<stdio.h>
int main()
{
   int a , b;
   a=10;
   b=~a; // b-----> -11    
   printf("%d\n",a+~b+1);// equivalent to a-b
   return 0;
}

Output: 0
Note : This is valid only for the range of data type. means for int data type this rule will be applicable only for the value of range[-2,147,483,648 to 2,147,483,647]. Thankyou .....May this help you

Answer 13

Iff:

1. The Minuend is greater or equal to 0, or
2. The Subtrahend is greater or equal to 0, or
3. The Subtrahend and the Minuend are less than 0

multiply the Minuend by -1 and add the result to the Subtrahend:

SUB + (MIN * -1)

Else multiply the Minuend by 1 and add the result to the Subtrahend.

SUB + (MIN * 1)

---

Example (Try it online):

#include <stdio.h>

int subtract (int a, int b)
{
    if ( a >= 0 || b >= 0 || ( a < 0 && b < 0 ) )
    {
        return a + (b * -1);
    }

    return a + (b * 1); 
}

int main (void)
{
    int x = -1;
    int y = -5;
    printf("%d - %d = %d", x, y, subtract(x, y) );
}

Output:

-1 - -5 = 4

Answer 14

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

Answer 15

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

Answer 16

        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 17

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

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

}