Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize increments required to make differences between all pairs of array elements even

  • Last Updated : 03 May, 2021

Given an array, arr[] consisting of N integers, the task is to minimize the number of increments of array elements required to make all differences pairs of array elements even.

Examples:

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

Operation 1: Increment arr[1] by 1. The array arr[] modifies to {4, 2, 2}.
All pairs: (4, 2) → difference = 2
(4, 2) → difference = 2
(2, 2) → difference = 0
Now, the pairwise differences between array elements is even. Hence, the answer is 1.

Input: arr[] = {2, 4}
Output: 0
Explanation: Differences between all pairs of array elements is already even. Therefore, the answer is 0.

Approach: The given problem can be solved by observing the fact that, to make the difference between all pairs of array elements even, both the elements must be of the same parity. Therefore, the idea is to convert all the array elements to either even numbers or odd numbers. The minimum number of increments is equal to the minimum of the count of even and odd array elements. 
 

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum increments
// required to difference between all
// pairs of array elements even
void minimumOperations(int arr[], int N)
{
    // Store the count of odd
    // and even numbers
    int oddCnt = 0, evenCnt = 0;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
 
        if (arr[i] % 2 == 0) {
 
            // Increment evenCnt by 1
            evenCnt++;
        }
        else {
 
            // Increment eveCnt by 1
            oddCnt++;
        }
    }
 
    // Print the minimum of oddCnt
    // and eveCnt
    cout << min(oddCnt, evenCnt);
}
 
// Driver Code
int main()
{
    int arr[] = { 4, 1, 2 };
    int N = sizeof(arr) / sizeof(arr[0]);
    minimumOperations(arr, N);
 
    return 0;
}
Java



// Java program for the above approach
public class GFG
{
 
  // Function to find the minimum increments
  // required to difference between all
  // pairs of array elements even
  static void minimumOperations(int[] arr, int N)
  {
 
    // Store the count of odd
    // and even numbers
    int oddCnt = 0, evenCnt = 0;
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
      if (arr[i] % 2 == 0)
      {
 
        // Increment evenCnt by 1
        evenCnt++;
      }
      else
      {
 
        // Increment oddCnt by 1
        oddCnt++;
      }
    }
 
    // Print the minimum of oddCnt
    // and eveCnt
    System.out.print(Math.min(oddCnt, evenCnt));
  }  
 
  // Driver code
  public static void main(String args[])
  {
    int[] arr = { 4, 1, 2 };
    int N = arr.length;
    minimumOperations(arr, N);
  }
}
 
// This code is contributed by AnkThon
Python3



# Python program for the above approach
 
# Function to find the minimum increments
# required to difference between all
# pairs of array elements even
def minimumOperations(arr, N) :
     
    # Store the count of odd
    # and even numbers
    oddCnt = 0
    evenCnt = 0
 
    # Traverse the array
    for i in range(N):
        if (arr[i] % 2 == 0) :
 
            # Increment evenCnt by 1
            evenCnt += 1
         
        else :
 
            # Increment eveCnt by 1
            oddCnt += 1
         
    # Prthe minimum of oddCnt
    # and eveCnt
    print(min(oddCnt, evenCnt))
 
# Driver Code
arr = [ 4, 1, 2 ]
N = len(arr)
minimumOperations(arr, N)
 
# This code is contributed by sanjoy_62.
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG
{
     
    // Function to find the minimum increments
    // required to difference between all
    // pairs of array elements even
    static void minimumOperations(int[] arr, int N)
    {
       
        // Store the count of odd
        // and even numbers
        int oddCnt = 0, evenCnt = 0;
       
        // Traverse the array
        for (int i = 0; i < N; i++)
        {
            if (arr[i] % 2 == 0)
            {
       
                // Increment evenCnt by 1
                evenCnt++;
            }
            else
            {
       
                // Increment eveCnt by 1
                oddCnt++;
            }
        }
       
        // Print the minimum of oddCnt
        // and eveCnt
        Console.Write(Math.Min(oddCnt, evenCnt));
    }  
 
  // Driver code
  static void Main()
  {
    int[] arr = { 4, 1, 2 };
    int N = arr.Length;
    minimumOperations(arr, N);
  }
}
 
// This code is contributed by divyeshrabadiya07.
Javascript



<script>
// Java script program for the above approach
 
 
// Function to find the minimum increments
// required to difference between all
// pairs of array elements even
function minimumOperations(arr,N)
{
 
    // Store the count of odd
    // and even numbers
    let oddCnt = 0, evenCnt = 0;
 
    // Traverse the array
    for (let i = 0; i < N; i++)
    {
    if (arr[i] % 2 == 0)
    {
 
        // Increment evenCnt by 1
        evenCnt++;
    }
    else
    {
 
        // Increment oddCnt by 1
        oddCnt++;
    }
    }
 
    // Print the minimum of oddCnt
    // and eveCnt
    document.write(Math.min(oddCnt, evenCnt));
}
 
// Driver code
 
    let arr = [ 4, 1, 2 ];
    let N = arr.length;
    minimumOperations(arr, N);
 
 
// This code is contributed by Bobby
</script>
Output: 
1
 
Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Previous
Largest area possible after removal of a series of horizontal & vertical bars
Next

Calculate score of parentheses from a given string
Recommended Articles
Page :
Minimize increments required to make count of even and odd array elements equal
22, Jan 21
Minimize subtraction followed by increments of adjacent elements required to make all array elements equal
22, Mar 21
Minimum increments required to make absolute difference of all pairwise adjacent array elements even
19, Apr 21
Minimize increments or decrements required to make sum and product of array elements non-zero
09, Nov 20
Minimum increments required to make the sum of all adjacent matrix elements even
17, Feb 21
Minimum increments required to make array elements alternately even and odd
19, Feb 21
Minimize subarray increments/decrements required to reduce all array elements to 0
17, Sep 20
Minimize count of increments of each element of subarrays required to make Array non-increasing
31, Aug 20
Minimum prefix increments required to make all elements of an array multiples of another array
31, Jan 21
Minimum increments or decrements by D required to make all array elements equal
13, Jan 21
Minimum increments or decrements by 1 required to make all array elements in AP
21, Jul 21
Minimum number of swaps required to minimize sum of absolute differences between adjacent array elements
13, May 21
Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K
03, Mar 21
Minimum increments to make all array elements equal with sum same as the given array after exactly one removal
04, Dec 20
Minimum increments to modify array such that value of any array element can be splitted to make all remaining elements equal
25, Dec 20
Minimum increments of Non-Decreasing Subarrays required to make Array Non-Decreasing
19, Aug 20
Minimize cost to make X and Y equal by given increments
15, Jan 21
Check if all elements of a Circular Array can be made equal by increments of adjacent pairs
18, Aug 20
Minimize moves required to make array elements equal by incrementing and decrementing pairs | Set 2
20, Jul 21
Minimum increments done in Array such that arr[i] can make all other elements equal
18, Nov 21
Minimize sum of absolute difference between all pairs of array elements by decrementing and incrementing pairs by 1
30, Jul 21
Minimum increments required to make given matrix palindromic
29, Oct 20
Minimize replacements of leftmost largest array element required to make all array elements equal
28, Jun 21
Minimum increments by index value required to obtain at least two equal Array elements
17, Aug 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dharanendralv23
@dharanendralv23
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!