Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Make all the elements of array even with given operations

  • Last Updated : 31 May, 2021

Given an array arr[] of positive integers, find the minimum number of operations required to make all the array elements even where:  

  1. If there is an odd number, then, increment the element and the next adjacent element by 1.
  2. Each increment costs one operation.

Note: If there is any number in arr[] which is odd after all operations, then, print -1.

Examples: 

Input: arr[] = {2, 3, 4, 5, 6} 
Output: 4 
Explanation: 
Add 1 to 3 (at 1st index) and add 1 to its adjacent element 4(2nd index). 
Now the array becomes {2, 4, 5, 5, 6}. 
Add 1 to 5 (at 2nd index) and add 1 to its adjacent element 5(3rd index). 
Now the array becomes {2, 4, 6, 6, 6}. 
The resultant array has all even numbers. 
The total number of operations for 4 increments is 4.

Input: arr[] = {5, 6} 
Output: -1 
Explanation: 
Adding 1 to 5(0th index), then we have to increment 1 to its adjacent element 6(1st index). 
Now the array becomes {6, 7}. 
And we have 1 odd number left after all possible increments. Therefore, we can’t make all array elements even.  

Approach: 
This problem can be solved using Greedy Approach. The following are the steps: 

  1. Traverse the given array arr[].
  2. If an odd element occurs, then increment that element by 1 to make it even and the next adjacent element by 1.
  3. Repeat the above step for all the odd elements for the given array arr[].
  4. If all the elements in arr[] are even, then print the number of operations.
  5. Else print -1.

Below is the implementation of the above approach: 

C++




// C++ program to make all array
// element even
#include "bits/stdc++.h"
using namespace std;
 
// Function to count the total
// number of operations needed to make
// all array element even
int countOperations(int arr[], int n)
{
    int count = 0;
 
    // Traverse the given array
    for (int i = 0; i < n - 1; i++) {
 
        // If an odd element occurs
        // then increment that element
        // and next adjacent element
        // by 1
        if (arr[i] & 1) {
            arr[i]++;
            arr[i + 1]++;
            count += 2;
        }
    }
 
    // Traverse the array if any odd
    // element occurs then return -1
    for (int i = 0; i < n; i++) {
        if (arr[i] & 1)
            return -1;
    }
 
    // Returns the count of operations
    return count;
}
 
