Multiplying using recursive function C++

Question

I did a recursive function to calculate x*y with x and y are all integers (x and y >= 0). My formula is: x * y =

0, if x is equal 0
(x >> 1)*(y << 1), if x is an even number
(x >> 1)*(y << 1) + y, if x is an odd number

"<<" and ">>" are Left Shift and Right Shift Bitwise Operator. Here is my code:

int multiply(int x, int y) {
    int y1 = 0;
    if (x == 0) return 0;
    else if (x % 3 == 0) {
        y1 = y;
        x = x >> 1;
        y = y << 1;
        return (multiply(x, y) + y1);
    }
    else if (x % 2 == 0) {
        x = x >> 1;
        y = y << 1;
        return multiply(x, y);
    }
}

The recursive function above is supposed to return (x*y) value but they were all wrong when i tested and i don't know why. What did i do wrong? How can i fix this?

`x % 3 == 0` has nothing to do with whether `x` is odd or even. — Igor Tandetnik, Aug 01 '20 at 14:24
x % 3 is not a n odd number.. it's subset of numbers divisible by 3 — Swift - Friday Pie, Aug 01 '20 at 14:25
Typcially checking for odd parity using bitwise `and` is acceptable and faster. For example `1&1==1`, `2&1==0`, `3&1==1`, `4&1==0`, `5&1==1`, etc. — Andy, Aug 01 '20 at 14:44

score 3 · Accepted Answer · 2020-08-01T19:34:02.177

Your problem is wit x % 3, what happens if x = 5? you skip it. Here is improved version of your code.

int multiply(int x, int y) {
    if (x == 0)
        return 0;
    else if (x % 2 == 1)
        return (multiply(x >> 1, y << 1) + y);

    return multiply(x >> 1, y << 1);
}

or maybe even this:

int multiply(int x, int y) {
    if (x == 0)
        return 0;
    int m = multiply(x >> 1, y << 1);

    if (x % 2 == 1)
        m += y;

    return m;
}

Here is super fast version suggested by Andy:

int multiply(int x, int y) {
    if (x == 0)
        return 0;
    int m = multiply(x >> 1, y << 1);

    if (x & 1)
        m += y;

    return m;
}

As a challenge of speed, here is non recursive version:

int multiply (int x, int y) {
    int y1 = 0;
    for (; x > 0; x = (x >> 1), y = (y << 1)) 
        if (x&1) 
            y1 += y;

    return y1; 
}

NOTE: I know this question is about recursive method but just as a challenge I wrote non-recursive algorithm.

@Andy I'd be very surprised if compilers didn't make both `if(x&1)` and `if(x%2==1)` into equivalent assembly. This seems to be an unnecessary optimization. — cigien, Aug 01 '20 at 14:58
@cigien -- yeah you're probably right. but i bet back in 1994 it might not have. so in case you end up there, you have this in your pocket. — Andy, Aug 01 '20 at 15:23

cigien · Answer 2 · 2020-08-01T14:32:29.570

1

You are not checking if x is odd correctly here:

else if (x % 3 == 0) {  // e.g. fails on x = 1

Instead, you need to do

else if (x % 2 == 1) {

Here's a demo.

Note that this makes the following else check for even values of x redundant:

else if (x % 2 == 0) {  // can just be an unconditional else

Also, since you are returning from the x == 0, and x % 2 == 1 branches, the else conditions can be removed as well. You can also factor out the repeated code to make the function simpler, like this:

int multiply(int x, int y) {
    if (x == 0) return 0;
    if (x % 2 == 1) 
        return (multiply(x >> 1, y << 1) + y);
    else 
        return multiply(x >> 1, y << 1); 
}

Here's a demo.

edited Aug 01 '20 at 14:32

answered Aug 01 '20 at 14:25

cigien

57,834
11
73
112

1

@Swift-FridayPie can you let us know what do you mean? – Aug 01 '20 at 14:37
@0x476f72616e he fixed that. was a paranoid `if` – Swift - Friday Pie Aug 03 '20 at 10:11

score 0 · Answer 3 · answered Aug 01 '20 at 15:12

This is what i feel is the simplest approach to carry out recursive multiplication. Do let me know if its efficient enough for you.

#include<iostream>
using namespace std;
 
float multiply(float a, float b) {
 
    //no zeros bro
    if (b == 0)
        return 0;
 
    //let the recursion begin
    if (b > 0)
        return x + multiply(a, b - 1);
 
    //negatives stay away pliz
    if (y < 0)
        return -multiply(a, -b);
}
 
int main() {
    float a, b, result;
    cout << "Enter the two numbers";
    cin >> a >> b;
 
    result = multiply(a, b);
 
    //And the result is.................
    cout << result;
    return 0;
}

I gave you +1 for an answer but your approach is `O(n), where the bit shift version is O(log(n)) — , Aug 01 '20 at 19:38

score 0 · Answer 4 · edited Oct 07 '21 at 09:19

0

Recursive function related to multiplication of natural numbers:

int multCool(int a, int b)
{
    return (b==1 ? a: a+ multCool(a,b-1));
}

edited Oct 07 '21 at 09:19

Peter Csala

17,736
16
35
75

answered Oct 07 '21 at 09:16

ofderdiyok

1

Multiplying using recursive function C++

4 Answers4