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

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`   `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` `/* 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

 ` 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

 ``

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` `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

 `=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!

Previous
Next