 Open in App
Not now

# 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
Related Articles