int main()
{
    int arr[] = { 2, 3, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(int);
    cout << countOperations(arr, n);
    return 0;
}
Java



// Java program to make all array
// element even
class GFG
{
 
// Function to count the total
// number of operations needed to make
// all array element even
static int countOperations(int arr[], int n)
{
    int count = 0;
 
    // Traverse the given array
    for (int i = 0; i < n - 1; i++)
    {
 
        // If an odd element occurs
        // then increment that element
        // and next adjacent element
        // by 1
        if (arr[i] % 2 == 1)
        {
            arr[i]++;
            arr[i + 1]++;
            count += 2;
        }
    }
 
    // Traverse the array if any odd
    // element occurs then return -1
    for (int i = 0; i < n; i++)
    {
        if (arr[i] % 2 == 1)
            return -1;
    }
 
    // Returns the count of operations
    return count;
}
 
// Driver code
public static void main(String[] args)
{
    int arr[] = { 2, 3, 4, 5, 6 };
    int n = arr.length;
    System.out.print(countOperations(arr, n));
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 program to make all array
# element even
 
# Function to count the total
# number of operations needed to make
# all array element even
def countOperations(arr, n) :
 
    count = 0;
 
    # Traverse the given array
    for i in range(n - 1) :
 
        # If an odd element occurs
        # then increment that element
        # and next adjacent element
        # by 1
        if (arr[i] & 1) :
            arr[i] += 1;
            arr[i + 1] += 1;
            count += 2;
 
    # Traverse the array if any odd
    # element occurs then return -1
    for i in range(n) :
        if (arr[i] & 1) :
            return -1;
 
    # Returns the count of operations
    return count;
 
if __name__ == "__main__" :
 
    arr = [ 2, 3, 4, 5, 6 ];
    n = len(arr);
    print(countOperations(arr, n));
     
    # This code is contributed by AnkitRai01
C#



// C# program to make all array
// element even
using System;
 
class GFG
{
 
// Function to count the total
// number of operations needed to make
// all array element even
static int countOperations(int []arr, int n)
{
    int count = 0;
 
    // Traverse the given array
    for (int i = 0; i < n - 1; i++)
    {
 
        // If an odd element occurs
        // then increment that element
        // and next adjacent element
        // by 1
        if (arr[i] % 2 == 1)
        {
            arr[i]++;
            arr[i + 1]++;
            count += 2;
        }
    }
 
    // Traverse the array if any odd
    // element occurs then return -1
    for (int i = 0; i < n; i++)
    {
        if (arr[i] % 2 == 1)
            return -1;
    }
 
    // Returns the count of operations
    return count;
}
 
// Driver code
public static void Main()
{
    int []arr = { 2, 3, 4, 5, 6 };
    int n = arr.Length;
    Console.Write(countOperations(arr, n));
}
}
 
// This code is contributed by AnkitRai01
Javascript



<script>
// Javascript program to make all array
// element even
 
// Function to count the total
// number of operations needed to make
// all array element even
function countOperations(arr, n)
{
    let count = 0;
 
    // Traverse the given array
    for (let i = 0; i < n - 1; i++) {
 
        // If an odd element occurs
        // then increment that element
        // and next adjacent element
        // by 1
        if (arr[i] & 1) {
            arr[i]++;
            arr[i + 1]++;
            count += 2;
        }
    }
 
    // Traverse the array if any odd
    // element occurs then return -1
    for (let i = 0; i < n; i++) {
        if (arr[i] & 1)
            return -1;
    }
 
    // Returns the count of operations
    return count;
}
 
 
let arr = [ 2, 3, 4, 5, 6 ];
let n = arr.length;
document.write(countOperations(arr, n));
 
// This code is contributed by _saurabh_jaiswal
</script>
Output: 
4
 
Time Complexity: O(N) where N is the number of elements in the array.
 

My Personal Notes
arrow_drop_up
Previous
Find the largest composite number that divides N but is strictly lesser than N
Next

Recursive Program to print multiplication table of a number
Recommended Articles
Page :
Make all array elements even by replacing any pair of array elements with their sum
21, Dec 20
Make all array elements even by replacing adjacent pair of array elements with their sum
21, Dec 20
Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array
04, Dec 21
Rearrange array such that all even-indexed elements in the Array is even
15, Aug 20
Make all the array elements odd with minimum operations of given type
13, Jan 20
Find if it is possible to make all elements of an array equal by the given operations
30, Mar 20
Minimum Cost to make all array elements equal using given operations
22, May 20
Minimize count of given operations required to be performed to make all array elements equal to 1
13, Jan 21
Count arrays having at least K elements exceeding XOR of all given array elements by X given operations
17, Feb 21
Minimum number of operations required to make all elements of at least one row of given Matrix prime
11, Dec 20
Minimum delete operations to make all elements of array same
09, Dec 16
Minimum gcd operations to make all array elements one
19, Nov 17
Find the number of operations required to make all array elements Equal
24, Jun 18
Minimum operations required to make all Array elements divisible by K
02, Jul 20
Minimum no. of operations required to make all Array Elements Zero
08, Oct 18
Minimum operations required to make all the array elements equal
25, Jan 19
Minimum number of operations on an array to make all elements 0
05, Feb 19
Count of operations to make all elements of array a[] equal to its min element by performing a[i] – b[i]
19, May 20
Minimum operations required to make all elements in an array of first N odd numbers equal
07, May 21
Minimum operations required to make all elements of Array less than equal to 0
05, Jul 21
Minimize operations to make all array elements -1 by changing maximums of K-size subarray to -1
20, Sep 21
Minimum operations to make all elements equal using the second array
07, May 20
Minimum number of increment-other operations to make all array elements equal.
05, Oct 17
Find the minimum number of operations required to make all array elements equal
05, Apr 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
mishrakishan1
@mishrakishan1
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!