Open In App
Related Articles

# Write program to calculate pow(x, n)

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

Naive Approach: To solve the problem follow the below idea:

A simple solution to calculate pow(x, n) would multiply x exactly n times. We can do that by using a simple for loop

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Naive iterative solution to calculate pow(x, n)``long` `power(``int` `x, unsigned n)``{``    ``// Initialize result to 1``    ``long` `long` `pow` `= 1;` `    ``// Multiply x for n times``    ``for` `(``int` `i = 0; i < n; i++) {``        ``pow` `= ``pow` `* x;``    ``}` `    ``return` `pow``;``}` `// Driver code``int` `main(``void``)``{` `    ``int` `x = 2;``    ``unsigned n = 3;` `    ``// Function call``    ``int` `result = power(x, n);``    ``cout << result << endl;` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `Gfg {` `    ``// Naive iterative solution to calculate pow(x, n)``    ``public` `static` `long` `power(``int` `x, ``int` `n)``    ``{``        ``// Initialize result by 1``        ``long` `pow = 1L;` `        ``// Multiply x for n times``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``pow = pow * x;``        ``}` `        ``return` `pow;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `n = ``3``;``        ``System.out.println(power(x, n));``    ``}``};`

## Python

 `# Python3 program for the above approach``def` `power(x, n):` `    ``# initialize result by 1``    ``pow` `=` `1` `    ``# Multiply x for n times``    ``for` `i ``in` `range``(n):``        ``pow` `=` `pow` `*` `x` `    ``return` `pow`  `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``x ``=` `2``    ``n ``=` `3` `       ``# Function call``    ``print``(power(x, n))`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `Gfg {` `    ``// Naive iterative solution to calculate pow(x, n)``    ``static` `long` `power(``int` `x, ``int` `n)``    ``{``        ``// Initialize result by 1``        ``long` `pow = 1L;` `        ``// Multiply x for n times``        ``for` `(``int` `i = 0; i < n; i++) {``            ``pow = pow * x;``        ``}` `        ``return` `pow;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `x = 2;``        ``int` `n = 3;``        ``Console.WriteLine(power(x, n));``    ``}``};` `// This code contributed by Pushpesh Raj`

## Javascript

 `// Naive iterative solution to calculate pow(x, n)``function` `power( x, n)``{``    ``// Initialize result to 1``    ``let pow = 1;` `    ``// Multiply x for n times``    ``for` `(let i = 0; i < n; i++) {``        ``pow = pow * x;``    ``}` `    ``return` `pow;``}` `// Driver code` `    ``let x = 2;``    ``let n = 3;` `    ``// Function call``    ``let result = power(x, n);``    ``console.log( result );` `// This code is contributed by garg28harsh.`

Output

```8

```

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

### pow(x, n) using recursion:

We can use the same approach as above but instead of an iterative loop, we can use recursion for the purpose.

## C++

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

## C

 `// C program for the above approach``#include ` `int` `power(``int` `x, ``int` `n)``{``    ``// If x^0 return 1``    ``if` `(n == 0)``        ``return` `1;` `    ``// If we need to find of 0^y``    ``if` `(x == 0)``        ``return` `0;``    ``// For all other cases``    ``return` `x * power(x, n - 1);``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `n = 3;` `    ``// Function call``    ``printf``(``"%d\n"``, power(x, n));``}` `// 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` `n)``    ``{` `        ``// If x^0 return 1``        ``if` `(n == ``0``)``            ``return` `1``;` `        ``// If we need to find of 0^y``        ``if` `(x == ``0``)``            ``return` `0``;` `        ``// For all other cases``        ``return` `x * power(x, n - ``1``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `n = ``3``;` `        ``// Function call``        ``System.out.println(power(x, n));``    ``}``}`

## Python3

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

## C#

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

## Javascript

 ``

Output

```8

```

Time Complexity: O(n)
Auxiliary Space: O(n) n is the size of the recursion stack

## Program to calculate pow(x, n) using Divide and Conqueror approach:

To solve the problem follow the below idea:

The problem can be recursively defined by:

• power(x, n) = power(x, n / 2) * power(x, n / 2);        // if n is even
• power(x, n) = x * power(x, n / 2) * power(x, n / 2);    // if n is odd

Below is the implementation of the above approach:

