Multiply two integers without using multiplication, division and bitwise operators, and no loops

Last Updated : 19 Sep, 2022

By making use of recursion, we can multiply two integers with the given constraints.
To multiply x and y, recursively add x y times.

Approach:

Since we cannot use any of the given symbols, the only way left is to use recursion, with the fact that x is to be added to x y times.

Base case: When the numbers of times x has to be added becomes 0.

Recursive call: If the base case is not met, then add x to the current resultant value and pass it to the next iteration.

C++

// C++ program to Multiply two integers without 
// using multiplication, division and bitwise
//  operators, and no loops
#include<iostream>
 
using namespace std;
class GFG
{
     
/* function to multiply two numbers x and y*/
public : int multiply(int x, int y)
{
    /* 0 multiplied with anything gives 0 */
    if(y == 0)
    return 0;
 
    /* Add x one by one */
    if(y > 0 )
    return (x + multiply(x, y-1));
 
    /* the case where y is negative */
    if(y < 0 )
    return -multiply(x, -y);
}
};
 
// Driver code
int main()
{
    GFG g;
    cout << endl << g.multiply(5, -11);
    getchar();
    return 0;
}
 
// This code is contributed by SoM15242

C

#include<stdio.h>
/* function to multiply two numbers x and y*/
int multiply(int x, int y)
{
   /* 0  multiplied with anything gives 0 */
   if(y == 0)
     return 0;
 
   /* Add x one by one */
   if(y > 0 )
     return (x + multiply(x, y-1));
  
  /* the case where y is negative */
   if(y < 0 )
     return -multiply(x, -y);
}
 
int main()
{
  printf("\n %d", multiply(5, -11));
  getchar();
  return 0;
}

Java

class GFG {
     
    /* function to multiply two numbers x and y*/
    static int multiply(int x, int y) {
         
        /* 0 multiplied with anything gives 0 */
        if (y == 0)
            return 0;
     
        /* Add x one by one */
        if (y > 0)
            return (x + multiply(x, y - 1));
     
        /* the case where y is negative */
        if (y < 0)
            return -multiply(x, -y);
             
        return -1;
    }
     
    // Driver code
    public static void main(String[] args) {
         
        System.out.print("\n" + multiply(5, -11));
    }
}
 
// This code is contributed by Anant Agarwal.

Python3

# Function to multiply two numbers
# x and y
def multiply(x,y):
 
    # 0 multiplied with anything
    # gives 0 
    if(y == 0):
        return 0
 
    # Add x one by one 
    if(y > 0 ):
        return (x + multiply(x, y - 1))
 
    # The case where y is negative
    if(y < 0 ):
        return -multiply(x, -y)
     
# Driver code
print(multiply(5, -11))
 
# This code is contributed by Anant Agarwal.

C#

// Multiply two integers without
// using multiplication, division
// and bitwise operators, and no
// loops
using System;
 
class GFG {
     
    // function to multiply two numbers
    // x and y
    static int multiply(int x, int y) {
         
        // 0 multiplied with anything gives 0
        if (y == 0)
            return 0;
     
        // Add x one by one
        if (y > 0)
            return (x + multiply(x, y - 1));
     
        // the case where y is negative
        if (y < 0)
            return -multiply(x, -y);
             
        return -1;
    }
     
    // Driver code
    public static void Main() {
         
        Console.WriteLine(multiply(5, -11));
    }
}
 
// This code is contributed by vt_m.

PHP

<?php
// function to multiply 
// two numbers x and y
function multiply($x, $y)
{
/* 0 multiplied with 
anything gives 0 */
if($y == 0)
    return 0;
 
/* Add x one by one */
if($y > 0 )
    return ($x + multiply($x, 
                          $y - 1));
 
/* the case where 
y is negative */
if($y < 0 )
    return -multiply($x, -$y);
}
 
// Driver Code
echo multiply(5, -11);
 
// This code is contributed by mits.
?>

Javascript

<script>
 
// javascript program to Multiply two integers without 
// using multiplication, division and bitwise
//  operators, and no loops
  
/* function to multiply two numbers x and y*/
function multiply( x,  y)
{
    /* 0 multiplied with anything gives 0 */
    if(y == 0)
    return 0;
 
    /* Add x one by one */
    if(y > 0 )
    return (x + multiply(x, y-1));
 
    /* the case where y is negative */
    if(y < 0 )
    return -multiply(x, -y);
}
 
 
// Driver code
  
   document.write( multiply(5, -11));
 
// This code is contributed by todaysgaurav 
 
</script>

Output

-55

Time Complexity: O(y) where y is the second argument to function multiply().

Auxiliary Space: O(y) for the recursion stack

Another approach: The problem can also be solved using basic math property

(a+b)² = a² + b² + 2a*b

⇒ a*b = ((a+b)² – a² – b²) / 2

For computing the square of numbers, we can use the power function in C++ and for dividing by 2 in the above expression we can write a recursive function.

Below is the implementation of the above approach:

C++

// C++ program to Multiply two integers without
// using multiplication, division and bitwise
// operators, and no loops
#include<bits/stdc++.h>
using namespace std;
 
// divide a number by 2 recursively
int divideby2(int num)
{
   if(num<2)
    return 0;
   return 1 + divideby2(num-2);
}
 
int multiply(int a,int b)
{
    int whole_square=pow(a+b,2);
    int a_square=pow(a,2);
    int b_square=pow(b,2);
     
    int val= whole_square- a_square - b_square;
     
    int product;
     
    // for positive value of variable val
    if(val>=0)
    product = divideby2(val);
    // for negative value of variable val
    // we first compute the division by 2 for
    // positive val and by subtracting from 
    // 0 we can make it negative
    else
    product = 0 - divideby2(abs(val));
     
    return product;
}
 
