How can I perform multiplication without the '*' operator?

Question

I was just going through some basic stuff as I am learning C. I came upon a question to multiply a number by 7 without using the * operator. Basically it\'s like this

<

Answer 1

unsigned int Multiply( unsigned int a, unsigned int b )
{
    int ret = 0;
    // For each bit in b
    for (int i=0; i<32; i++) {

        // If that bit is not equal to zero
        if (( b & (1 << i)) != 0) {

            // Add it to our return value
            ret += a << i;
        }
    }
    return ret;
}

I avoided the sign bit, because it's kind of not the subject of the post. This is an implementation of what Wayne Conrad said basically. Here is another problem is you want to try more low level math operations. Project Euler is cool!

Answer 2

Another thinking-outside-the-box answer:

BigDecimal a = new BigDecimal(123);
BigDecimal b = new BigDecimal(2);
BigDecimal result = a.multiply(b);
System.out.println(result.intValue());

Answer 3

Loop it. Run a loop seven times and iterate by the number you are multiplying with seven.

Pseudocode:

total = 0
multiply = 34

loop while i < 7

    total = total + multiply

endloop

Answer 4

The question says:

multiply a number by 7 without using * operator

This doesn't use *:

 number / (1 / 7) 

Edit:
This compiles and works fine in C:

 int number,result;
 number = 8;
 result = number / (1. / 7);
 printf("result is %d\n",result);

Answer 5

When it comes down to it, multiplication by a positive integer can be done like this:

int multiply(int a, int b) {
  int ret = 0;
  for (int i=0; i<b; i++) {
    ret += b;
  }
  return ret;
}

Efficient? Hardly. But it's correct (factoring in limits on ints and so forth).

So using a left-shift is just a shortcut for multiplying by 2. But once you get to the highest power-of-2 under b you just add a the necessary number of times, so:

int multiply(int a, int b) {
  int ret = a;
  int mult = 1;
  while (mult <= b) {
    ret <<= 1;
    mult <<= 1;
  }
  while (mult < b) {
    ret += a;
  }
  return ret;
}

or something close to that.

To put it another way, to multiply by 7.

• Left shift by 2 (times 4). Left shift 3 is 8 which is >7;
• Add b 3 times.

Answer 6

O(log(b)) method

public int multiply_optimal(int a, int b) {

    if (a == 0 || b == 0)
        return 0;
    if (b == 1)
        return a;
    if ((b & 1) == 0)
        return multiply_optimal(a + a, b >> 1);
    else
        return a + multiply_optimal(a + a, b >> 1);

}

The resursive code works as follows:
Base case:
if either of the number is 0 ,product is 0.
if b=1, product =a.

If b is even:
ab can be written as 2a(b/2)
2a(b/2)=(a+a)(b/2)=(a+a)(b>>1) where'>>' arithematic right shift operator in java.

If b is odd:
ab can be written as a+a(b-1)
a+a(b-1)=a+2a(b-1)/2=a+(a+a)(b-1)/2=a+(a+a)((b-1)>>1)
Since b is odd (b-1)/2=b/2=b>>1
So ab=a+(2a*(b>>1))
NOTE:each recursive call b is halved => O(log(b))