Minimum steps to make all the elements of the array divisible by 4

Given an array of size n, the task is to find the minimum number of steps required to make all the elements of the array divisible by 4. A step is defined as removal of any two elements from the array and adding the sum of these elements to the array. 
Examples:

Input: array = {1, 2, 3, 1, 2, 3, 8} 
Output: 3 
Explanation:

As we can see in the image, 
combining array[0] and array[2] makes it 4. Similarly for array[1] and array[4] as well as array[3] and array[5]. array[6] is already divisible by 4. So by doing 3 steps, all the elements in the array become divisible by 4.
Input: array = {12, 31, 47, 32, 93, 24, 61, 29, 21, 34} 
Output: 4 

Approach: The idea here is to convert all the elements in the array to modulus 4. First, sum of all the elements of the array should be divisible by 4. If not, this task is not possible. 

• Initialize an array modulus with size 4 to 0. 
• Initialize a counter count to 0 to keep track of number of steps done. 
• Traverse through the input array and take modulus 4 of each element. 
• Increment the value of the mod 4 value in the modulus array by 1. 
• modulus[0] is the count of elements that are already divisible by 4. So no need to pair them with any other element. 
• modulus[1] and modulus[3] elements can be combined to get a number divisible by 4. So, increment count to the minimum value of the both. 
• Every 2 elements of modulus[2] can be combined to get an element divisible to 4. 
• For the remaining elements, increment value modulus[2] by half of modulus[1] and modulus[3]. 
• Now, increment count by half modulus[2]. We take half because every two elements are combined as one. 
• The final value of count is the number of steps required to convert the all the elements of the input array divisible by 4. 

Below is the implementation of the above approach:  

C++

#include <bits/stdc++.h>
using namespace std;

int getSteps(int arr[], int n)
{
    // Count to keep track of the
    // number of steps done.
    int count = 0;

    // Modulus array to store all elements mod 4
    int modulus[4] = { 0 };

    // sum to check if given task is possible
    int sum = 0;

    // Loop to store all elements mod 4
    // and calculate sum;
    int i;
    for (i = 0; i < n; i++)
    {
        int mod = arr[i] % 4;
        sum += mod;
        modulus[mod]++;
    }

    // If sum is not divisible by 4,
    // not possible
    if (sum % 4 != 0)
    {
        return -1;
    }
    else
    {

        // Find minimum of modulus[1] and modulus[3]
        // and increment the count by the minimum
        if (modulus[1] > modulus[3])
        {
            count += modulus[3];
        }
        else
        {
            count += modulus[1];
        }

        // Update the values in modulus array.
        modulus[1] -= count;
        modulus[3] -= count;

        // Use modulus[2] to pair remaining elements.
        modulus[2] += modulus[1] / 2;
        modulus[2] += modulus[3] / 2;

        // increment count to half of remaining
        // modulus[1] or modulus of [3] elements.
        count += modulus[1] / 2;
        count += modulus[3] / 2;

        // increment count by half of modulus[2]
        count += modulus[2] / 2;

        return count;
    }
}

// Driver Code
int main()
{
    // size of array
    int n = 7;

    // input array
    int arr[] = { 1, 2, 3, 1, 2, 3, 8 };

    int count = getSteps(arr, n);

    cout << count;
}

// This code is contributed
// by Akanksha Rai

C

#include <stdio.h>
#include <string.h>

int getSteps(int arr[], int n)
{
    // Count to keep track of the number of steps done.
    int count = 0;

    // Modulus array to store all elements mod 4
    int modulus[4] = { 0 };

    // sum to check if given task is possible
    int sum = 0;

    // Loop to store all elements mod 4 and calculate sum;
    int i;
    for (i = 0; i < n; i++) {
        int mod = arr[i] % 4;
        sum += mod;
        modulus[mod]++;
    }

    // If sum is not divisible by 4, not possible
    if (sum % 4 != 0) {
        return -1;
    }
    else {

        // Find minimum of modulus[1] and modulus[3]
        // and increment the count by the minimum
        if (modulus[1] > modulus[3]) {
            count += modulus[3];
        }
        else {
            count += modulus[1];
        }
        // Update the values in modulus array.
        modulus[1] -= count;
        modulus[3] -= count;

        // Use modulus[2] to pair remaining elements.
        modulus[2] += modulus[1] / 2;
        modulus[2] += modulus[3] / 2;

        // increment count to half of remaining
        // modulus[1] or modulus of [3] elements.
        count += modulus[1] / 2;
        count += modulus[3] / 2;

        // increment count by half of modulus[2]
        count += modulus[2] / 2;

        return count;
    }
}

