# Minimum steps required to rearrange given array to a power sequence of 2

Given an array arr[] consisting of N positive integers, the task is to find the minimum steps required to make the given array of integers into a sequence of powers of 2 by the following operations:

• Reorder the given array. It doesn’t count as a step.
• For each step, select any index i from the array and change arr[i] to arr[i] − 1 or arr[i] + 1.

A sequence is called power sequence of 2, if for every ith index (0 ≤i ≤ N − 1),
arr[i] = 2i
, where N is length of the given array.

Examples:

Input: arr[] = { 1, 8, 2, 10, 6 }
Output: 8
Explanation:
Reorder the array arr[] to { 1, 2, 6, 8, 10 }
Step 1: Decrement arr to 5
Step 2: Decrement arr to 4
Step 3 – 8: Increment arr by 1. Final value of arr becomes 16.
Therefore, arr[] = {1, 2, 4, 8, 16}
Hence, the minimum number of steps required to obtain the power sequence of 2 is 8.

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: To solve the given problem, the idea is to sort the array in ascending order  and for every ith index of the sorted array, calculate the absolute difference between arr[i]  and 2i. The sum of the absolute differences gives us the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement ` `// the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate the minimum ` `// steps required to convert given ` `// array into a power sequence of 2 ` `int` `minsteps(``int` `arr[], ``int` `n) ` `{ ` ` `  `    ``// Sort the array in ` `    ``// ascending order ` `    ``sort(arr, arr + n); ` ` `  `    ``int` `ans = 0; ` ` `  `    ``// Calculate the absolute difference ` `    ``// between arr[i] and 2^i for each index ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``ans += ``abs``(arr[i] - ``pow``(2, i)); ` `    ``} ` ` `  `    ``// Return the answer ` `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 8, 2, 10, 6 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << minsteps(arr, n) << endl; ` `    ``return` `0; ` `}`

## Java

 `// Java Program to implement ` `// the above approach ` ` `  `import` `java.util.*; ` `import` `java.lang.Math; ` ` `  `class` `GFG { ` ` `  `    ``// Function to calculate the minimum ` `    ``// steps required to convert given ` `    ``// array into a power sequence of 2 ` `    ``static` `int` `minsteps(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``// Sort the array in ascending order ` `        ``Arrays.sort(arr); ` `        ``int` `ans = ``0``; ` ` `  `        ``// Calculate the absolute difference ` `        ``// between arr[i] and 2^i for each index ` `        ``for` `(``int` `i = ``0``; i < n; i++) { ` `            ``ans += Math.abs(arr[i] - Math.pow(``2``, i)); ` `        ``} ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``1``, ``8``, ``2``, ``10``, ``6` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(minsteps(arr, n)); ` `    ``} ` `}`

## Python3

 `# Python 3 program for the above approach ` ` `  `# Function to calculate the minimum ` `# steps required to convert given ` `# array into a power sequence of 2 ` `def` `minsteps(arr, n): ` ` `  `    ``# Sort the array in ascending order ` `    ``arr.sort() ` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(n): ` `        ``ans ``+``=` `abs``(arr[i]``-``pow``(``2``, i)) ` `    ``return` `ans ` ` `  ` `  `# Driver Code ` `arr ``=` `[``1``, ``8``, ``2``, ``10``, ``6``] ` `n ``=` `len``(arr) ` `print``(minsteps(arr, n)) `

## C#

 `// C# Program to the above approach ` ` `  `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Function to calculate the minimum ` `    ``// steps required to convert given ` `    ``// array into a power sequence of 2 ` `    ``static` `int` `minsteps(``int``[] arr, ``int` `n) ` `    ``{ ` ` `  `        ``// Sort the array in ascending order ` `        ``Array.Sort(arr); ` `        ``int` `ans = 0; ` ` `  `        ``// Calculate the absolute difference ` `        ``// between arr[i] and 2^i for each index ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``ans += Math.Abs(arr[i] ` `                            ``- (``int``)(Math.Pow(2, i))); ` `        ``} ` `        ``return` `ans; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` ` `  `        ``int``[] arr = { 1, 8, 2, 10, 6 }; ` `        ``int` `n = arr.Length; ` `        ``Console.WriteLine(minsteps(arr, n)); ` `    ``} ` `}`

Output:

```8
```

Time Complexity: O(NlogN)
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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.