# Minimize adding odd and subtracting even numbers to make all array elements equal to K

• Difficulty Level : Medium
• Last Updated : 26 Apr, 2021

Given an array, arr[] of size N and an integer K, the task is to find the minimum number of operations required to make all array elements equal to K by performing the following operations any number of times:

• Convert arr[i] to arr[i] + X, where X is an odd number.
• Convert arr[i] to arr[i] – Y, where Y is an even number.

Examples:

Input: arr[] = {8, 7, 2, 1, 3}, K = 5
Output:
Explanation: To make all elements of the given array equal to K(= 5), following operations are required:
arr = arr + X, X = 1
arr = arr – Y, Y = 4
arr = arr – Y, Y = 2
arr = arr + X, X = 3
arr = arr + X, X = 3
arr = arr + X, X = 1
arr = arr + X, X = 1
arr = arr + X, X = 1

Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, K = 3
Output:

Approach: The problem can be solved using the Greedy technique. Following are the observations:

Even + Even = Even
Even + Odd = Odd
Odd + Odd = Even
Odd + Even = Odd

Follow the steps below to solve the problem:

• Traverse the given array and check the following conditions.
• If K > arr[i] and (K – arr[i]) % 2 == 0 then add two odd numbers(X) into arr[i]. Therefore, total 2 operations required.
• If K > arr[i] and (K – arr[i]) % 2 != 0 then add one odd numbers(X) into arr[i]. Therefore, total 1 operations required.
• If K < arr[i] and (arr[i] – arr[i]) % 2 == 0 then subtract one even numbers(Y) into arr[i]. Therefore, total 1 operations required.
• If K < arr[i] and (K – arr[i]) % 2 != 0 then add an odd numbers(X) into arr[i] and subtract an even numbers(Y) from arr[i]. Therefore, total 2 operations required.
• Finally, print the total number of operations required to make all the array elements equal to K.

Below is the implementation of the above approach

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum operations``// required to make array elements equal to K``int` `MinOperation(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Stores minimum count of operations``    ``int` `cntOpe = 0;` `    ``// Traverse the given array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If K is greater than arr[i]``        ``if` `(K > arr[i]) {` `            ``// If (K - arr[i]) is even``            ``if` `((K - arr[i]) % 2 == 0) {` `                ``// Update cntOpe``                ``cntOpe += 2;``            ``}``            ``else` `{` `                ``// Update cntOpe``                ``cntOpe += 1;``            ``}``        ``}` `        ``// If K is less than arr[i]``        ``else` `if` `(K < arr[i]) {` `            ``// If (arr[i] - K) is even``            ``if` `((K - arr[i]) % 2 == 0) {` `                ``// Update cntOpe``                ``cntOpe += 1;``            ``}``            ``else` `{` `                ``// Update cntOpe``                ``cntOpe += 2;``            ``}``        ``}``    ``}` `    ``return` `cntOpe;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 8, 7, 2, 1, 3 };``    ``int` `K = 5;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << MinOperation(arr, N, K);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``class` `GFG{``    ` `// Function to find the minimum``// operations required to make``// array elements equal to K``public` `static` `int` `MinOperation(``int` `arr[],``                               ``int` `N, ``int` `K)``{``  ``// Stores minimum count of``  ``// operations``  ``int` `cntOpe = ``0``;` `  ``// Traverse the given array``  ``for` `(``int` `i = ``0``; i < N; i++)``  ``{``    ``// If K is greater than``    ``// arr[i]``    ``if` `(K > arr[i])``    ``{``      ``// If (K - arr[i]) is even``      ``if` `((K - arr[i]) % ``2` `== ``0``)``      ``{``        ``// Update cntOpe``        ``cntOpe += ``2``;``      ``}``      ``else``      ``{``        ``// Update cntOpe``        ``cntOpe += ``1``;``      ``}``    ``}` `    ``// If K is less than``    ``// arr[i]``    ``else` `if` `(K < arr[i])``    ``{``      ``// If (arr[i] - K) is``      ``// even``      ``if` `((K - arr[i]) % ``2` `== ``0``)``      ``{``        ``// Update cntOpe``        ``cntOpe += ``1``;``      ``}``      ``else``      ``{``        ``// Update cntOpe``        ``cntOpe += ``2``;``      ``}``    ``}``  ``}` `  ``return` `cntOpe;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``int` `arr[] = {``8``, ``7``, ``2``, ``1``, ``3``};``  ``int` `K = ``5``;``  ``int` `N = arr.length;``  ``System.out.println(``  ``MinOperation(arr, N, K));``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program to implement``# the above approach`` ` `# Function to find the minimum operations``# required to make array elements equal to K``def` `MinOperation(arr, N, K):``    ` `    ``# Stores minimum count of operations``    ``cntOpe ``=` `0`` ` `    ``# Traverse the given array``    ``for` `i ``in` `range``(N):`` ` `        ``# If K is greater than arr[i]``        ``if` `(K > arr[i]):`` ` `            ``# If (K - arr[i]) is even``            ``if` `((K ``-` `arr[i]) ``%` `2` `=``=` `0``):`` ` `                ``# Update cntOpe``                ``cntOpe ``+``=` `2``            ` `            ``else``:`` ` `                ``# Update cntOpe``                ``cntOpe ``+``=` `1``            ` `        ``# If K is less than arr[i]``        ``elif` `(K < arr[i]):``            ` `            ``# If (arr[i] - K) is even``            ``if` `((K ``-` `arr[i]) ``%` `2` `=``=` `0``):`` ` `                ``# Update cntOpe``                ``cntOpe ``+``=` `1``            ` `            ``else``:`` ` `                ``# Update cntOpe``                ``cntOpe ``+``=` `2` `    ``return` `cntOpe` `# Driver Code``arr ``=` `[ ``8``, ``7``, ``2``, ``1``, ``3` `]``K ``=` `5``N ``=` `len``(arr)` `print``(MinOperation(arr, N, K))` `# This code is contributed by sanjoy_62`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the minimum``// operations required to make``// array elements equal to K``public` `static` `int` `MinOperation(``int` `[]arr,``                               ``int` `N, ``int` `K)``{``  ` `  ``// Stores minimum count of``  ``// operations``  ``int` `cntOpe = 0;` `  ``// Traverse the given array``  ``for``(``int` `i = 0; i < N; i++)``  ``{``    ` `    ``// If K is greater than``    ``// arr[i]``    ``if` `(K > arr[i])``    ``{``      ` `      ``// If (K - arr[i]) is even``      ``if` `((K - arr[i]) % 2 == 0)``      ``{``        ` `        ``// Update cntOpe``        ``cntOpe += 2;``      ``}``      ``else``      ``{``        ` `        ``// Update cntOpe``        ``cntOpe += 1;``      ``}``    ``}` `    ``// If K is less than``    ``// arr[i]``    ``else` `if` `(K < arr[i])``    ``{``      ` `      ``// If (arr[i] - K) is``      ``// even``      ``if` `((K - arr[i]) % 2 == 0)``      ``{``        ` `        ``// Update cntOpe``        ``cntOpe += 1;``      ``}``      ``else``      ``{``        ` `        ``// Update cntOpe``        ``cntOpe += 2;``      ``}``    ``}``  ``}``  ``return` `cntOpe;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``  ``int` `[]arr = {8, 7, 2, 1, 3};``  ``int` `K = 5;``  ``int` `N = arr.Length;``  ` `  ``Console.WriteLine(``  ``MinOperation(arr, N, K));``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`8`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up