# Minimum elements to be removed such that sum of adjacent elements is always odd

• Difficulty Level : Easy
• Last Updated : 16 Sep, 2022

Given an array of N integers. The task is to eliminate the minimum number of elements such that in the resulting array the sum of any two adjacent values is odd.

Examples:

Input: arr[] = {1, 2, 3}
Output:
Sum of all adjacent elements is already odd.

Input: arr[] = {1, 3, 5, 4, 2}
Output:
Eliminate 3, 5 and 2 so that in the resulting array the sum of any two adjacent values is odd.

Approach The sum of 2 numbers is odd if one of them is odd and the other is even. This means for every pair of consecutive numbers that have the same parity, eliminate one of them, it doesn’t matter which. So the following greedy algorithm works:

• Go through all the elements in order.
• If the current number has the same parity as the previous one eliminate it, otherwise don’t.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include``using` `namespace` `std;` `// Returns the minimum number of eliminations``int` `min_elimination(``int` `n, ``int` `arr [])``{``    ``int` `count = 0;` `    ``// Stores the previous element``    ``int` `prev_val = arr;` `    ``// Stores the new value``    ``for` `(``int` `i = 1; i < n; i++)``    ``{``        ``int` `curr_val = arr[i];` `        ``// Check if the previous and current``        ``// values are of same parity``        ``if` `(curr_val % 2 == prev_val % 2)``            ``count++;` `        ``// Previous value is now the current value``        ``prev_val = curr_val;``    ``}` `    ``// Return the counter variable``    ``return` `count;``}` `// Driver code``int` `main()``{``    ``int` `arr [] = { 1, 2, 3, 7, 9 };``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);` `    ``cout << min_elimination(n, arr);``    ` `    ``return` `0;``}` `// This code is contributed by ihritik`

## Java

 `// Java implementation of the above approach` `class` `GFG {` `    ``// Returns the minimum number of eliminations``    ``static` `int` `min_elimination(``int` `n, ``int``[] arr)``    ``{``        ``int` `count = ``0``;` `        ``// Stores the previous element``        ``int` `prev_val = arr[``0``];` `        ``// Stores the new value``        ``for` `(``int` `i = ``1``; i < n; i++) {``            ``int` `curr_val = arr[i];` `            ``// Check if the previous and current``            ``// values are of same parity``            ``if` `(curr_val % ``2` `== prev_val % ``2``)``                ``count++;` `            ``// Previous value is now the current value``            ``prev_val = curr_val;``        ``}` `        ``// Return the counter variable``        ``return` `count;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = ``new` `int``[] { ``1``, ``2``, ``3``, ``7``, ``9` `};``        ``int` `n = arr.length;` `        ``System.out.println(min_elimination(n, arr));``    ``}``}`

## Python3

 `# Python3 implementation of the above approach` `# Returns the minimum number of eliminations``def` `min_elimination(n, arr):` `    ``count ``=` `0` `    ``# Stores the previous element``    ``prev_val ``=` `arr[``0``]` `    ``# Stores the new value``    ``for` `i ``in` `range` `(``1``, n):``        ``curr_val ``=` `arr[i];` `        ``# Check if the previous and current``        ``# values are of same parity``        ``if` `(curr_val ``%` `2` `=``=` `prev_val ``%` `2``):``            ``count ``=` `count ``+` `1` `        ``# Previous value is now the current value``        ``prev_val ``=` `curr_val``    `  `    ``# Return the counter variable``    ``return` `count` `# Driver code``arr ``=` `[ ``1``, ``2``, ``3``, ``7``, ``9` `]``n ``=` `len``(arr)` `print``(min_elimination(n, arr));` `# This code is contributed by ihritik`

## C#

 `// C# implementation of the above approach``using` `System;` `class` `GFG``{` `    ``// Returns the minimum number of eliminations``    ``static` `int` `min_elimination(``int` `n, ``int``[] arr)``    ``{``        ``int` `count = 0;` `        ``// Stores the previous element``        ``int` `prev_val = arr;` `        ``// Stores the new value``        ``for` `(``int` `i = 1; i < n; i++)``        ``{``            ``int` `curr_val = arr[i];` `            ``// Check if the previous and current``            ``// values are of same parity``            ``if` `(curr_val % 2 == prev_val % 2)``                ``count++;` `            ``// Previous value is now the current value``            ``prev_val = curr_val;``        ``}` `        ``// Return the counter variable``        ``return` `count;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = ``new` `int``[] { 1, 2, 3, 7, 9 };``        ``int` `n = arr.Length;` `        ``Console.WriteLine(min_elimination(n, arr));``    ``}``}` `// This code is contributed by ihritik`

## PHP

 ``

## Javascript

 ``

Output

`2`

Complexity Analysis:

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

My Personal Notes arrow_drop_up