# Write a program to calculate pow(x,n)

• Difficulty Level : Easy
• Last Updated : 19 Jul, 2022

Given two integers x and n, write a function to compute xn. We may assume that x and n are small and overflow doesn’t happen.  Examples :

```Input : x = 2, n = 3
Output : 8

Input : x = 7, n = 2
Output : 49```
Recommended Practice

Below solution divides the problem into subproblems of size y/2 and call the subproblems recursively.

## C++

 `// C++ program to calculate pow(x,n)``#include``using` `namespace` `std;``class` `gfg``{``    ` `/* Function to calculate x raised to the power y */``public``:``int` `power(``int` `x, unsigned ``int` `y)``{``    ``if` `(y == 0)``        ``return` `1;``    ``else` `if` `(y % 2 == 0)``        ``return` `power(x, y / 2) * power(x, y / 2);``    ``else``        ``return` `x * power(x, y / 2) * power(x, y / 2);``}``};` `/* Driver code */``int` `main()``{``    ``gfg g;``    ``int` `x = 2;``    ``unsigned ``int` `y = 3;` `    ``cout << g.power(x, y);``    ``return` `0;``}` `// This code is contributed by SoM15242`

## C

 `#include` `/* Function to calculate x raised to the power y */``int` `power(``int` `x, unsigned ``int` `y)``{``    ``if` `(y == 0)``        ``return` `1;``    ``else` `if` `(y%2 == 0)``        ``return` `power(x, y/2)*power(x, y/2);``    ``else``        ``return` `x*power(x, y/2)*power(x, y/2);``}` `/* Program to test function power */``int` `main()``{``    ``int` `x = 2;``    ``unsigned ``int` `y = 3;` `    ``printf``(``"%d"``, power(x, y));``    ``return` `0;``}`

## Java

 `class` `GFG {``    ``/* Function to calculate x raised to the power y */``    ``static` `int` `power(``int` `x, ``int` `y)``    ``{``        ``if` `(y == ``0``)``            ``return` `1``;``        ``else` `if` `(y % ``2` `== ``0``)``            ``return` `power(x, y / ``2``) * power(x, y / ``2``);``        ``else``            ``return` `x * power(x, y / ``2``) * power(x, y / ``2``);``    ``}` `    ``/* Program to test function power */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `y = ``3``;` `        ``System.out.printf(``"%d"``, power(x, y));``    ``}``}` `// This code is contributed by Smitha Dinesh Semwal`

## Python3

 `# Python3 program to calculate pow(x,n)` `# Function to calculate x``# raised to the power y``def` `power(x, y):` `    ``if` `(y ``=``=` `0``): ``return` `1``    ``elif` `(``int``(y ``%` `2``) ``=``=` `0``):``        ``return` `(power(x, ``int``(y ``/` `2``)) ``*``               ``power(x, ``int``(y ``/` `2``)))``    ``else``:``        ``return` `(x ``*` `power(x, ``int``(y ``/` `2``)) ``*``                   ``power(x, ``int``(y ``/` `2``)))` `# Driver Code``x ``=` `2``; y ``=` `3``print``(power(x, y))` `# This code is contributed by Smitha Dinesh Semwal.`

## C#

 `using` `System;` `public` `class` `GFG {``    ` `    ``// Function to calculate x raised to the power y``    ``static` `int` `power(``int` `x, ``int` `y)``    ``{``        ``if` `(y == 0)``            ``return` `1;``        ``else` `if` `(y % 2 == 0)``            ``return` `power(x, y / 2) * power(x, y / 2);``        ``else``            ``return` `x * power(x, y / 2) * power(x, y / 2);``    ``}` `    ``// Program to test function power``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 2;``        ``int` `y = 3;` `        ``Console.Write(power(x, y));``    ``}``}` `// This code is contributed by shiv_bhakt.`

## PHP

 ``

## Javascript

 ``

Output :

`8`

Time Complexity: O(n)
Space Complexity: O(1)

Above function can be optimized to O(logn) by calculating power(x, y/2) only once and storing it.

## C++

 `/* Function to calculate x raised to the power y in O(logn)*/``int` `power(``int` `x, unsigned ``int` `y)``{``    ``int` `temp;``    ``if``( y == 0)``        ``return` `1;``    ``temp = power(x, y / 2);``    ``if` `(y % 2 == 0)``        ``return` `temp * temp;``    ``else``        ``return` `x * temp * temp;``}` `// This code is contributed by Shubhamsingh10`

