Count minimum steps to get the given desired array - GeeksforGeeks

01 Apr, 2021
Consider an array with n elements and value of all the elements is zero. We can perform following operations on the array.  
Incremental operations:Choose 1 element from the array and increment its value by 1.Doubling operation: Double the values of all the elements of array.
Incremental operations:Choose 1 element from the array and increment its value by 1.
Doubling operation: Double the values of all the elements of array.
We are given desired array target[] containing n elements. Compute and return the smallest possible number of the operations needed to change the array from all zeros to desired array.Examples:  
Input: target[] = {2, 3}
Output: 4
To get the target array from {0, 0}, we 
first increment both elements by 1 (2 
operations), then double the array (1 
operation). Finally increment second
element (1 more operation)

Input: target[] = {2, 1}
Output: 3
One of the optimal solution is to apply the 
incremental operation 2 times to first and 
once on second element.

Input: target[] = {16, 16, 16}
Output: 7
The output solution looks as follows. First 
apply an incremental operation to each element. 
Then apply the doubling operation four times. 
Total number of operations is 3+4 = 7
 
One important thing to note is that the task is to count the number of steps to get the given target array (not to convert zero array to target array). The idea is to follow reverse steps, i.e. to convert target to array of zeros. Below are steps.
Take the target array first. 

Initialize result as 0. 

If all are even, divide all elements by 2 
and increment result by 1. 

Find all odd elements, make them even by 
reducing them by 1. and for every reduction,
increment result by 1.

