Вычитание без знака "минус"

int a = 34;
int b = 50;

Можно преобразовать b в отрицательную величину с помощью отрицания и добавив 1:

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

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

-16

Это - дополнительное отрицание знака two. Процессор делает его при использовании '-' оператор, когда Вы хотите инвертировать значение или вычесть его.

Преобразование плавания более просто. Просто инвертируйте первый бит (shoosh, дал Вам пример, как сделать это).

Править:

Хорошо, парни. Я сдаюсь. Вот является мой компилятор независимой версией:

#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;
}

Я использую неподписанный интервал так, чтобы любой компилятор рассматривал его то же.

Если Вы хотите вычесть отрицательные величины, то сделайте это тот путь:

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

Теперь мы - completly независимый политик конвенций значений со знаком. В моем результате подхода весь ints будет сохранен как дополнение two - таким образом, необходимо будет быть осторожными с большим ints (они должны запустить с 0 битов).

Создайте справочную таблицу для каждого возможного случая международного интервала!

Для вычитания в C два целых числа Вам только нужно:

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

Я не полагаю, что существует простое изящное решение для плавания или двойных чисел как для целых чисел. Таким образом, можно преобразовать числа плавающие в массивы и применить алгоритм, похожий с одним моделируемым здесь

Как вопрос, который задают для целых чисел нет ints, Вы могли реализовать маленький интерпретатор, чем церковные цифры использования.

Я предполагаю это

b - = ~ (+ ~b)

a - b = c

ограничение нас к числу располагает с интервалами 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)

упрощение второго срока:

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

замена:

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

если b> a, то b-a> 0, таким образом:

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

Так, если бы всегда больше, чем b, то это работало бы.

Если Вы хотите сделать это для плаваний, запустите с положительного числа и измените его знаковый бит как так:

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

Можно также сделать, это для удваивает использование соответствующего целого числа на 64 бита. в Visual Studio это __ int64, например.

Учитывая, что кодирование целых чисел для поддержки дополнения two не получает мандат в C, выполните итерации, пока не сделано. Если они хотят, чтобы Вы перешли через пылающие обручи, никакая потребность быть эффективными об этом!

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

Глупый вопрос..., вероятно, глупое интервью!

• + Никакая разрядная установка
• + Независимый от языка
• + Может быть скорректирован для различных типов числа (интервал, плавание, и т.д.)
• - Почти наверняка не Ваш ответ домашней работы C (который, вероятно, будет о битах),

Разверните a-b:

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

Изготовление-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

Понт является правильным, 2's, дополнение не получает мандат по стандарту C (даже если это - фактический аппаратный стандарт). +1 для творческих ответов Phil; вот другой подход к получению-1, не пользуясь стандартной библиотекой или - оператор.

C передает под мандат три возможных представления, таким образом, можно осуществить сниффинг, который в действии, и получите различный-1 для каждого:

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;

Значение 0x7FFFFFFFE зависело бы от ширины (число ‘битов значения’) типа целого числа, которым Вы интересовались; если неуказанный, у Вас есть больше работы для обнаружения этого!

Блок (аккумулятор) стиль:

int result = a;
result -= b;

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

Не тестировалось. Без использования дополнения до 2:

#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;
   }
}

Предполагая, что длина int намного меньше 255, и передача snprintf / sscanf туда и обратно не приведет к неопределенному поведению (верно? Верно?).

Вычитание можно вычислить, используя a - b == a + (-b).

Альтернатива:

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

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

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

}

Это будет работать с целочисленным переполнением:

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

Это также работает для чисел с плавающей запятой (при условии, что вы создаете версию с плавающей запятой…)