## C

 `/* Function to calculate x raised to the power y in O(logn)*/``int` `power(``int` `x, unsigned ``int` `y)``{``    ``int` `temp;``    ``if``( y == 0)``        ``return` `1;``    ``temp = power(x, y/2);``    ``if` `(y%2 == 0)``        ``return` `temp*temp;``    ``else``        ``return` `x*temp*temp;``}`

## Java

 `/* Function to calculate x raised to the power y in O(logn)*/``static` `int` `power(``int` `x, ``int` `y)``{``    ``int` `temp;``    ``if``( y == ``0``)``        ``return` `1``;``    ``temp = power(x, y / ``2``);``    ``if` `(y % ``2` `== ``0``)``        ``return` `temp*temp;``    ``else``        ``return` `x*temp*temp;``}` `// This code is contributed by divyeshrabadiya07.`

## Python3

 `# Function to calculate x raised to the power y in O(logn)``def` `power(x,y):``    ``temp ``=` `0``    ``if``( y ``=``=` `0``):``        ``return` `1``    ``temp ``=` `power(x, ``int``(y ``/` `2``))``    ``if` `(y ``%` `2` `=``=` `0``)``        ``return` `temp ``*` `temp;``    ``else``        ``return` `x ``*` `temp ``*` `temp;` `# This code is contributed by avanitrachhadiya2155`

## C#

 `/* Function to calculate x raised to the power y in O(logn)*/``static` `int` `power(``int` `x, ``int` `y)``{``    ``int` `temp;``    ``if``( y == 0)``        ``return` `1;``    ``temp = power(x, y / 2);``    ``if` `(y % 2 == 0)``        ``return` `temp*temp;``    ``else``        ``return` `x*temp*temp;``}` `// This code is contributed by divyesh072019.`

## Javascript

 ``

Time Complexity of optimized solution: O(log(n))

Auxiliary Space: O(log(n))

Let us extend the pow function to work for negative y and float x.

## C++

 `/* Extended version of power function``that can work for float x and negative y*/``#include ``using` `namespace` `std;` `float` `power(``float` `x, ``int` `y)``{``    ``float` `temp;``    ``if``(y == 0)``        ``return` `1;``    ``temp = power(x, y / 2);``    ``if` `(y % 2 == 0)``        ``return` `temp * temp;``    ``else``    ``{``        ``if``(y > 0)``            ``return` `x * temp * temp;``        ``else``            ``return` `(temp * temp) / x;``    ``}``}` `// Driver Code``int` `main()``{``    ``float` `x = 2;``    ``int` `y = -3;``    ``cout << power(x, y);``    ``return` `0;``}` `// This is code is contributed``// by rathbhupendra`

## C

 `/* Extended version of power function that can work`` ``for float x and negative y*/``#include` `float` `power(``float` `x, ``int` `y)``{``    ``float` `temp;``    ``if``( y == 0)``       ``return` `1;``    ``temp = power(x, y/2);      ``    ``if` `(y%2 == 0)``        ``return` `temp*temp;``    ``else``    ``{``        ``if``(y > 0)``            ``return` `x*temp*temp;``        ``else``            ``return` `(temp*temp)/x;``    ``}``} ` `/* Program to test function power */``int` `main()``{``    ``float` `x = 2;``    ``int` `y = -3;``    ``printf``(``"%f"``, power(x, y));``    ``return` `0;``}`

## Java

 `/* Java code for extended version of power function``that can work for float x and negative y */``class` `GFG {``    ` `    ``static` `float` `power(``float` `x, ``int` `y)``    ``{``        ``float` `temp;``        ``if``( y == ``0``)``            ``return` `1``;``        ``temp = power(x, y/``2``);``        ` `        ``if` `(y%``2` `== ``0``)``            ``return` `temp*temp;``        ``else``        ``{``            ``if``(y > ``0``)``                ``return` `x * temp * temp;``            ``else``                ``return` `(temp * temp) / x;``        ``}``    ``}``    ` `    ``/* Program to test function power */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``float` `x = ``2``;``        ``int` `y = -``3``;``        ``System.out.printf(``"%f"``, power(x, y));``    ``}``}` `// This code is contributed by  Smitha Dinesh Semwal.`