## 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;` `    ``// Function call``    ``cout << g.power(x, y);``    ``return` `0;``}` `// This code is contributed by SoM15242`

## C

 `// C program to calculate pow(x,n)``#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);``}` `/* Driver code */``int` `main()``{``    ``int` `x = 2;``    ``unsigned ``int` `y = 3;` `    ``// Function call``    ``printf``(``"%d"``, power(x, y));``    ``return` `0;``}`

## Java

 `// Java program to calculate pow(x,n)` `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``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `y = ``3``;` `        ``// Function call``        ``System.out.printf(``"%d"``, power(x, y));``    ``}``}` `// This code is contributed by Smitha Dinesh Semwal`

## Python

 `# 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``if` `__name__ ``=``=` `"__main__"``:``    ``x ``=` `2``    ``y ``=` `3` `    ``# Function call``    ``print``(power(x, y))` `# This code is contributed by Smitha Dinesh Semwal.`

## C#

 `// C# program to calculate pow(x,n)` `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);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 2;``        ``int` `y = 3;` `        ``// Function call``        ``Console.Write(power(x, y));``    ``}``}` `// This code is contributed by shiv_bhakt.`

## Javascript

 ``

## PHP

 ``

Output

```8

```

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

### An Optimized Divide and Conquer Solution:

To solve the problem follow the below idea:

There is a problem with the above solution, the same subproblem is computed twice for each recursive call. We can optimize the above function by computing the solution of the subproblem once only.

Below is the implementation of the above approach:

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

 ``

Output

```8

```

Time Complexity: O(log n)
Auxiliary Space: O(log n), for recursive call stack

### Extend the pow function to work for negative n and float x:

Below is the implementation of the above approach:

## 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;` `    ``// Function call``    ``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;``    ``}``}` `/* Driver code */``int` `main()``{``    ``float` `x = 2;``    ``int` `y = -3;` `    ``// Function call``    ``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;``        ``}``    ``}` `    ``/* Driver code */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``float` `x = ``2``;``        ``int` `y = -``3``;` `        ``// Function call``        ``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``if` `__name__ ``=``=` `"__main__"``:``    ``x, y ``=` `2``, ``-``3` `    ``# Function call``    ``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;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``float` `x = 2;``        ``int` `y = -3;` `        ``// Function call``        ``Console.Write(power(x, y));``    ``}``}` `// This code is contributed by shiv_bhakt.`

## Javascript

 ``

## PHP

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

Output

```0.125

```

Time Complexity: O(log |n|)
Auxiliary Space: O(log |n|) , for recursive call stack

## Program to calculate pow(x,n) using inbuilt power function:

To solve the problem follow the below idea:

We can use inbuilt power function pow(x, n) to calculate xn

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `power(``int` `x, ``int` `n)``{` `    ``// return type of pow()``    ``// function is double``    ``return` `(``int``)``pow``(x, n);``}` `// Driver Code``int` `main()``{``    ``int` `x = 2;``    ``int` `n = 3;` `    ``// Function call``    ``cout << (power(x, n));``}` `// 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` `n)``    ``{` `        ``// Math.pow() is a function that``        ``// return floating number``        ``return` `(``int``)Math.pow(x, n);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``2``;``        ``int` `n = ``3``;` `        ``// Function call``        ``System.out.println(power(x, n));``    ``}``}`

## Python3

 `# Python3 program for the above approach``def` `power(x, n):` `    ``# Return type of pow()``    ``# function is double``    ``return` `pow``(x, n)`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``x ``=` `2``    ``n ``=` `3` `    ``# Function call``    ``print``(power(x, n))` `# 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` `n)``    ``{` `        ``// Math.pow() is a function that``        ``// return floating number``        ``return` `(``int``)Math.Pow(x, n);``    ``}` `    ``// Driver code``    ``static` `public` `void` `Main()``    ``{``        ``int` `x = 2;``        ``int` `n = 3;` `        ``// Function call``        ``Console.WriteLine(power(x, n));``    ``}``}`

## Javascript

 ``

Output

```8

```

Time Complexity: O(log n)
Auxiliary Space: O(1), for recursive call stack

## Program to calculate pow(x,n) using Binary operators:

To solve the problem follow the below idea:

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.

Illustration:

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

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

Below is the implementation of the above approach.

