Кодирование целочисленной функции умножения с использованием рекурсии (в C) [закрыто]

Хорошо, давайте будем оригинальными. :)

unsigned int mul(unsigned int a, unsigned int b)
{
    if ( !a || !b ) return 0;
    if ( a == 1 ) return b;
    if ( b == 1 ) return a;

    return mul(a-1, b-1)+a+b-1;
}

Если вы действительно хотите произвести впечатление на своих сверстников и учителя, отправьте это - это одновременно и рекурсивно, и быстро!

int mul(int a, int b)
{
    if ( a < 0 ) return -mul(-a,b);
    if ( b < 0 ) return -mul(a,-b);
    if ( b == 0 ) return 0;
    return (mul(a,b>>1)<<1)+(b&1?a:0);
}

Добавлено : В качестве дополнительного бонуса это правильно обрабатывает как положительные, так и положительные результаты, отрицательные и нулевые значения.

Вот функция:

int mulitplication(x,y)
{
    if (y==0)
    {
      return 0;
    }
    else
      return x+multiplication(x,y-1);
    }
}

Вы должны быть более конкретными, если вам нужна хорошая помощь. Но вот рекурсивная функция в C, которая умножает два положительных целых числа:

int multiply(int multiplicand, int multiplier)
{
  if(multiplier == 0)
  {
    return 0;
  }
  return multiply(multiplicand, multiplier - 1) + multiplicand;
}

Джонатан Леффлер писал: А если множитель отрицательный?

Хорошо:

int multiply(int multiplicand, int multiplier)
{
  if(multiplier == 0)
  {
    return 0;
  }
  if(multiplier < 0)
  {
    return multiply(multiplicand, multiplier + 1) - multiplicand; //Edit: changed "+ multiplicand" to "- multplicand"
  }
  return multiply(multiplicand, multiplier - 1) + multiplicand;
}

Марк Байерс писал: Отрицательная версия все еще неверна

Ворчать, ворчать. Обслуживает меня для записи по памяти и без тестирования. Этот тестируется для многих целочисленных диапазонов, отрицательных и положительных, нечетных и четных. Должно работать для любого целочисленного значения. Веселый Винтермас.

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

int mulInner(int a, int b, int c)
{
    if (b == 0)
        return a*c;
    return mulInner(a, b-1, c+1);
}
int mul(int a, int b)
{
    return multInner(a, b, 0);
}

Эй, он не запретил использовать оператор * ...

Добавляйте его к себе снова и снова, N раз. То есть, если вы хотите умножить число на N ..

если я не ошибаюсь, это так ...

int mul(int a, int b)
{
if(b==1)
return a;
else
return a+mul(a,b-1);
}

Это работает, только если первый операнд больше нуля, но по крайней мере он короткий и запутанный.;)

int mul(int a, int b) {
  return b + (--a ? mul(a, b) : 0);
}

Однако я не убедитесь, что порядок оценки определен, поэтому вам, возможно, придется переместить декремент за пределы выражения:

int mul(int a, int b) {
  a--;
  return b + (a ? mul(a, b) : 0);
}

int mul(int a,int b)
{
     if(b==1)
        return a;
     else
        return(a+(mul(a,b-1)));
}

50 символов:

m(x,y){return!y?0:rand()%2?m(x,y+1)-x:m(x,y-1)+x;}

Я надеюсь, что набираю очки за использование функции rand() (особенно в таком виде) и общие синтаксические тонкости. В зависимости от вашей системной библиотеки и фазы луны, имейте в виду, что рекурсия может привести к segfault при больших значениях аргументов, например, при вычислении 2 × 3.