## Python3

 `# Python3 code for extended version``# of power function that can work``# for float x and negative y` `def` `power(x, y):` `    ``if``(y ``=``=` `0``): ``return` `1``    ``temp ``=` `power(x, ``int``(y ``/` `2``))``    ` `    ``if` `(y ``%` `2` `=``=` `0``):``        ``return` `temp ``*` `temp``    ``else``:``        ``if``(y > ``0``): ``return` `x ``*` `temp ``*` `temp``        ``else``: ``return` `(temp ``*` `temp) ``/` `x``    ` `# Driver Code``x, y ``=` `2``, ``-``3``print``(``'%.6f'` `%``(power(x, y)))` `# This code is contributed by Smitha Dinesh Semwal.`

## C#

 `// C# code for extended version of power function``// that can work for float x and negative y` `using` `System;` `public` `class` `GFG{``    ` `    ``static` `float` `power(``float` `x, ``int` `y)``    ``{``        ``float` `temp;``        ` `        ``if``( y == 0)``            ``return` `1;``        ``temp = power(x, y/2);``        ` `        ``if` `(y % 2 == 0)``            ``return` `temp * temp;``        ``else``        ``{``            ``if``(y > 0)``                ``return` `x * temp * temp;``            ``else``                ``return` `(temp * temp) / x;``        ``}``    ``}``    ` `    ``// Program to test function power``    ``public` `static` `void` `Main()``    ``{``        ``float` `x = 2;``        ``int` `y = -3;``        ` `        ``Console.Write(power(x, y));``    ``}``}` `// This code is contributed by shiv_bhakt.`

## PHP

 ` 0)``            ``return` `\$x` `*``                   ``\$temp` `* ``\$temp``;``        ``else``            ``return` `(``\$temp` `*``                    ``\$temp``) / ``\$x``;``    ``}``}` `// Driver Code``\$x` `= 2;``\$y` `= -3;``echo` `power(``\$x``, ``\$y``);` `// This code is contributed by ajit``?>`

## Javascript

 ``

Output :

`0.125000`

Time Complexity: O(log|n|)

Auxiliary Space: O(1)

Using recursion:

This approach is almost similar to iterative solution

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `power(``int` `x, ``int` `y)``{``    ``// If x^0 return 1``    ``if` `(y == 0)``        ``return` `1;``    ``// If we need to find of 0^y``    ``if` `(x == 0)``        ``return` `0;``    ``// For all other cases``    ``return` `x * power(x, y - 1);``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `y = 3;``    ``cout << (power(x, y));``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program for the above approach``#include ` `int` `power(``int` `x, ``int` `y)``{``    ``// If x^0 return 1``    ``if` `(y == 0)``        ``return` `1;``    ``// If we need to find of 0^y``    ``if` `(x == 0)``        ``return` `0;``    ``// For all other cases``    ``return` `x * power(x, y - 1);``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `y = 3;``    ``printf``(``"%d\n"``,power(x, y));``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {``    ``public` `static` `int` `power(``int` `x, ``int` `y)``    ``{``        ` `        ``// If x^0 return 1``        ``if` `(y == ``0``)``            ``return` `1``;``        ` `        ``// If we need to find of 0^y``        ``if` `(x == ``0``)``            ``return` `0``;``        ` `        ``// For all other cases``        ``return` `x * power(x, y - ``1``);``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `y = ``3``;` `        ``System.out.println(power(x, y));``    ``}``}`

## Python3

 `# Python3 program for the above approach``def` `power(x, y):``    ` `    ``# If x^0 return 1``    ``if` `(y ``=``=` `0``):``        ``return` `1``    ` `    ``# If we need to find of 0^y``    ``if` `(x ``=``=` `0``):``        ``return` `0``    ` `    ``# For all other cases``    ``return` `x ``*` `power(x, y ``-` `1``)`` ` `# Driver Code``x ``=` `2``y ``=` `3` `print``(power(x, y))` `# This code is contributed by shivani.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `public` `static` `int` `power(``int` `x, ``int` `y)``{``    ` `    ``// If x^0 return 1``    ``if` `(y == 0)``        ``return` `1;``    ` `    ``// If we need to find of 0^y``    ``if` `(x == 0)``        ``return` `0;``    ` `    ``// For all other cases``    ``return` `x * power(x, y - 1);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `x = 2;``    ``int` `y = 3;` `    ``Console.WriteLine(power(x, y));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`8`

Time Complexity: O(n)

Auxiliary Space: O(n)

Using Math.pow() function of java:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `power(``int` `x, ``int` `y)``{``    ` `    ``// return type of pow()``    ``// function is double``    ``return` `(``int``)``pow``(x, y);``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `y = 3;` `    ``cout << (power(x, y));``}` `// This code is contributed by hemantraj712.`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {``    ``public` `static` `int` `power(``int` `x, ``int` `y)``    ``{``        ` `        ``// Math.pow() is a function that``        ``// return floating number``        ``return` `(``int``)Math.pow(x, y);``    ``}``  ` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `y = ``3``;` `        ``System.out.println(power(x, y));``    ``}``}`