## C++

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

## Java

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

## Python3

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

## C#

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

## Javascript

 ``

Output

```8

```

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

## Program to calculate pow(x,n) using Python ** operator:

To solve the problem follow the below idea:

In Python language, we can easily find power of a number using ** operator.

Below is the implementation of the above approach.

## Python3

 `# Python program to illustrate use of ** operator``# to calculate power of a number``def` `power(x, n):` `    ``# Calculate the power``    ``return` `x``*``*``n`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``x ``=` `2``    ``n ``=` `3` `    ``# Function call``    ``print``(power(x, n))` `# This code is contributed by Susobhan Akhuli`

Output

```8

```

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

## Program to calculate pow(x,n) using Python numpy module:

We can install NumPy by running the following command:

`pip install numpy`

To solve the problem follow the below idea:

In Python language, we can easily find power of a number using the NumPy library’s “power” function. This function allows you to calculate the power of a number using a single line of code.

Below is the implementation of the above approach.

## Python3

 `import` `numpy as np` `N ``=` `2``X ``=` `3``result ``=` `np.power(N, X)``print``(result) ``# Output: 8` `#This code is contributed by Susobhan Akhuli`

Output

`8`

## Program to calculate pow(x,n) using math.log2() and ** operator:

Here, we can use the math.log2() in combination with the operator “**” to calculate the power of a number.

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `calculatePower(``int` `a, ``int` `n) {``    ``return` `round(``pow``(2, (log2(a) * n)));``}` `int` `main() {``    ``int` `a = 2;``    ``int` `n = 3;``    ``cout << calculatePower(a, n) << endl;``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``    ``// Function to calculate a^n using log2 and pow methods``    ``public` `static` `int` `calculatePower(``int` `a, ``int` `n) {``        ``// Calculate a^n using the log2 and pow methods``        ``// The result is rounded to the nearest integer``        ``return` `Math.round((``int``) Math.pow(``2``, (Math.log(a) / Math.log(``2``)) * n));``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int` `a = ``2``;``        ``int` `n = ``3``;``        ``System.out.println(calculatePower(a, n));``    ``}``}`

## Python3

 `import` `math` `def` `calculatePower(a, n):``    ``return` `round``(``2` `*``*` `(math.log2(a) ``*` `n))` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``a ``=` `2``    ``n ``=` `3``    ``print``(calculatePower(a, n)) ``# Output: a^n` `# This code is contributed by Susobhan Akhuli`

## C#

 `using` `System;` `public` `class` `MainClass``{``    ``// Function to calculate a^n using log2 and pow methods``    ``public` `static` `int` `CalculatePower(``int` `a, ``int` `n)``    ``{``        ``// Calculate a^n using the log2 and pow methods``        ``// The result is rounded to the nearest integer``        ``return` `(``int``)Math.Round(Math.Pow(2, (Math.Log(a) / Math.Log(2)) * n));``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int` `a = 2;``        ``int` `n = 3;``        ``Console.WriteLine(CalculatePower(a, n));``    ``}``}`

## Javascript

 `// Function to calculate a^n using Math.pow``function` `calculatePower(a, n) {``    ``// Calculate a^n using Math.pow``    ``return` `Math.round(Math.pow(a, n));``}` `// Test the function``var` `a = 2;``var` `n = 3;``console.log(calculatePower(a, n));`

Output

```8

```

## Program to calculate pow(x,n) using math.exp() function:

In math library, the math.exp() function in Python is used to calculate the value of the mathematical constant e (2.71828…) raised to a given power. It takes a single argument, which is the exponent to which the constant e should be raised, and returns the result as a float. Now, if we use combination of math.log() and math.exp() function, then we can find power of any number.

## Python3

 `import` `math` `def` `calculatePower(x, n):``      ``ans ``=` `math.exp(math.log(x) ``*` `n)``      ``ans ``=` `round``(ans)``      ``return` `ans` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``x ``=` `2``    ``n ``=` `3``    ``print``(calculatePower(x, n)) ``# Output: x^n` `# This code is contributed by Susobhan Akhuli`

Output

```8

```

#### Complexity Analysis:

Time Complexity: O(1), as both math.exp() and math.log() functions run on O(1) time complexity.
Auxiliary Space: O(1), as no extra space is used.

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.