Related Articles
Find the absolute difference between the nearest powers of two given integers for every array element
• Difficulty Level : Medium
• Last Updated : 19 Apr, 2021

Given an array arr[] consisting of N positive integers and two positive integers A and B, the task is to replace each array element with the absolute difference of the nearest powers of A and B. If there exists two nearest powers, then choose the maximum of the two.

Examples:

Input: arr[] = {5, 12, 25}, A = 2, B = 3
Output: 1 7 5
Explanation:

• For element arr( = 5): The nearest power of 2 is 4 and the nearest power of 3 is 3. Therefore, the absolute difference of 4 and 3 is 1.
• For arr( = 12): The nearest power of 2 is 16 and the nearest power of 3 is 9. Therefore, the absolute difference of 16 and 9 is 7.
• For arr( = 5): The nearest power of 2 is 32 and the nearest power of 3 is 27. Therefore, the absolute difference of 27 and 32 is 5.

Therefore, the modified array is {1, 7, 5}.

Input: arr[] = {32, 3, 7}, a = 2, b = 3
Output: 0 1 1

Approach: The given problem can be solved by finding both the nearest power of A and B for every array element and update it to the absolute difference of the two values obtained.
Follow the steps to solve the problem

• Traverse the given array arr[] and perform the following steps:
• Find the two values that are the perfect powers of a less than and greater than arr[i] and find the closest of the two values.
• Find the two values that are the perfect powers of b less than and greater than arr[i] and find the closest of the two values.
• Find the absolute difference between the two closest values obtained and update arr[i] with it.
• After completing the above steps, print the modified array arr[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to print the array``void` `printArray(``int` `arr[], ``int` `N)``{``    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {``        ``cout << arr[i] << ``" "``;``    ``}``}` `// Function to modify array elements``// by absolute difference of the``// nearest perfect power of a and b``void` `nearestPowerDiff(``int` `arr[], ``int` `N,``                      ``int` `a, ``int` `b)``{``    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Find the log a of arr[i]``        ``int` `log_a = ``log``(arr[i]) / ``log``(a);` `        ``// Find the power of a less``        ``// than and greater than a``        ``int` `A = ``pow``(a, log_a);``        ``int` `B = ``pow``(a, log_a + 1);` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_a = A;``        ``else``            ``log_a = B;` `        ``// Find the log b of arr[i]``        ``int` `log_b = ``log``(arr[i]) / ``log``(b);` `        ``// Find the power of b less than``        ``// and greater than b``        ``A = ``pow``(b, log_b);``        ``B = ``pow``(b, log_b + 1);` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_b = A;``        ``else``            ``log_b = B;` `        ``// Update arr[i] with absolute``        ``// difference of log_a & log _b``        ``arr[i] = ``abs``(log_a - log_b);``    ``}` `    ``// Print the modified array``    ``printArray(arr, N);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 5, 12, 25 };``    ``int` `A = 2, B = 3;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``nearestPowerDiff(arr, N, A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG{` `// Function to print the array``static` `void` `printArray(``int``[] arr, ``int` `N)``{``    ` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``System.out.print(arr[i] + ``" "``);``    ``}``}` `// Function to modify array elements``// by absolute difference of the``// nearest perfect power of a and b``static` `void` `nearestPowerDiff(``int``[] arr, ``int` `N,``                             ``int` `a, ``int` `b)``{``    ` `    ``// Traverse the array arr[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Find the log a of arr[i]``        ``int` `log_a = (``int``)(Math.log(arr[i]) /``                          ``Math.log(a));` `        ``// Find the power of a less``        ``// than and greater than a``        ``int` `A = (``int``)(Math.pow(a, log_a));``        ``int` `B = (``int``)(Math.pow(a, log_a + ``1``));` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_a = A;``        ``else``            ``log_a = B;` `        ``// Find the log b of arr[i]``        ``int` `log_b = (``int``)(Math.log(arr[i]) /``                          ``Math.log(b));` `        ``// Find the power of b less than``        ``// and greater than b``        ``A = (``int``)(Math.pow(b, log_b));``        ``B = (``int``)(Math.pow(b, log_b + ``1``));` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_b = A;``        ``else``            ``log_b = B;` `        ``// Update arr[i] with absolute``        ``// difference of log_a & log _b``        ``arr[i] = Math.abs(log_a - log_b);``    ``}` `    ``// Print the modified array``    ``printArray(arr, N);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``5``, ``12``, ``25` `};``    ``int` `A = ``2``, B = ``3``;``    ``int` `N = arr.length;` `    ``nearestPowerDiff(arr, N, A, B);``}``}` `// This code is contributed by subham348`

## Python3

 `# Python3 program for the above approach``import` `math` `# Function to prthe array``def` `printArray(arr, N):``    ` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):``        ``print``(arr[i], end ``=` `" "``)``    ` `# Function to modify array elements``# by absolute difference of the``# nearest perfect power of a and b``def` `nearestPowerDiff(arr, N, a, b):``    ` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):` `        ``# Find the log a of arr[i]``        ``log_a ``=` `int``(math.log(arr[i]) ``/``                    ``math.log(a))` `        ``# Find the power of a less``        ``# than and greater than a``        ``A ``=` `int``(``pow``(a, log_a))``        ``B ``=` `int``(``pow``(a, log_a ``+` `1``))` `        ``if` `((arr[i] ``-` `A) < (B ``-` `arr[i])):``            ``log_a ``=` `A``        ``else``:``            ``log_a ``=` `B` `        ``# Find the log b of arr[i]``        ``log_b ``=` `int``(math.log(arr[i]) ``/``                    ``math.log(b))` `        ``# Find the power of b less than``        ``# and greater than b``        ``A ``=` `int``(``pow``(b, log_b))``        ``B ``=` `int``(``pow``(b, log_b ``+` `1``))` `        ``if` `((arr[i] ``-` `A) < (B ``-` `arr[i])):``            ``log_b ``=` `A``        ``else``:``            ``log_b ``=` `B` `        ``# Update arr[i] with absolute``        ``# difference of log_a & log _b``        ``arr[i] ``=` `abs``(log_a ``-` `log_b)``    ` `    ``# Print the modified array``    ``printArray(arr, N)` `# Driver Code``arr ``=` `[ ``5``, ``12``, ``25` `]``A ``=` `2``B ``=` `3``N ``=` `len``(arr)` `nearestPowerDiff(arr, N, A, B)` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG{` `// Function to print the array``static` `void` `printArray(``int``[] arr, ``int` `N)``{``    ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``Console.Write(arr[i] + ``" "``);``    ``}``}` `// Function to modify array elements``// by absolute difference of the``// nearest perfect power of a and b``static` `void` `nearestPowerDiff(``int``[] arr, ``int` `N,``                             ``int` `a, ``int` `b)``{``    ` `    ``// Traverse the array arr[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Find the log a of arr[i]``        ``int` `log_a = (``int``)(Math.Log(arr[i]) /``                          ``Math.Log(a));` `        ``// Find the power of a less``        ``// than and greater than a``        ``int` `A = (``int``)(Math.Pow(a, log_a));``        ``int` `B = (``int``)(Math.Pow(a, log_a + 1));` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_a = A;``        ``else``            ``log_a = B;` `        ``// Find the log b of arr[i]``        ``int` `log_b = (``int``)(Math.Log(arr[i]) /``                          ``Math.Log(b));` `        ``// Find the power of b less than``        ``// and greater than b``        ``A = (``int``)(Math.Pow(b, log_b));``        ``B = (``int``)(Math.Pow(b, log_b + 1));` `        ``if` `((arr[i] - A) < (B - arr[i]))``            ``log_b = A;``        ``else``            ``log_b = B;` `        ``// Update arr[i] with absolute``        ``// difference of log_a & log _b``        ``arr[i] = Math.Abs(log_a - log_b);``    ``}` `    ``// Print the modified array``    ``printArray(arr, N);``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 5, 12, 25 };``    ``int` `A = 2, B = 3;``    ``int` `N = arr.Length;` `    ``nearestPowerDiff(arr, N, A, B);``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``
Output:
`1 7 5`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up