# Write you own Power without using multiplication(*) and division(/) operators

Method 1 (Using Nested Loops): We can calculate power by using repeated addition. For example to calculate 5^6.

1) First 5 times add 5, we get 25. (5^2)
2) Then 5 times add 25, we get 125. (5^3)
3) Then 5 times add 125, we get 625 (5^4)
4) Then 5 times add 625, we get 3125 (5^5)
5) Then 5 times add 3125, we get 15625 (5^6)

## C++

 `// C++ code for power function ` `#include ` `using` `namespace` `std;`   `/* Works only if a >= 0 and b >= 0 */` `int` `pow``(``int` `a, ``int` `b) ` `{ ` `    ``if` `(b == 0) ` `        ``return` `1; ` `    ``int` `answer = a; ` `    ``int` `increment = a; ` `    ``int` `i, j; ` `    ``for``(i = 1; i < b; i++) ` `    ``{ ` `        ``for``(j = 1; j < a; j++) ` `        ``{ ` `            ``answer += increment; ` `        ``} ` `        ``increment = answer; ` `    ``} ` `    ``return` `answer; ` `} `   `// Driver Code` `int` `main() ` `{ ` `    ``cout << ``pow``(5, 3); ` `    ``return` `0; ` `} `   `// This code is contributed ` `// by rathbhupendra`

## C

 `#include` `/* Works only if a >= 0 and b >= 0  */` `int` `pow``(``int` `a, ``int` `b)` `{` `  ``//base case : anything raised to the power 0 is 1` `  ``if` `(b == 0)` `    ``return` `1;` `  ``int` `answer = a;` `  ``int` `increment = a;` `  ``int` `i, j;` `  ``for``(i = 1; i < b; i++)` `  ``{` `     ``for``(j = 1; j < a; j++)` `     ``{` `        ``answer += increment;` `     ``}` `     ``increment = answer;` `  ``}` `  ``return` `answer;` `}`   `/* driver program to test above function */` `int` `main()` `{` `  ``printf``(``"\n %d"``, ``pow``(5, 3));` `  ``getchar``();` `  ``return` `0;` `}`

## Java

 `import` `java.io.*;`   `class` `GFG {` `    `  `    ``/* Works only if a >= 0 and b >= 0 */` `    ``static` `int` `pow(``int` `a, ``int` `b)` `    ``{` `        ``if` `(b == ``0``)` `            ``return` `1``;` `            `  `        ``int` `answer = a;` `        ``int` `increment = a;` `        ``int` `i, j;` `        `  `        ``for` `(i = ``1``; i < b; i++) {` `            ``for` `(j = ``1``; j < a; j++) {` `                ``answer += increment;` `            ``}` `            ``increment = answer;` `        ``}` `        `  `        ``return` `answer;` `    ``}`   `    ``// driver program to test above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``System.out.println(pow(``5``, ``3``));` `    ``}` `}`   `// This code is contributed by vt_m.`

## Python

 `# Python 3 code for power` `# function `   `# Works only if a >= 0 and b >= 0 ` `def` `pow``(a,b):` `    ``if``(b``=``=``0``):` `        ``return` `1` `        `  `    ``answer``=``a` `    ``increment``=``a` `    `  `    ``for` `i ``in` `range``(``1``,b):` `        ``for` `j ``in` `range` `(``1``,a):` `            ``answer``+``=``increment` `        ``increment``=``answer` `    ``return` `answer`   `# driver code` `print``(``pow``(``5``,``3``))`   `# this code is contributed ` `# by Sam007`

## C#

 `using` `System;`   `class` `GFG` `{` `    ``/* Works only if a >= 0 and b >= 0 */` `    ``static` `int` `pow(``int` `a, ``int` `b)` `    ``{` `        ``if` `(b == 0)` `            ``return` `1;` `            `  `        ``int` `answer = a;` `        ``int` `increment = a;` `        ``int` `i, j;` `        `  `        ``for` `(i = 1; i < b; i++) {` `            ``for` `(j = 1; j < a; j++) {` `                ``answer += increment;` `            ``}` `            ``increment = answer;` `        ``}` `        `  `        ``return` `answer;` `    ``}`   `    ``// driver program to test ` `    ``// above function` `    ``public` `static` `void` `Main()` `    ``{` `        ``Console.Write(pow(5, 3));` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 `= 0 ` `// and b >= 0 ` `function` `poww(``\$a``, ``\$b``)` `{` `    ``if` `(``\$b` `== 0)` `        ``return` `1;` `    ``\$answer` `= ``\$a``;` `    ``\$increment` `= ``\$a``;` `    ``\$i``;` `    ``\$j``;` `    ``for``(``\$i` `= 1; ``\$i` `< ``\$b``; ``\$i``++)` `    ``{` `        ``for``(``\$j` `= 1; ``\$j` `< ``\$a``; ``\$j``++)` `        ``{` `            ``\$answer` `+= ``\$increment``;` `        ``}` `        ``\$increment` `= ``\$answer``;` `    ``}` `    ``return` `\$answer``;` `}`   `    ``// Driver Code` `    ``echo``( poww(5, 3));` ` `  `// This code is contributed by nitin mittal.` `?>`