// Driver Code
int main()
{
    // size of array
    int n = 7;
    // input array
    int arr[] = { 1, 2, 3, 1, 2, 3, 8 };

    int count = getSteps(arr, n);

    printf("%d", count);
}

Java

// Java program for the above approach
class GFG
{

static int getSteps(int arr[], int n)
{
    // Count to keep track of the number of steps done.
    int count = 0;

    // Modulus array to store all elements mod 4
    int modulus[] = new int[4];

    // sum to check if given task is possible
    int sum = 0;

    // Loop to store all elements
    // mod 4 and calculate sum;
    int i;
    for (i = 0; i < n; i++)
    {
        int mod = arr[i] % 4;
        sum += mod;
        modulus[mod]++;
    }

    // If sum is not divisible by 4, not possible
    if (sum % 4 != 0)
    {
        return -1;
    }
    else {

        // Find minimum of modulus[1] and modulus[3]
        // and increment the count by the minimum
        if (modulus[1] > modulus[3])
        {
            count += modulus[3];
        }
        else
        {
            count += modulus[1];
        }
        // Update the values in modulus array.
        modulus[1] -= count;
        modulus[3] -= count;

        // Use modulus[2] to pair remaining elements.
        modulus[2] += modulus[1] / 2;
        modulus[2] += modulus[3] / 2;

        // increment count to half of remaining
        // modulus[1] or modulus of [3] elements.
        count += modulus[1] / 2;
        count += modulus[3] / 2;

        // increment count by half of modulus[2]
        count += modulus[2] / 2;

        return count;
    }
}

// Driver Code
public static void main(String[] args)
{
    // size of array
    int n = 7;

    // input array
    int arr[] = { 1, 2, 3, 1, 2, 3, 8 };

    int count = getSteps(arr, n);
    System.out.printf("%d", count);
}
}

// This code has been contributed by 29AjayKumar

Python3

# Python 3 program for the above approach
def getSteps(arr, n):

    # Count to keep track of the
    # number of steps done.
    count = 0

    # Modulus array to store all elements mod 4
    modulus = [0 for i in range(4)]

    # Sum to check if given task is possible
    Sum = 0

    # Loop to store all elements mod 4
    # and calculate Sum
    i = 0
    for i in range(n):
        mod = arr[i] % 4
        Sum += mod
        modulus[mod] += 1

    # If Sum is not divisible by 4,
    # not possible
    if (Sum % 4 != 0):
        return -1
    else:

        # Find minimum of modulus[1] and modulus[3]
        # and increment the count by the minimum
        if (modulus[1] > modulus[3]):
            count += modulus[3]
        else:
            count += modulus[1]

        # Update the values in modulus array.
        modulus[1] -= count
        modulus[3] -= count

        # Use modulus[2] to pair remaining elements.
        modulus[2] += modulus[1] // 2
        modulus[2] += modulus[3] // 2

        # increment count to half of remaining
        # modulus[1] or modulus of [3] elements.
        count += modulus[1] // 2
        count += modulus[3] // 2

        # increment count by half of modulus[2]
        count += modulus[2] // 2

        return count

# Driver Code

# size of array
n = 7

# input array
arr = [1, 2, 3, 1, 2, 3, 8]

count = getSteps(arr, n)
print(count)

# This code is contributed by mohit kumar

C#

// C# program for the above approach
using System;

