Given a circular array **arr[]** consisting of **N** integers, the task is to replace all the array elements with the nearest possible power of its previous adjacent element

**Examples:**

Input:arr[] = {2, 4, 6, 3, 11}Output:1 4 4 6 9Explanation:

Power of 11 which is nearest to 2 —> 11^{0 }= 1

Power of 2 which is nearest to 4 —> 2^{2}= 4

Power of 4 which is nearest to 6 —> 4^{1}= 4

Power of 6 which is nearest to 3 —> 6^{1}= 6

Power of 3 which is nearest to 11—> 3^{2}= 9

Input:arr[] = {3, 2, 4, 3}Output:3 3 4 4Explanation:

Power of 3 which is nearest to 3 —> 3^{1 }= 3

Power of 3 which is nearest to 2 —> 3^{1}= 3

Power of 2 which is nearest to 4 —> 2^{2}= 4

Power of 4 which is nearest to 3 —> 4^{1}= 4

**Approach: **The idea to solve this problem is to traverse the array and for each array element **arr[i], **find the power of the previous element, say **X, **which is nearest to **arr[i]**, i.e. **X ^{K}** which is closest to

**arr[i]**. Follow the steps:

- Calculate the value of
**K**, which is equal to the floor value of**log**._{x}(Y) - Therefore,
**K**and**(K + 1)**will be the two integers for which the power could be nearest. - Calculate
**X**^{K}^{ }and**X**and check which is nearer to^{(K + 1)}**Y**. Then, print that value.

Below is the implementation of the above approach:

## C++

`// CPP program for the above approach` `#include <iostream>` `#include <cmath>` `using` `namespace` `std;` `// Function to calculate log x for given base` `int` `LOG(` `int` `a, ` `int` `b) {` ` ` `return` `log` `(a) / ` `log` `(b);` `}` `// Function to replace all array` `// elements with the nearest power` `// of previous adjacent nelement` `void` `repbyNP(` `int` `*arr,` `int` `n)` `{` ` ` ` ` `// For the first element, set the last` ` ` `// array element to its previous element` ` ` `int` `x = arr[n - 1];` ` ` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Find K for which x ^ k is` ` ` `// nearest to arr[i]` ` ` `int` `k = LOG(arr[i], x);` ` ` `int` `temp = arr[i];` ` ` ` ` `// Find the power to x nearest to arr[i]` ` ` `if` `(` `abs` `(` `pow` `(x,k) - arr[i]) < ` `abs` `(` `pow` `(x,k+1) - arr[i]))` ` ` `arr[i] = ` `pow` `(x, k);` ` ` `else` ` ` `arr[i] = ` `pow` `(x, k + 1);` ` ` ` ` `// Update x` ` ` `x = temp;` ` ` `}` `}` `int` `main()` `{` ` ` ` ` `// Driver Code` ` ` `int` `arr[5] = {2, 4, 6, 3, 11};` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` ` ` `// Function Call` ` ` `repbyNP(arr,n);` ` ` ` ` `// Display the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `cout<<arr[i]<<` `" "` `;` ` ` `return` `0;` `}` `// This code is contributed by rohitsingh07052.` |

## Java

`// Java program for the above approach` `import` `java.util.*;` ` ` `class` `GFG` `{` ` ` `// Function to calculate log x for given base` `static` `int` `LOG(` `int` `a, ` `int` `b) {` ` ` `return` `(` `int` `)(Math.log(a) / Math.log(b));` `}` ` ` `// Function to replace all array` `// elements with the nearest power` `// of previous adjacent nelement` `static` `void` `repbyNP(` `int` `[] arr,` `int` `n)` `{` ` ` ` ` `// For the first element, set the last` ` ` `// array element to its previous element` ` ` `int` `x = arr[n - ` `1` `];` ` ` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` ` ` `// Find K for which x ^ k is` ` ` `// nearest to arr[i]` ` ` `int` `k = LOG(arr[i], x);` ` ` `int` `temp = arr[i];` ` ` ` ` `// Find the power to x nearest to arr[i]` ` ` `if` `(Math.abs(Math.pow(x,k) - arr[i]) < Math.abs(Math.pow(x,k+` `1` `) - arr[i]))` ` ` `arr[i] = (` `int` `)Math.pow(x, k);` ` ` `else` ` ` `arr[i] = (` `int` `)Math.pow(x, k + ` `1` `);` ` ` ` ` `// Update x` ` ` `x = temp;` ` ` `}` `}` ` ` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = {` `2` `, ` `4` `, ` `6` `, ` `3` `, ` `11` `};` ` ` `int` `n = arr.length;` ` ` ` ` `// Function Call` ` ` `repbyNP(arr,n);` ` ` ` ` `// Display the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `System.out.print(arr[i] + ` `" "` `);` `}` `}` `// This code is contributed by sanjoy_62.` |

## Python3

