Open in App
Not now

Make all array elements even by replacing adjacent pair of array elements with their sum

• Last Updated : 28 Feb, 2022

Given an array arr[] of size N, the task is to make all array elements even by replacing a pair of adjacent elements with their sum.

Examples:

Input: arr[] = { 2, 4, 5, 11, 6 }
Output: 1
Explanation:
Replacing a pair (arr[2], arr[3]) with their sum ( = 5 + 11 = 16) modifies arr[] to { 2, 4, 16, 16, 6 }
Since all array elements are even, the required output is 1.

Input: arr[] = { 1, 2, 4, 3, 11 }
Output: 3
Explanation:
Replacing the pair (arr[3], arr[4]) and replacing them with their sum ( = 3 + 11 = 14) modifies arr[] to { 1, 2, 4, 14, 14 }
Replacing the pair (arr[0], arr[1]) and replacing them with their sum ( = 1 + 2 = 3) modifies arr[] to { 3, 3, 4, 14, 14 }
Replacing the pair (arr[0], arr[1]) with their sum ( = 3 + 3 = 6) modifies arr[] to { 6, 6, 4, 14, 14 }.
Therefore, the required output is 3.

Approach: The idea is to use the fact that the sum of two odd numbers generates an even number. Follow the steps below to solve the problem:

1. Initialize two integers, say res, to count the number of replacements, and odd_continuous_segment, to count the number of continuous odd numbers
2. Traverse the array and check the following conditions for every array element:
1. If arr[i] is odd, then increment the count of odd_continuous_segment by 1
2. Otherwise, if odd_continuous_segment is odd, then increment res by odd_continuous_segment/2. Otherwise, increment res by odd_continuous_segment / 2 + 2 and assign odd_continuous_segment to 0.
3. Check if odd_continuous_segment is odd. If found to be true, then increment res by odd_continuous_segment / 2. Otherwise increment res by (odd_continuous_segment / 2 + 2)
4. Finally, print the obtained value of res

Below is the implementation of the above approach:

C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find minimum count of operations` `// required to make all array elements even` `int` `make_array_element_even(``int` `arr[], ``int` `N)` `{` `    ``// Stores minimum count of replacements` `    ``// to make all array elements even` `    ``int` `res = 0;`   `    ``// Stores the count of odd` `    ``// continuous numbers` `    ``int` `odd_cont_seg = 0;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++) {`   `        ``// If arr[i] is an odd number` `        ``if` `(arr[i] % 2 == 1) {`   `            ``// Update odd_cont_seg` `            ``odd_cont_seg++;` `        ``}` `        ``else` `{`   `            ``if` `(odd_cont_seg > 0) {`   `                ``// If odd_cont_seg is even` `                ``if` `(odd_cont_seg % 2 == 0) {`   `                    ``// Update res` `                    ``res += odd_cont_seg / 2;` `                ``}`   `                ``else` `{`   `                    ``// Update res` `                    ``res += (odd_cont_seg / 2) + 2;` `                ``}`   `                ``// Reset odd_cont_seg = 0` `                ``odd_cont_seg = 0;` `            ``}` `        ``}` `    ``}`   `    ``// If odd_cont_seg exceeds 0` `    ``if` `(odd_cont_seg > 0) {`   `        ``// If odd_cont_seg is even` `        ``if` `(odd_cont_seg % 2 == 0) {`   `            ``// Update res` `            ``res += odd_cont_seg / 2;` `        ``}`   `        ``else` `{`   `            ``// Update res` `            ``res += odd_cont_seg / 2 + 2;` `        ``}` `    ``}`   `    ``// Print the result` `    ``return` `res;` `}`   `// Drivers Code` `int` `main()` `{` `    ``int` `arr[] = { 2, 4, 5, 11, 6 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << make_array_element_even(arr, N);`   `    ``return` `0;` `}`

Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{`   `  ``// Function to find minimum count of operations` `  ``// required to make all array elements even` `  ``static` `int` `make_array_element_even(``int` `arr[], ``int` `N)` `  ``{`   `    ``// Stores minimum count of replacements` `    ``// to make all array elements even` `    ``int` `res = ``0``;`   `    ``// Stores the count of odd` `    ``// continuous numbers` `    ``int` `odd_cont_seg = ``0``;`   `    ``// Traverse the array` `    ``for` `(``int` `i = ``0``; i < N; i++)` `    ``{`   `      ``// If arr[i] is an odd number` `      ``if` `(arr[i] % ``2` `== ``1``)` `      ``{`   `        ``// Update odd_cont_seg` `        ``odd_cont_seg++;` `      ``}` `      ``else` `      ``{` `        ``if` `(odd_cont_seg > ``0``)` `        ``{`   `          ``// If odd_cont_seg is even` `          ``if` `(odd_cont_seg % ``2` `== ``0``) ` `          ``{`   `            ``// Update res` `            ``res += odd_cont_seg / ``2``;` `          ``}`   `          ``else` `          ``{`   `            ``// Update res` `            ``res += (odd_cont_seg / ``2``) + ``2``;` `          ``}`   `          ``// Reset odd_cont_seg = 0` `          ``odd_cont_seg = ``0``;` `        ``}` `      ``}` `    ``}`   `    ``// If odd_cont_seg exceeds 0` `    ``if` `(odd_cont_seg > ``0``) ` `    ``{`   `      ``// If odd_cont_seg is even` `      ``if` `(odd_cont_seg % ``2` `== ``0``) ` `      ``{`   `        ``// Update res` `        ``res += odd_cont_seg / ``2``;` `      ``}`   `      ``else` `      ``{`   `        ``// Update res` `        ``res += odd_cont_seg / ``2` `+ ``2``;` `      ``}` `    ``}`   `    ``// Print the result` `    ``return` `res;` `  ``}`   `  ``// Drivers Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `arr[] = { ``2``, ``4``, ``5``, ``11``, ``6` `};` `    ``int` `N = arr.length;` `    ``System.out.print(make_array_element_even(arr, N));` `  ``}` `}`   `// This code is contributed by shikhasingrajput`

Python3

 `# Python program to implement` `# the above approach`   `# Function to find minimum count of operations` `# required to make all array elements even` `def` `make_array_element_even(arr, N):` `    `  `    ``# Stores minimum count of replacements` `    ``# to make all array elements even` `    ``res ``=` `0` `    `  `    ``# Stores the count of odd` `    ``# continuous numbers` `    ``odd_cont_seg ``=` `0` `    `  `    ``# Traverse the array` `    ``for` `i ``in` `range``(``0``, N):` `        `  `        ``# If arr[i] is an odd number` `        ``if` `(arr[i] ``%` `2` `=``=` `1``):` `          `  `            ``# Update odd_cont_seg` `            ``odd_cont_seg``+``=``1` `        ``else``:` `            ``if` `(odd_cont_seg > ``0``):` `              `  `                ``# If odd_cont_seg is even` `                ``if` `(odd_cont_seg ``%` `2` `=``=` `0``):` `                  `  `                    ``# Update res` `                    ``res ``+``=` `odd_cont_seg ``/``/` `2` `                `  `                ``else``:` `                  `  `                    ``# Update res` `                    ``res ``+``=` `(odd_cont_seg ``/``/` `2``) ``+` `2` `                `  `                ``# Reset odd_cont_seg = 0` `                ``odd_cont_seg ``=` `0` `    `  `    ``# If odd_cont_seg exceeds 0` `    ``if` `(odd_cont_seg > ``0``):` `        `  `        ``# If odd_cont_seg is even` `        ``if` `(odd_cont_seg ``%` `2` `=``=` `0``):` `            `  `            ``# Update res` `            ``res ``+``=` `odd_cont_seg ``/``/` `2` `        `  `        ``else``:` `            `  `            ``# Update res` `            ``res ``+``=` `odd_cont_seg ``/``/` `2` `+` `2` `            `  `    ``# Print the result` `    ``return` `res`   `# Drivers Code` `arr ``=`  `[``2``, ``4``, ``5``, ``11``, ``6``]` `N ``=` `len``(arr)` `print``(make_array_element_even(arr, N))`   `# This code is contributed by shubhamsingh10`

C#

 `// C# program to implement` `// the above approach` `using` `System;` `public` `class` `GFG` `{`   `  ``// Function to find minimum count of operations` `  ``// required to make all array elements even` `  ``static` `int` `make_array_element_even(``int` `[]arr, ``int` `N)` `  ``{`   `    ``// Stores minimum count of replacements` `    ``// to make all array elements even` `    ``int` `res = 0;`   `    ``// Stores the count of odd` `    ``// continuous numbers` `    ``int` `odd_cont_seg = 0;`   `    ``// Traverse the array` `    ``for` `(``int` `i = 0; i < N; i++)` `    ``{`   `      ``// If arr[i] is an odd number` `      ``if` `(arr[i] % 2 == 1)` `      ``{`   `        ``// Update odd_cont_seg` `        ``odd_cont_seg++;` `      ``}` `      ``else` `      ``{` `        ``if` `(odd_cont_seg > 0)` `        ``{`   `          ``// If odd_cont_seg is even` `          ``if` `(odd_cont_seg % 2 == 0) ` `          ``{`   `            ``// Update res` `            ``res += odd_cont_seg / 2;` `          ``}`   `          ``else` `          ``{`   `            ``// Update res` `            ``res += (odd_cont_seg / 2) + 2;` `          ``}`   `          ``// Reset odd_cont_seg = 0` `          ``odd_cont_seg = 0;` `        ``}` `      ``}` `    ``}`   `    ``// If odd_cont_seg exceeds 0` `    ``if` `(odd_cont_seg > 0) ` `    ``{`   `      ``// If odd_cont_seg is even` `      ``if` `(odd_cont_seg % 2 == 0) ` `      ``{`   `        ``// Update res` `        ``res += odd_cont_seg / 2;` `      ``}`   `      ``else` `      ``{`   `        ``// Update res` `        ``res += odd_cont_seg / 2 + 2;` `      ``}` `    ``}`   `    ``// Print the result` `    ``return` `res;` `  ``}`   `  ``// Drivers Code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `[]arr = { 2, 4, 5, 11, 6 };` `    ``int` `N = arr.Length;` `    ``Console.Write(make_array_element_even(arr, N));` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

Javascript

 ``

Output:

`1`

Time complexity: O(N)
Auxiliary space: O(1)

My Personal Notes arrow_drop_up
Related Articles