// Driver code
int main()
{
    int a=5;
    int b=-11;
    cout << multiply(a,b);
    return 0;
}
 
// This code is contributed by Pushpesh raj.

Java

// Java program to Multiply two integers without
// using multiplication, division and bitwise
// operators, and no loops
import java.util.*;
class GFG {
 
  // divide a number by 2 recursively
  static int divideby2(int num)
  {
    if (num < 2)
      return 0;
    return 1 + divideby2(num - 2);
  }
 
  static int multiply(int a, int b)
  {
    int whole_square = (int)Math.pow(a + b, 2);
    int a_square = (int)Math.pow(a, 2);
    int b_square = (int)Math.pow(b, 2);
 
    int val = whole_square - a_square - b_square;
 
    int product;
 
    // for positive value of variable val
    if (val >= 0)
      product = divideby2(val);
    // for negative value of variable val
    // we first compute the division by 2 for
    // positive val and by subtracting from
    // 0 we can make it negative
    else
      product = 0 - divideby2(Math.abs(val));
 
    return product;
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int a = 5;
    int b = -11;
    System.out.println(multiply(a, b));
  }
}
 
// This code is contributed by phasing17

Python3

# Python3 program to Multiply two integers without
# using multiplication, division and bitwise
# operators, and no loops
 
# divide a number by 2 recursively
def divideby2(num):
 
    if(num < 2):
        return 0
    return 1 + divideby2(num-2)
 
def multiply(a, b):
    whole_square = (a + b) ** 2
    a_square = pow(a, 2)
    b_square = pow(b, 2)
 
    val = whole_square - a_square - b_square
 
    # for positive value of variable val
    if(val >= 0):
        product = divideby2(val)
         
    # for negative value of variable val
    # we first compute the division by 2 for
    # positive val and by subtracting from
    # 0 we can make it negative
    else:
        product = 0 - divideby2(abs(val))
 
    return product
 
# Driver code
a = 5
b = -11
print(multiply(a, b))
 
# This code is contributed by phasing17

C#

// C# program to Multiply two integers without
// using multiplication, division and bitwise
// operators, and no loops
 
using System;
 
class GFG {
 
  // divide a number by 2 recursively
  static int divideby2(int num)
  {
    if (num < 2)
      return 0;
    return 1 + divideby2(num - 2);
  }
 
  static int multiply(int a, int b)
  {
    int whole_square = (int)Math.Pow(a + b, 2);
    int a_square = (int)Math.Pow(a, 2);
    int b_square = (int)Math.Pow(b, 2);
 
    int val = whole_square - a_square - b_square;
 
    int product;
 
    // for positive value of variable val
    if (val >= 0)
      product = divideby2(val);
    // for negative value of variable val
    // we first compute the division by 2 for
    // positive val and by subtracting from
    // 0 we can make it negative
    else
      product = 0 - divideby2(Math.Abs(val));
 
    return product;
  }
 
  // Driver code
  public static void Main(string[] args)
  {
    int a = 5;
    int b = -11;
    Console.WriteLine(multiply(a, b));
  }
}
 
// This code is contributed by phasing17

Javascript

// JavaScript program to Multiply two integers without
// using multiplication, division and bitwise
// operators, and no loops
 
// divide a number by 2 recursively
function divideby2(num)
{
   if(num<2)
    return 0;
   return 1 + divideby2(num-2);
}
 
function multiply(a, b)
{
    let whole_square = Math.pow(a+b,2);
    let a_square = Math.pow(a,2);
    let b_square = Math.pow(b,2);
 
    let val = whole_square- a_square - b_square;
     
    let product;
     
    // for positive value of variable val
    if(val>=0)
    product = divideby2(val);
    // for negative value of variable val
    // we first compute the division by 2 for
    // positive val and by subtracting from 
    // 0 we can make it negative
    else
    product = 0 - divideby2(Math.abs(val));
     
    return product;
}
 
// Driver code
let a = 5;
let b = -11;
console.log(multiply(a,b));
 
// This code is contributed by phasing17

PHP

<?php
    
  // PHP program to Multiply two integers without
// using multiplication, division and bitwise
// operators, and no loops
 
// divide a number by 2 recursively
function divideby2($num)
{
   if($num < 2)
    return 0;
   return 1 + divideby2($num-2);
}
 
function multiply($a, $b)
{
    $whole_square = pow($a+$b,2);
    $a_square = pow($a,2);
    $b_square = pow($b,2);
 
    $val = $whole_square- $a_square - $b_square;
     
    $product;
     
    // for positive value of variable val
    if($val>=0)
    $product = divideby2($val);
    // for negative value of variable val
    // we first compute the division by 2 for
    // positive val and by subtracting from 
    // 0 we can make it negative
    else
    $product = 0 - divideby2(abs($val));
     
    return $product;
}
 
// Driver code
$a = 5;
$b = -11;
echo(multiply($a,$b));
   
// This code is contributed by laxmigangarajula03  
?>

Output

-55

Time complexity: O(num)

Auxiliary space: O(num) for recursive call stack

Russian Peasant (Multiply two numbers using bitwise operators)
Please write comments if you find any of the above code/algorithm incorrect, or find better ways to solve the same problem.

Queue using Stacks

kartik

Improve

Article Tags :

Practice Tags :

Mathematical

Multiply two integers without using multiplication, division and bitwise operators, and no loops

C++

C

Java

Python3

C#

PHP

Javascript

C++

Java

Python3

C#

Javascript

PHP

Similar Reads

Thank You!

What kind of Experience do you want to share?