## Javascript

 ``

Output :

`125`

Time Complexity: O(a * b)

Auxiliary Space: O(1)

Method 2 (Using Recursion): Recursively add a to get the multiplication of two numbers. And recursively multiply to get a raise to the power b.

## C++

 `#include` `using` `namespace` `std;`   `/* A recursive function to get x*y */` `int` `multiply(``int` `x, ``int` `y)` `{` `    ``if``(y)` `        ``return` `(x + multiply(x, y - 1));` `    ``else` `        ``return` `0;` `}`   `/* A recursive function to get a^b` `Works only if a >= 0 and b >= 0 */` `int` `pow``(``int` `a, ``int` `b)` `{` `    ``if``(b)` `        ``return` `multiply(a, ``pow``(a, b - 1));` `    ``else` `        ``return` `1;` `} `   `// Driver Code` `int` `main()` `{` `    ``cout << ``pow``(5, 3);` `    ``getchar``();` `    ``return` `0;` `}`   `// This code is contributed ` `// by Akanksha Rai`

## C

 `#include` `/* A recursive function to get a^b` `  ``Works only if a >= 0 and b >= 0  */` `int` `pow``(``int` `a, ``int` `b)` `{` `   ``if``(b)` `     ``return` `multiply(a, ``pow``(a, b-1));` `   ``else` `    ``return` `1;` `}    `   `/* A recursive function to get x*y */` `int` `multiply(``int` `x, ``int` `y)` `{` `   ``if``(y)` `     ``return` `(x + multiply(x, y-1));` `   ``else` `     ``return` `0;` `}`   `/* driver program to test above functions */` `int` `main()` `{` `  ``printf``(``"\n %d"``, ``pow``(5, 3));` `  ``getchar``();` `  ``return` `0;` `}`

## Java

 `import` `java.io.*;`   `class` `GFG {` `    `  `    ``/* A recursive function to get a^b` `    ``Works only if a >= 0 and b >= 0 */` `    ``static` `int` `pow(``int` `a, ``int` `b)` `    ``{` `        `  `        ``if` `(b > ``0``)` `            ``return` `multiply(a, pow(a, b - ``1``));` `        ``else` `            ``return` `1``;` `    ``}`   `    ``/* A recursive function to get x*y */` `    ``static` `int` `multiply(``int` `x, ``int` `y)` `    ``{` `        `  `        ``if` `(y > ``0``)` `            ``return` `(x + multiply(x, y - ``1``));` `        ``else` `            ``return` `0``;` `    ``}`   `    ``/* driver program to test above functions */` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``System.out.println(pow(``5``, ``3``));` `    ``}` `}`   `// This code is contributed by vt_m.`

## Python3

 `def` `pow``(a,b):` `    `  `    ``if``(b):` `        ``return` `multiply(a, ``pow``(a, b``-``1``));` `    ``else``:` `        ``return` `1``;` `     `  `# A recursive function to get x*y *` `def` `multiply(x, y):` `    `  `    ``if` `(y):` `        ``return` `(x ``+` `multiply(x, y``-``1``));` `    ``else``:` `        ``return` `0``;`   `# driver program to test above functions *` `print``(``pow``(``5``, ``3``));`     `# This code is contributed` `# by Sam007`

## C#

 `using` `System;`   `class` `GFG` `{` `    ``/* A recursive function to get a^b` `    ``Works only if a >= 0 and b >= 0 */` `    ``static` `int` `pow(``int` `a, ``int` `b)` `    ``{` `        `  `        ``if` `(b > 0)` `            ``return` `multiply(a, pow(a, b - 1));` `        ``else` `            ``return` `1;` `    ``}`   `    ``/* A recursive function to get x*y */` `    ``static` `int` `multiply(``int` `x, ``int` `y)` `    ``{` `        `  `        ``if` `(y > 0)` `            ``return` `(x + multiply(x, y - 1));` `        ``else` `            ``return` `0;` `    ``}`   `    ``/* driver program to test above functions */` `    ``public` `static` `void` `Main()` `    ``{` `        ``Console.Write(pow(5, 3));` `    ``}` `}`   `// This code is contributed by Sam007`

