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

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 <iostream>
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

<script>

// Javascript program to implement
// the above approach

// Function to find minimum count of operations
// required to make all array elements even
function make_array_element_even(arr, N)
{

    // Stores minimum count of replacements
    // to make all array elements even
    let res = 0;

    // Stores the count of odd
    // continuous numbers
    let odd_cont_seg = 0;

    // Traverse the array
    for(let 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;
}

// Driver Code

// Given array arr[]
let arr = [ 2, 4, 5, 11, 6 ];
let N = arr.length;

document.write(make_array_element_even(arr, N));

// This code is contributed by splevel62

</script>

Output:

1

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