Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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)2 = a2 + b2 + 2a*b

⇒  a*b = ((a+b)2 – a2 – b2) / 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.
 


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!


Last Updated : 19 Sep, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads
Complete Tutorials