Minimum steps to make all the elements of the array divisible by 4
Last Updated :
31 Jul, 2022
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)
{
int count = 0;
int modulus[4] = { 0 };
int sum = 0;
int i;
for (i = 0; i < n; i++)
{
int mod = arr[i] % 4;
sum += mod;
modulus[mod]++;
}
if (sum % 4 != 0)
{
return -1;
}
else
{
if (modulus[1] > modulus[3])
{
count += modulus[3];
}
else
{
count += modulus[1];
}
modulus[1] -= count;
modulus[3] -= count;
modulus[2] += modulus[1] / 2;
modulus[2] += modulus[3] / 2;
count += modulus[1] / 2;
count += modulus[3] / 2;
count += modulus[2] / 2;
return count;
}
}
int main()
{
int n = 7;
int arr[] = { 1, 2, 3, 1, 2, 3, 8 };
int count = getSteps(arr, n);
cout << count;
}
|
C
#include <stdio.h>
#include <string.h>
int getSteps( int arr[], int n)
{
int count = 0;
int modulus[4] = { 0 };
int sum = 0;
int i;
for (i = 0; i < n; i++) {
int mod = arr[i] % 4;
sum += mod;
modulus[mod]++;
}
if (sum % 4 != 0) {
return -1;
}
else {
if (modulus[1] > modulus[3]) {
count += modulus[3];
}
else {
count += modulus[1];
}
modulus[1] -= count;
modulus[3] -= count;
modulus[2] += modulus[1] / 2;
modulus[2] += modulus[3] / 2;
count += modulus[1] / 2;
count += modulus[3] / 2;
count += modulus[2] / 2;
return count;
}
}
int main()
{
int n = 7;
int arr[] = { 1, 2, 3, 1, 2, 3, 8 };
int count = getSteps(arr, n);
printf ( "%d" , count);
}
|
Java
class GFG
{
static int getSteps( int arr[], int n)
{
int count = 0 ;
int modulus[] = new int [ 4 ];
int sum = 0 ;
int i;
for (i = 0 ; i < n; i++)
{
int mod = arr[i] % 4 ;
sum += mod;
modulus[mod]++;
}
if (sum % 4 != 0 )
{
return - 1 ;
}
else {
if (modulus[ 1 ] > modulus[ 3 ])
{
count += modulus[ 3 ];
}
else
{
count += modulus[ 1 ];
}
modulus[ 1 ] -= count;
modulus[ 3 ] -= count;
modulus[ 2 ] += modulus[ 1 ] / 2 ;
modulus[ 2 ] += modulus[ 3 ] / 2 ;
count += modulus[ 1 ] / 2 ;
count += modulus[ 3 ] / 2 ;
count += modulus[ 2 ] / 2 ;
return count;
}
}
public static void main(String[] args)
{
int n = 7 ;
int arr[] = { 1 , 2 , 3 , 1 , 2 , 3 , 8 };
int count = getSteps(arr, n);
System.out.printf( "%d" , count);
}
}
|
Python3
def getSteps(arr, n):
count = 0
modulus = [ 0 for i in range ( 4 )]
Sum = 0
i = 0
for i in range (n):
mod = arr[i] % 4
Sum + = mod
modulus[mod] + = 1
if ( Sum % 4 ! = 0 ):
return - 1
else :
if (modulus[ 1 ] > modulus[ 3 ]):
count + = modulus[ 3 ]
else :
count + = modulus[ 1 ]
modulus[ 1 ] - = count
modulus[ 3 ] - = count
modulus[ 2 ] + = modulus[ 1 ] / / 2
modulus[ 2 ] + = modulus[ 3 ] / / 2
count + = modulus[ 1 ] / / 2
count + = modulus[ 3 ] / / 2
count + = modulus[ 2 ] / / 2
return count
n = 7
arr = [ 1 , 2 , 3 , 1 , 2 , 3 , 8 ]
count = getSteps(arr, n)
print (count)
|
C#
using System;
class GFG
{
static int getSteps( int []arr, int n)
{
int count = 0;
int []modulus = new int [4];
int sum = 0;
int i;
for (i = 0; i < n; i++)
{
int mod = arr[i] % 4;
sum += mod;
modulus[mod]++;
}
if (sum % 4 != 0)
{
return -1;
}
else
{
if (modulus[1] > modulus[3])
{
count += modulus[3];
}
else
{
count += modulus[1];
}
modulus[1] -= count;
modulus[3] -= count;
modulus[2] += modulus[1] / 2;
modulus[2] += modulus[3] / 2;
count += modulus[1] / 2;
count += modulus[3] / 2;
count += modulus[2] / 2;
return count;
}
}
public static void Main(String[] args)
{
int n = 7;
int []arr = { 1, 2, 3, 1, 2, 3, 8 };
int count = getSteps(arr, n);
Console.Write( "{0}" , count);
}
}
|
PHP
<?php
function getSteps( $arr , $n )
{
$count = 0;
$modulus = array_fill (0, 4, 0);
$sum = 0;
for ( $i = 0; $i < $n ; $i ++)
{
$mod = $arr [ $i ] % 4;
$sum += $mod ;
$modulus [ $mod ]++;
}
if ( $sum % 4 != 0)
{
return -1;
}
else
{
if ( $modulus [1] > $modulus [3])
{
$count += $modulus [3];
}
else
{
$count += $modulus [1];
}
$modulus [1] -= $count ;
$modulus [3] -= $count ;
$modulus [2] += (int)( $modulus [1] / 2);
$modulus [2] += (int)( $modulus [3] / 2);
$count += (int)( $modulus [1] / 2);
$count += (int)( $modulus [3] / 2);
$count += (int)( $modulus [2] / 2);
return $count ;
}
}
$n = 7;
$arr = array ( 1, 2, 3, 1, 2, 3, 8 );
$count = getSteps( $arr , $n );
print ( $count );
?>
|
Javascript
<script>
function getSteps(arr, n)
{
let count = 0;
let modulus = new Array(4);
modulus.fill(0);
let sum = 0;
let i;
for (i = 0; i < n; i++)
{
let mod = arr[i] % 4;
sum += mod;
modulus[mod]++;
}
if (sum % 4 != 0)
{
return -1;
}
else
{
if (modulus[1] > modulus[3])
{
count += modulus[3];
}
else
{
count += modulus[1];
}
modulus[1] -= count;
modulus[3] -= count;
modulus[2] += parseInt(modulus[1] / 2, 10);
modulus[2] += parseInt(modulus[3] / 2, 10);
count += parseInt(modulus[1] / 2, 10);
count += parseInt(modulus[3] / 2, 10);
count += parseInt(modulus[2] / 2, 10);
return count;
}
}
let n = 7;
let arr = [ 1, 2, 3, 1, 2, 3, 8 ];
let count = getSteps(arr, n);
document.write(count);
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...