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

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:0

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

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<bits/stdc++.h>` `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[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` `int` `main()` `{` ` ` `int` `arr [] = { 1, 2, 3, 7, 9 };` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `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[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()` ` ` `{` ` ` `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

`<?php` `// PHP implementation of the above approach` `// Returns the minimum number of eliminations` `function` `min_elimination(` `$n` `, ` `$arr` `)` `{` ` ` `$count` `= 0;` ` ` `// Stores the previous element` ` ` `$prev_val` `= ` `$arr` `[0];` ` ` `// Stores the new value` ` ` `for` `(` `$i` `= 1; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `{` ` ` `$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` `$arr` `= ` `array` `( 1, 2, 3, 7, 9 );` `$n` `= sizeof(` `$arr` `);` `echo` `min_elimination(` `$n` `, ` `$arr` `);` `// This code is contributed by Ryuga` `?>` |

## Javascript

`<script>` `// JavaScript implementation of the above approach` `// Returns the minimum number of eliminations` `function` `min_elimination(n,arr)` `{` ` ` `let count = 0;` ` ` `// Stores the previous element` ` ` `let prev_val = arr[0];` ` ` `// Stores the new value` ` ` `for` `(let i = 1; i < n; i++)` ` ` `{` ` ` `let 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` `let arr = [1, 2, 3, 7, 9];` `let n = arr.length;` `document.write(min_elimination(n, arr));` `</script>` |

**Output:**

2

**Time Complexity:** O(N)

**Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.