## PHP

 `= 0 and b >= 0 */` `function` `p_ow( ``\$a``, ``\$b``)` `{` `    ``if``(``\$b``)` `        ``return` `multiply(``\$a``, ` `          ``p_ow(``\$a``, ``\$b` `- 1));` `    ``else` `        ``return` `1;` `} `   `/* A recursive function ` `   ``to get x*y */` `function` `multiply(``\$x``, ``\$y``)` `{` `    ``if``(``\$y``)` `        ``return` `(``\$x` `+ multiply(``\$x``, ``\$y` `- 1));` `    ``else` `        ``return` `0;` `}`   `// Driver Code` `echo` `pow(5, 3);`   `// This code is contributed by anuj_67.` `?>`

## Javascript

 ``

Output :

`125`

Time Complexity: O(b)

Auxiliary Space: O(b)

Approach: We can a^n (let’s say 3^5) as 3^4 * 3^0 * 3^1 = 3^5, so we can represent 5 as its binary i.e. 101

## C++

 `#include ` `using` `namespace` `std;`   `//function calculating power` `long` `long` `pow``(``int` `a, ``int` `n){` `    ``int` `ans=1;` `      ``while``(n>0){` `          ``// calculate last bit(right most) bit of n` `        ``int` `last_bit = n&1;` `          `  `          ``//if last bit is 1 then multiply ans and a` `          ``if``(last_bit){` `            ``ans = ans*a;` `        ``}` `      `  `      ``//make a equal to square of a as on every succeeding bit it got squared like a^0, a^1, a^2, a^4, a^8` `      ``a = a*a;` `      ``n = n >> 1;` `    ``}` `      ``return` `ans;` `}`   `//driver code` `int` `main() {`   `    ``cout<<``pow``(3,5);` `    ``return` `0;` `}`