class GFG
{

static int getSteps(int []arr, int n)
{
    // Count to keep track of the number of steps done.
    int count = 0;

    // Modulus array to store all elements mod 4
    int []modulus = new int[4];

    // sum to check if given task is possible
    int sum = 0;

    // Loop to store all elements
    // mod 4 and calculate sum;
    int i;
    for (i = 0; i < n; i++)
    {
        int mod = arr[i] % 4;
        sum += mod;
        modulus[mod]++;
    }

    // If sum is not divisible by 4, not possible
    if (sum % 4 != 0)
    {
        return -1;
    }
    else
    {

        // Find minimum of modulus[1] and modulus[3]
        // and increment the count by the minimum
        if (modulus[1] > modulus[3])
        {
            count += modulus[3];
        }
        else
        {
            count += modulus[1];
        }

        // Update the values in modulus array.
        modulus[1] -= count;
        modulus[3] -= count;

        // Use modulus[2] to pair remaining elements.
        modulus[2] += modulus[1] / 2;
        modulus[2] += modulus[3] / 2;

        // increment count to half of remaining
        // modulus[1] or modulus of [3] elements.
        count += modulus[1] / 2;
        count += modulus[3] / 2;

        // increment count by half of modulus[2]
        count += modulus[2] / 2;

        return count;
    }
}

// Driver Code
public static void Main(String[] args)
{
    // size of array
    int n = 7;

    // input array
    int []arr = { 1, 2, 3, 1, 2, 3, 8 };

    int count = getSteps(arr, n);
    Console.Write("{0}", count);
}
}

// This code contributed by Rajput-Ji

PHP

<?php
// PHP program for the above approach

function getSteps($arr, $n)
{
    // Count to keep track of the number
    // of steps done.
    $count = 0;

    // Modulus array to store all elements mod 4
    $modulus = array_fill(0, 4, 0);

    // sum to check if given task is possible
    $sum = 0;

    // Loop to store all elements
    // mod 4 and calculate sum;
    for ($i = 0; $i < $n; $i++)
    {
        $mod = $arr[$i] % 4;
        $sum += $mod;
        $modulus[$mod]++;
    }

    // If sum is not divisible by 4, not possible
    if ($sum % 4 != 0)
    {
        return -1;
    }
    else
    {

        // Find minimum of modulus[1] and modulus[3]
        // and increment the count by the minimum
        if ($modulus[1] > $modulus[3])
        {
            $count += $modulus[3];
        }
        else
        {
            $count += $modulus[1];
        }

        // Update the values in modulus array.
        $modulus[1] -= $count;
        $modulus[3] -= $count;

        // Use modulus[2] to pair remaining elements.
        $modulus[2] += (int)($modulus[1] / 2);
        $modulus[2] += (int)($modulus[3] / 2);

        // increment count to half of remaining
        // modulus[1] or modulus of [3] elements.
        $count += (int)($modulus[1] / 2);
        $count += (int)($modulus[3] / 2);

        // increment count by half of modulus[2]
        $count += (int)($modulus[2] / 2);

        return $count;
    }
}

// Driver Code

// size of array
$n = 7;

// input array
$arr = array( 1, 2, 3, 1, 2, 3, 8 );

$count = getSteps($arr, $n);
print($count);

// This code contributed by mits
?>

Javascript

<script>

    function getSteps(arr, n)
    {

        // Count to keep track of the
        // number of steps done.
        let count = 0;

        // Modulus array to store all elements mod 4
        let modulus = new Array(4);
        modulus.fill(0);

        // sum to check if given task is possible
        let sum = 0;

        // Loop to store all elements mod 4
        // and calculate sum;
        let i;
        for (i = 0; i < n; i++)
        {
            let mod = arr[i] % 4;
            sum += mod;
            modulus[mod]++;
        }

        // If sum is not divisible by 4,
        // not possible
        if (sum % 4 != 0)
        {
            return -1;
        }
        else
        {

            // Find minimum of modulus[1] and modulus[3]
            // and increment the count by the minimum
            if (modulus[1] > modulus[3])
            {
                count += modulus[3];
            }
            else
            {
                count += modulus[1];
            }

            // Update the values in modulus array.
            modulus[1] -= count;
            modulus[3] -= count;

            // Use modulus[2] to pair remaining elements.
            modulus[2] += parseInt(modulus[1] / 2, 10);
            modulus[2] += parseInt(modulus[3] / 2, 10);

            // increment count to half of remaining
            // modulus[1] or modulus of [3] elements.
            count += parseInt(modulus[1] / 2, 10);
            count += parseInt(modulus[3] / 2, 10);

            // increment count by half of modulus[2]
            count += parseInt(modulus[2] / 2, 10);

            return count;
        }
    }

    // size of array
    let n = 7;

    // input array
    let arr = [ 1, 2, 3, 1, 2, 3, 8 ];
    let count = getSteps(arr, n);
    document.write(count);

    // This code is contributed by divyeshrabadiya07.
</script>

Output:

3

Time Complexity: O(n)

Auxiliary Space: O(1)