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++ 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 |
#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;
} |
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. |
# 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. |
// 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 // 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. ?> |
<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> |
-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++ 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 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 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# 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 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 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 ?> |
-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.