## Python3

 `# Python3 program for the above approach``def` `power(x, y):``    ` `    ``# Return type of pow()``    ``# function is double``    ``return` `pow``(x, y)``    ` `# Driver Code``x ``=` `2``y ``=` `3` `print``(power(x, y))` `# This code is contributed by susmitakundugoaldanga`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG {` `    ``public` `static` `int` `power(``int` `x, ``int` `y)``    ``{``         ` `        ``// Math.pow() is a function that``        ``// return floating number``        ``return` `(``int``)Math.Pow(x, y);``    ``}` `    ``// Driver code``    ``static` `public` `void` `Main()``    ``{``        ``int` `x = 2;``        ``int` `y = 3;`` ` `        ``Console.WriteLine(power(x, y));``    ``}``}`

## Javascript

 ``

Output:

`8`

Time Complexity: O(1)

Auxiliary Space: O(1)

Iterative approach : Binary explanation

Some important concepts related to this approach:

• Every number can be written as the sum of powers of 2
• We can traverse through all the bits of a number from LSB to MSB in O(log(n)) time.

For example :

3^10 = 3^8 * 3^2 ; (10 in binary can be represented as : 1010 , where from left side the first 1 represents 3^2 and second 1 represents 3^8 )

3^19 = 3^16 * 3^2 * 3 ; (19 in binary can be represented as : 10011 , where from left side the first 1 represents 3^1 and second 1 represents 3^2 and the

third one represents 3^16 )

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `power(``int` `x, ``int` `y)``{``    ``int` `result = 1;``    ``while` `(y > 0) {``      ``if``(y&1==1) ``// y is odd``      ``{``        ``result=result*x;``      ``}``      ``x=x*x;``      ``y=y>>1; ``// y=y/2;``    ``}``    ``return` `result;``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `y = 3;` `    ``cout << (power(2, 3));``    ``return` `0;``}` `// This code is contributed bySuruchi Kumari`

## Java

 `// Java program for above approach``class` `GFG{` `static` `int` `power(``int` `x, ``int` `y)``{``    ``int` `result = ``1``;``    ``while` `(y > ``0``) {``      ``if``(y%``2``!=``0``) ``// y is odd``      ``{``        ``result=result*x;``      ``}``      ``x=x*x;``      ``y=y>>``1``; ``// y=y/2;``    ``}``    ``return` `result;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `x = ``2``;``    ``int` `y = ``3``;``    ` `    ``System.out.println(power(x, y));``}``}` `// This code is contributed by Suruchi Kumari`

## Python3

 `# Python program for the above approach``def` `power( x, y):` `    ``result ``=` `1``    ``while` `(y > ``0``):``        ``if` `(y ``%` `2` `=``=` `0``):``        ``# y is even``        ` `            ``x ``=` `x ``*` `x``            ``y ``=` `y ``/` `2``        ` `        ``else``:``        ``# y isn't even``        ` `            ``result ``=` `result ``*` `x``            ``y ``=` `y ``-` `1``        ` `    ` `    ``return` `result`  `# Driver Code``x ``=` `2``y ``=` `3``print``((power(x, y)))` `# This code is contributed by shivanisinghss2110`

## C#

 `// C# program for above approach``using` `System;` `class` `GFG{` `static` `int` `power(``int` `x, ``int` `y)``{``    ``int` `result = 1;``    ` `    ``while` `(y > 0)``    ``{``        ` `        ``// y is even``        ``if` `(y % 2 == 0)``        ``{``            ``x = x * x;``            ``y = y / 2;``        ``}``        ` `        ``// y isn't even``        ``else``        ``{``            ``result = result * x;``            ``y = y - 1;``        ``}``    ``}``    ``return` `result;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `x = 2;``    ``int` `y = 3;``    ` `    ``Console.Write(power(x, y));``}``}` `// This code is contributed by shivanisinghss2110`

## Javascript

 ``

Output

`8`

Time Complexity: O(log2y)

Auxiliary Space: O(1)

Write an iterative O(Log y) function for pow(x, y)
Modular Exponentiation (Power in Modular Arithmetic)
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.