GeeksforGeeks App
Open App
Browser
Continue

# Minimum increments or decrements required to convert a sorted array into a power sequence

Given a sorted array arr[] consisting of N positive integers, the task is to minimize the total number of increments or decrements of each array element required to convert the given array into a power sequence of any arbitrary integer X.

A sequence is called a power sequence of any integer X, if and only if for every ith element (0 ≤ i < N), arr[i] = Xi, where N is length of the given array.

Examples:

Input: arr[] = {1, 3, 4}
Output: 1
Explanation: Decreasing arr[1] by 1 modifies array to {1, 2, 4}, which is a power sequence of 2. Therefore, the total number of increments or decrements required is 1.

Input: arr[] = {1, 5, 7}
Output: 6
Explanation:
Operation 1: Decreasing arr[1] by 1 modifies array to {1, 4, 7}
Operation 2: Decreasing arr[1] by 1 modifies array to {1, 3, 7}
Operation 3: Increasing arr[2] by 1 modifies array to {1, 3, 8}
Operation 4: Increasing arr[2] by 1 modifies array to {1, 3, 9}, which is the power sequence of 3. Therefore, the total number of increments or decrements required is 4.

Approach: The given problem can be solved based on the following observations:

• As the given array needs to be converted into a power sequence for any arbitrary integer X, then the mathematical relations can be written as:

where, 0 <= i < N, N is the number of elements in the array.

• The minimum value of f(X) is the minimum number of operations required to convert it into a power sequence of X and the maximum value of X can be calculated as follows:

=>
=>

• Therefore, the idea is to iterate for all possible values of X starting from 1, and check if the following equation satisfies or not:

If found to be true, then find all possible values of and return the minimum among all the values obtained.

Follow the steps below to solve the given problem:

• Initialize a variable, say ans as (the sum of array elements – N), that stores the minimum number of increments or decrements required to make the array a power sequence.
• Iterate a loop, starting from 1, using the variable X and perform the following steps:
• Initialize two variables, say currCost as 0 and currPower as 1, that stores the sum of the expression and power of the integer X.
• Iterate over the range [0, N – 1] and update the value of currCost as currCost + abs(arr[i] – currPower) and the value of currPower as X * currPower.
• If the expression is not satisfied, then break out of the loop. Otherwise, update the value of ans to the minimum of ans and currCost.
• After completing the above steps, print the value of ans as the required minimum number of operations.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std; // Function to find the minimum number// of increments or decrements required// to convert array into a power sequenceint minOperations(int a[], int n){    // Initialize the count to f(X) for X = 1    int ans = accumulate(a, a + n, 0) - n;     // Calculate the value of f(X)    // X ^ (n - 1) <= f(1) + a[n - 1]    for (int x = 1;; x++) {         int curPow = 1, curCost = 0;         // Calculate F(x)        for (int i = 0; i < n; i++) {            curCost += abs(a[i] - curPow);            curPow *= x;        }         // Check if X ^ (n - 1) > f(1) + a[n - 1]        if (curPow / x > ans + a[n - 1])            break;         // Update ans to store the        // minimum of ans and F(x)        ans = min(ans, curCost);    }     // Return the minimum number    // of operations required    return ans;} // Driver Codeint main(){    int arr[] = { 1, 5, 7 };    int N = sizeof(arr) / sizeof(arr[0]);     cout << minOperations(arr, N);     return 0;}

## Java

 // Java program for the above approachclass GFG{ // Function to find the minimum number// of increments or decrements required// to convert array into a power sequencestatic int minOperations(int a[], int n){         // Initialize the count to f(X) for X = 1    int ans = 0;    for(int i = 0; i < n; i++)    {        ans += a[i];    }    ans -= n;     // Calculate the value of f(X)    // X ^ (n - 1) <= f(1) + a[n - 1]    for(int x = 1;; x++)    {        int curPow = 1, curCost = 0;         // Calculate F(x)        for(int i = 0; i < n; i++)        {            curCost += Math.abs(a[i] - curPow);            curPow *= x;        }         // Check if X ^ (n - 1) > f(1) + a[n - 1]        if (curPow / x > ans + a[n - 1])            break;         // Update ans to store the        // minimum of ans and F(x)        ans = Math.min(ans, curCost);    }     // Return the minimum number    // of operations required    return ans;} // Driver Codepublic static void main(String[] args){    int arr[] = { 1, 5, 7 };    int N = arr.length;     System.out.print(minOperations(arr, N));}} // This code is contributed by avijitmondal1998

## Python3

 # Python3 program for the above approach # Function to find the minimum number# of increments or decrements required# to convert array into a power sequencedef minOperations(a, n):         # Initialize the count to f(X) for X = 1    ans = 0    for i in range(n):        ans += a[i]             ans -= n     # Calculate the value of f(X)    # X ^ (n - 1) <= f(1) + a[n - 1]    x = 1    while(1):        curPow = 1        curCost = 0         # Calculate F(x)        for i in range(n):            curCost += abs(a[i] - curPow)            curPow *= x         # Check if X ^ (n - 1) > f(1) + a[n - 1]        if (curPow / x > ans + a[n - 1]):            break         # Update ans to store the        # minimum of ans and F(x)        ans = min(ans, curCost)        x += 1     # Return the minimum number    # of operations required    return ans # Driver Codeif __name__ == '__main__':         arr =  [1, 5, 7]    N = len(arr)         print(minOperations(arr, N))     # This code is contributed by ipg2016107

## C#

 // C# program for the above approachusing System; class GFG{ // Function to find the minimum number// of increments or decrements required// to convert array into a power sequencestatic int minOperations(int []a, int n){         // Initialize the count to f(X) for X = 1    int ans = 0;    for(int i = 0; i < n; i++)    {        ans += a[i];    }    ans -= n;     // Calculate the value of f(X)    // X ^ (n - 1) <= f(1) + a[n - 1]    for(int x = 1;; x++)    {        int curPow = 1, curCost = 0;         // Calculate F(x)        for(int i = 0; i < n; i++)        {            curCost += Math.Abs(a[i] - curPow);            curPow *= x;        }         // Check if X ^ (n - 1) > f(1) + a[n - 1]        if (curPow / x > ans + a[n - 1])            break;         // Update ans to store the        // minimum of ans and F(x)        ans = Math.Min(ans, curCost);    }     // Return the minimum number    // of operations required    return ans;} // Driver Codepublic static void Main(){    int []arr = { 1, 5, 7 };    int N = arr.Length;     Console.WriteLine(minOperations(arr, N));}} // This code is contributed by mohit kumar 29

## Javascript

 

Output:

4

Time Complexity: O(N*(S)(1/(N – 1)))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up