Finally, we get all zeros in target array.
Below is the implementation of above algorithm.  
C++
Java
Python3
C#
PHP
Javascript
/* C++ program to count minimum number of operations   to get the given target array */#include <bits/stdc++.h>using namespace std; // Returns count of minimum operations to convert a// zero array to target array with increment and// doubling operations.// This function computes count by doing reverse// steps, i.e., convert target to zero array.int countMinOperations(unsigned int target[], int n){    // Initialize result (Count of minimum moves)    int result = 0;     // Keep looping while all elements of target    // don't become 0.    while (1)    {        // To store count of zeroes in current        // target array        int zero_count = 0;         int i;  // To find first odd element        for (i=0; i<n; i++)        {            // If odd number found            if (target[i] & 1)                break;             // If 0, then increment zero_count            else if (target[i] == 0)                zero_count++;        }         // All numbers are 0        if (zero_count == n)          return result;         // All numbers are even        if (i == n)        {            // Divide the whole array by 2            // and increment result            for (int j=0; j<n; j++)               target[j] = target[j]/2;            result++;        }         // Make all odd numbers even by subtracting        // one and increment result.        for (int j=i; j<n; j++)        {           if (target[j] & 1)           {              target[j]--;              result++;           }        }    }} /* Driver program to test above functions*/int main(){    unsigned int arr[] = {16, 16, 16};    int n = sizeof(arr)/sizeof(arr[0]);    cout << "Minimum number of steps required to "           "get the given target array is "         << countMinOperations(arr, n);    return 0;}
/* Java program to count minimum number of operations   to get the given arr array */  class Test{    static int arr[] = new int[]{16, 16, 16} ;          // Returns count of minimum operations to convert a    // zero array to arr array with increment and    // doubling operations.    // This function computes count by doing reverse    // steps, i.e., convert arr to zero array.    static int countMinOperations(int n)    {        // Initialize result (Count of minimum moves)        int result = 0;              // Keep looping while all elements of arr        // don't become 0.        while (true)        {            // To store count of zeroes in current            // arr array            int zero_count = 0;                  int i;  // To find first odd element            for (i=0; i<n; i++)            {                // If odd number found                if (arr[i] % 2 == 1)                    break;                      // If 0, then increment zero_count                else if (arr[i] == 0)                    zero_count++;            }                  // All numbers are 0            if (zero_count == n)              return result;                  // All numbers are even            if (i == n)            {                // Divide the whole array by 2                // and increment result                for (int j=0; j<n; j++)                   arr[j] = arr[j]/2;                result++;            }                  // Make all odd numbers even by subtracting            // one and increment result.            for (int j=i; j<n; j++)            {               if (arr[j] %2 == 1)               {                  arr[j]--;                  result++;               }            }        }    }       // Driver method to test the above function    public static void main(String[] args) {                  System.out.println("Minimum number of steps required to \n" +                            "get the given target array is "+                                 countMinOperations(arr.length));          }}
# Python3 program to count minimum number of# operations to get the given target array # Returns count of minimum operations to# convert a zero array to target array# with increment and doubling operations.# This function computes count by doing reverse# steps, i.e., convert target to zero array.def countMinOperations(target, n):         # Initialize result (Count of minimum moves)    result = 0;     # Keep looping while all elements of    # target don't become 0.    while (True):                 # To store count of zeroes in        # current target array        zero_count = 0;             # To find first odd element        i = 0;        while (i < n):                         # If odd number found            if ((target[i] & 1) > 0):                break;             # If 0, then increment            # zero_count            elif (target[i] == 0):                zero_count += 1;            i += 1;         # All numbers are 0        if (zero_count == n):            return result;         # All numbers are even        if (i == n):                         # Divide the whole array by 2            # and increment result            for j in range(n):                target[j] = target[j] // 2;            result += 1;         # Make all odd numbers even by        # subtracting one and increment result.        for j in range(i, n):            if (target[j] & 1):                target[j] -= 1;                result += 1; # Driver Codearr = [16, 16, 16];n = len(arr);print("Minimum number of steps required to",          "\nget the given target array is",                countMinOperations(arr, n)); # This code is contributed by mits
// C# program to count minimum// number of operations to get// the given arr array */using System;class GFG {         static int []arr = new int[]{16, 16, 16} ;         // Returns count of minimum    // operations to convert a    // zero array to arr array    // with increment and    // doubling operations.    // This function computes    // count by doing reverse    // steps, i.e., convert arr    // to zero array.    static int countMinOperations(int n)    {                 // Initialize result        // (Count of minimum moves)        int result = 0;             // Keep looping while all        // elements of arr        // don't become 0.        while (true)        {                         // To store count of zeroes            // in current arr array            int zero_count = 0;                 // To find first odd element            int i;            for (i = 0; i < n; i++)            {                                 // If odd number found                if (arr[i] % 2 == 1)                    break;                     // If 0, then increment                // zero_count                else if (arr[i] == 0)                    zero_count++;            }                 // All numbers are 0            if (zero_count == n)            return result;                 // All numbers are even            if (i == n)            {                                 // Divide the whole array by 2                // and increment result                for(int j = 0; j < n; j++)                arr[j] = arr[j] / 2;                result++;            }                 // Make all odd numbers            // even by subtracting            // one and increment result.            for(int j = i; j < n; j++)            {                if (arr[j] %2 == 1)                {                    arr[j]--;                    result++;                }            }        }    }         // Driver Code    public static void Main()    {        Console.Write("Minimum number of steps required to \n" +                            "get the given target array is "+                                countMinOperations(arr.Length));         }} // This code is contributed by nitin mittal.
<?php// PHP program to count minimum// number of operations to get// the given target array // Returns count of minimum// operations to convert a// zero array to target array// with increment and doubling// operations.// This function computes// count by doing reverse// steps, i.e., convert target// to zero array.function countMinOperations($target, $n){         // Initialize result    // (Count of minimum moves)    $result = 0;     // Keep looping while    // all elements of target    // don't become 0.    while (1)    {                 // To store count of        // zeroes in current        // target array        $zero_count = 0;             // To find first        // odd element        $i = 0;        for($i = 0; $i < $n; $i++)        {                         // If odd number found            if ($target[$i] & 1)                break;             // If 0, then increment            // zero_count            else if ($target[$i] == 0)                $zero_count++;        }         // All numbers are 0        if ($zero_count == $n)            return $result;         // All numbers are even        if ($i == $n)        {                         // Divide the whole array by 2            // and increment result            for ($j = 0; $j < $n; $j++)            $target[$j] = $target[$j] / 2;            $result++;        }         // Make all odd numbers        // even by subtracting        // one and increment result.        for ($j = $i; $j < $n; $j++)        {            if ($target[$j] & 1)            {                $target[$j]--;                $result++;            }        }    }}     // Driver Code    $arr= array(16, 16, 16);    $n = sizeof($arr);    echo "Minimum number of steps required to \n".         "get the given target array is ".          countMinOperations($arr, $n); // This code is contributed by mits?>
<script> // JavaScript program to count minimum number of operations//  to get the given arr array     let arr = [16, 16, 16] ;            // Returns count of minimum operations to convert a    // zero array to arr array with increment and    // doubling operations.    // This function computes count by doing reverse    // steps, i.e., convert arr to zero array.    function countMinOperations(n)    {        // Initialize result (Count of minimum moves)        let result = 0;                // Keep looping while all elements of arr        // don't become 0.        while (true)        {            // To store count of zeroes in current            // arr array            let zero_count = 0;                    let i;  // To find first odd element            for (i=0; i<n; i++)            {                // If odd number found                if (arr[i] % 2 == 1)                    break;                        // If 0, then increment zero_count                else if (arr[i] == 0)                    zero_count++;            }                    // All numbers are 0            if (zero_count == n)              return result;                    // All numbers are even            if (i == n)            {                // Divide the whole array by 2                // and increment result                for (let j=0; j<n; j++)                   arr[j] = arr[j]/2;                result++;            }                    // Make all odd numbers even by subtracting            // one and increment result.            for (let j=i; j<n; j++)            {               if (arr[j] %2 == 1)               {                  arr[j]--;                  result++;               }            }        }    } // Driver Code        document.write("Minimum number of steps required to " + "<br/>" +                            "get the given target array is "+                                 countMinOperations(arr.length)); </script>
Output : 
Minimum number of steps required to 
get the given target array is 7
 
YouTubeGeeksforGeeks501K subscribersCount minimum steps to get the given desired array | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.More videosMore videosYou're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 8:43•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=AXlPTwCzpAo" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Shivam Agrawal. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
nitin mittal
Mithun Kumar
nidhi_biet
chinmoy1997pal
Arrays
Mathematical
Arrays
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Arrays in Java
Arrays in C/C++
Program for array rotation
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews
Program for Fibonacci numbers
C++ Data Types
Write a program to print all permutations of a given string
Set in C++ Standard Template Library (STL)
Program to find GCD or HCF of two numbers