Related Articles

# Find the absolute difference between the nearest powers of two given integers for every array element

• Difficulty Level : Medium
• Last Updated : 06 Jul, 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 print the 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 DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up