## C

 `#include `   `// function calculating power` `long` `long` `pow_(``int` `a, ``int` `n){` `  ``int` `ans = 1;` `  ``while``(n > 0)` `  ``{` `    `  `    ``// calculate last bit(right most) bit of n` `    ``int` `last_bit = n&1;`   `    ``// if last bit is 1 then multiply ans and a` `    ``if``(last_bit){` `      ``ans = ans*a;` `    ``}`   `    ``//make a equal to square of a as on every succeeding bit it got squared like a^0, a^1, a^2, a^4, a^8` `    ``a = a*a;` `    ``n = n >> 1;` `  ``}` `  ``return` `ans;` `}`   `// driver code` `int` `main() ` `{`   `  ``// pow is an inbuilt function so I have used pow_ as a function name` `  ``printf``(``"%lld"``,pow_(3,5));` `  ``return` `0;` `}`   `// This code is contributed by akashish_.`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG` `{`   `// function calculating power` `static` `int` `pow(``int` `a, ``int` `n){` `    ``int` `ans = ``1``;` `      ``while``(n > ``0``)` `      ``{` `        `  `          ``// calculate last bit(right most) bit of n` `        ``int` `last_bit = n&``1``;` `           `  `          ``//if last bit is 1 then multiply ans and a` `          ``if``(last_bit != ``0``){` `            ``ans = ans*a;` `        ``}` `       `  `      ``//make a equal to square of a as on every succeeding bit it got squared like a^0, a^1, a^2, a^4, a^8` `      ``a = a*a;` `      ``n = n >> ``1``;` `    ``}` `      ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``System.out.print(pow(``3``,``5``));` `}` `}`   `// This code is contributed by code_hunt.`

## Python3

 `# function calculating power` `def` `pow``(a, n):` `    ``ans ``=` `1` `    ``while``(n > ``0``):` `      `  `        ``#  calculate last bit(right most) bit of n` `        ``last_bit ``=` `n&``1` `          `  `        ``# if last bit is 1 then multiply ans and a` `        ``if``(last_bit):` `            ``ans ``=` `ans``*``a` `      `  `        ``# make a equal to square of a as on ` `        ``# every succeeding bit it got squared ` `        ``# like a^0, a^1, a^2, a^4, a^8` `        ``a ``=` `a``*``a` `        ``n ``=` `n >> ``1` `    ``return` `ans`   `# driver code` `print``(``pow``(``3``, ``5``))`   `# This code is contributed by shinjanpatra`

## C#

 `// C# code to implement the approach` `using` `System;` `using` `System.Numerics;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `// function calculating power` `static` `int` `pow(``int` `a, ``int` `n){` `    ``int` `ans = 1;` `      ``while``(n > 0)` `      ``{` `        `  `          ``// calculate last bit(right most) bit of n` `        ``int` `last_bit = n&1;` `           `  `          ``//if last bit is 1 then multiply ans and a` `          ``if``(last_bit != 0){` `            ``ans = ans*a;` `        ``}` `       `  `      ``//make a equal to square of a as on every succeeding bit it got squared like a^0, a^1, a^2, a^4, a^8` `      ``a = a*a;` `      ``n = n >> 1;` `    ``}` `      ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``Console.Write(pow(3,5));` `}` `}`   `// This code is contributed by sanjoy_62.`

## Javascript

 ``

## PHP

 ` 0)` `    ``{` `    `  `        ``// calculate last bit(right most) bit of n` `        ``\$last_bit` `= ``\$n``&1;` `          `  `        ``// if last bit is 1 then multiply ans and a` `        ``if``(``\$last_bit``)` `        ``{` `            ``\$ans` `= ``\$ans``*``\$a``;` `        ``}` `      `  `        ``// make a equal to square of a as on ` `        ``// every succeeding bit it got squared` `        ``// like a^0, a^1, a^2, a^4, a^8` `        ``\$a` `= ``\$a``*``\$a``;` `        ``\$n` `= ``\$n` `>> 1;` `    ``}` `    ``return` `\$ans``;` `}`   `// driver code` `echo``(p_ow(5,3));` `  `  `  `  `?>`

Time Complexity: O(log n)

Auxiliary Space: O(1)

Please write comments if you find any bug in the above code/algorithm, or find other ways to solve the same problem.

Method 4 (Using Exponentiation by Squaring):

This method is based on the idea that the result of a^b can be obtained by dividing the problem into smaller sub-problems of size b/2 and solving them recursively.

Algorithm:

1. If b==0, return 1.
2. If b is even, return pow(a*a, b/2).
3. If b is odd, return apow(aa, (b-1)/2).

## C++

 `#include ` `using` `namespace` `std;`   `int` `Pow(``int` `a, ``int` `b) {` `  ``if` `(b == 0) {` `      ``return` `1;` `  ``}` `  ``if` `(b % 2 == 0) {` `      ``return` `Pow(a * a, b / 2);` `  ``}` `  ``else` `{` `      ``return` `a * Pow(a * a, (b - 1) / 2);` `  ``}` `}`   `int` `main() {` `cout << Pow(5, 3); ``// Output: 125` `return` `0;` `}` `// This code is contributed by shivhack999`

## Java

 `public` `class` `Main {` `    ``public` `static` `long` `pow(``long` `a, ``long` `b)` `    ``{` `        ``if` `(b == ``0``) {` `            ``return` `1``;` `        ``}` `        ``if` `(b % ``2` `== ``0``) {` `            ``return` `pow(a * a, b / ``2``);` `        ``}` `        ``else` `{` `            ``return` `a * pow(a * a, (b - ``1``) / ``2``);` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``System.out.println(pow(``5``, ``3``)); ``// Output: 125` `    ``}` `}` `// This code is contributed by user_dtewbxkn77n`

## Python3

 `def` `pow``(a, b):` `    ``if` `b ``=``=` `0``:` `        ``return` `1` `    ``if` `b ``%` `2` `=``=` `0``:` `        ``return` `pow``(a``*``a, b``/``/``2``)` `    ``else``:` `        ``return` `a``*``pow``(a``*``a, (b``-``1``)``/``/``2``)`   `print``(``pow``(``5``,``3``)) ``# Output: 125`

## C#

 `using` `System;`   `class` `Program {` `    ``static` `int` `Pow(``int` `a, ``int` `b)` `    ``{` `        ``if` `(b == 0) {` `            ``return` `1;` `        ``}` `        ``if` `(b % 2 == 0) {` `            ``return` `Pow(a * a, b / 2);` `        ``}` `        ``else` `{` `            ``return` `a * Pow(a * a, (b - 1) / 2);` `        ``}` `    ``}`   `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``Console.WriteLine(Pow(5, 3)); ``// Output: 125` `    ``}` `}`

## Javascript

 `function` `pow(a, b) {` `    ``if` `(b == 0) {` `        ``return` `1;` `    ``}` `    ``if` `(b % 2 == 0) {` `        ``return` `pow(a * a, b / 2);` `    ``} ``else` `{` `        ``return` `a * pow(a * a, (b - 1) / 2);` `    ``}` `}`   `console.log(pow(5, 3)); ``// Output: 125`

Output

`125`

Time complexity of the above pow function is O(log b) because the function is dividing the problem into half in each recursive call.

The auxiliary space or space complexity of the function is also O(log b) because the maximum number of recursive calls will be equal to the log base 2 of the input value b.

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