`# Python3 program for the above approach` `import` `math` `# Function to calculate log x for given base` `def` `LOG(x, base):` ` ` `return` `int` `(math.log(x)` `/` `math.log(base))` `# Function to replace all array` `# elements with the nearest power` `# of previous adjacent nelement` `def` `repbyNP(arr):` ` ` `# For the first element, set the last` ` ` `# array element to its previous element` ` ` `x ` `=` `arr[` `-` `1` `]` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(` `len` `(arr)):` ` ` `# Find K for which x ^ k is` ` ` `# nearest to arr[i]` ` ` `k ` `=` `LOG(arr[i], x)` ` ` `temp ` `=` `arr[i]` ` ` `# Find the power to x nearest to arr[i]` ` ` `if` `abs` `(x` `*` `*` `k ` `-` `arr[i]) < ` `abs` `(x` `*` `*` `(k ` `+` `1` `) ` `-` `arr[i]):` ` ` `arr[i] ` `=` `x` `*` `*` `k` ` ` `else` `:` ` ` `arr[i] ` `=` `x` `*` `*` `(k ` `+` `1` `)` ` ` `# Update x` ` ` `x ` `=` `temp` ` ` `# Return the array` ` ` `return` `arr` `# Driver Code` `arr ` `=` `[` `2` `, ` `4` `, ` `6` `, ` `3` `, ` `11` `]` `# Function Call` `print` `(repbyNP(arr))` |

## C#

`// C# program for the above approach` `using` `System;` `class` `GFG{` `// Function to calculate log x for given base` `static` `int` `LOG(` `int` `a, ` `int` `b) {` ` ` `return` `(` `int` `)(Math.Log(a) / Math.Log(b));` `}` ` ` `// Function to replace all array` `// elements with the nearest power` `// of previous adjacent nelement` `static` `void` `repbyNP(` `int` `[] arr,` `int` `n)` `{` ` ` ` ` `// For the first element, set the last` ` ` `// array element to its previous element` ` ` `int` `x = arr[n - 1];` ` ` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Find K for which x ^ k is` ` ` `// nearest to arr[i]` ` ` `int` `k = LOG(arr[i], x);` ` ` `int` `temp = arr[i];` ` ` ` ` `// Find the power to x nearest to arr[i]` ` ` `if` `(Math.Abs(Math.Pow(x, k) - arr[i]) <` ` ` `Math.Abs(Math.Pow(x, k + 1) - arr[i]))` ` ` `arr[i] = (` `int` `)Math.Pow(x, k);` ` ` `else` ` ` `arr[i] = (` `int` `)Math.Pow(x, k + 1);` ` ` ` ` `// Update x` ` ` `x = temp;` ` ` `}` `}` `// Driver Code` `public` `static` `void` `Main(` `string` `[] args)` `{` ` ` `int` `[] arr = {2, 4, 6, 3, 11};` ` ` `int` `n = arr.Length;` ` ` ` ` `// Function Call` ` ` `repbyNP(arr,n);` ` ` ` ` `// Display the array` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `Console.Write(arr[i] + ` `" "` `);` `}` `}` `// This code is contributed by code_hunt.` |

## Javascript

`<script>` `// Javascript program for the above approach` `// Function to calculate log x for given base` `function` `LOG(a, b) {` ` ` `return` `parseInt(Math.log(a) / Math.log(b));` `}` `// Function to replace all array` `// elements with the nearest power` `// of previous adjacent nelement` `function` `repbyNP(arr, n)` `{` ` ` ` ` `// For the first element, set the last` ` ` `// array element to its previous element` ` ` `let x = arr[n - 1];` ` ` ` ` `// Traverse the array` ` ` `for` `(let i = 0; i < n; i++)` ` ` `{` ` ` ` ` `// Find K for which x ^ k is` ` ` `// nearest to arr[i]` ` ` `let k = LOG(arr[i], x);` ` ` `let temp = arr[i];` ` ` ` ` `// Find the power to x nearest to arr[i]` ` ` `if` `(Math.abs(Math.pow(x, k) - arr[i]) < Math.abs(Math.pow(x, k + 1) - arr[i]))` ` ` `arr[i] = Math.pow(x, k);` ` ` `else` ` ` `arr[i] = Math.pow(x, k + 1);` ` ` ` ` `// Update x` ` ` `x = temp;` ` ` `}` `}` ` ` ` ` `// Driver Code` ` ` `let arr = [2, 4, 6, 3, 11];` ` ` `let n = arr.length;` ` ` ` ` `// Function Call` ` ` `repbyNP(arr, n);` ` ` ` ` `// Display the array` ` ` `for` `(let i = 0; i < n; i++)` ` ` `document.write(arr[i] + ` `" "` `);` ` ` ` ` `// This code is contributed by rishavmahato348.` `</script>` |

**Output:**

[1, 4, 4, 1, 9]

**Time Complexity:** O(N)**Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.