Find number of subarrays with even sum

Given an array, find the number of subarrays whose sum is even.

Example :

Input : arr[] = {1, 2, 2, 3, 4, 1} 
Output : 9

There are possible subarrays with even
sum. The subarrays are 
1) {1, 2, 2, 3}  Sum = 8
2) {1, 2, 2, 3, 4}  Sum = 12
3) {2}  Sum = 2 (At index 1)
4) {2, 2}  Sum = 4
5) {2, 2, 3, 4, 1}  Sum = 12
6) {2}  Sum = 2 (At index 2)
7) {2, 3, 4, 1} Sum = 10
8) {3, 4, 1}  Sum = 8
9) {4}  Sum = 4 

O(n2) time and O(1) space method [Brute Force]
We can simply generate all the possible sub-arrays and find whether the sum of all the elements in them is an even or not. If it is even then we will count that sub-array otherwise neglect it.



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* C++ program to count number of sub-arrays
  whose sum is even using brute force
 Time Complexity - O(N^2)
 Space Complexity - O(1) */
#include<iostream>
using namespace std;
  
int countEvenSum(int arr[], int n)
{
    int result = 0;
  
    // Find sum of all subarrays and increment
    // result if sum is even
    for (int i=0; i<=n-1; i++)
    {
        int sum = 0;
        for (int j=i; j<=n-1; j++)
        {
            sum = sum + arr[j];
            if (sum % 2 == 0)
                    result++;
        }
    }
  
    return (result);
}
  
// Driver code
int main()
{
    int arr[] = {1, 2, 2, 3, 4, 1};
    int n = sizeof (arr) / sizeof (arr[0]);
  
    cout << "The Number of Subarrays with even"
            " sum is " << countEvenSum (arr, n);
  
    return (0);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count number 
// of sub-arrays whose sum is 
// even using brute force 
// Time Complexity - O(N^2)
// Space Complexity - O(1) 
import java.io.*;
  
class GFG
{
static int countEvenSum(int arr[], 
                        int n)
{
    int result = 0;
  
    // Find sum of all subarrays 
    // and increment result if
    // sum is even
    for (int i = 0; i <= n - 1; i++)
    {
        int sum = 0;
        for (int j = i; j <= n - 1; j++)
        {
            sum = sum + arr[j];
            if (sum % 2 == 0)
                    result++;
        }
    }
  
    return (result);
}
  
// Driver code
public static void main (String[] args) 
{
int arr[] = {1, 2, 2
             3, 4, 1};
int n = arr.length;
  
System.out.print("The Number of Subarrays"
                     " with even sum is ");
                       
System.out.println(countEvenSum(arr, n));
}
}
  
// This code is contributed by ajit

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to count number 
# of sub-arrays whose sum is even
# using brute force
# Time Complexity - O(N^2)
# Space Complexity - O(1) 
  
def countEvenSum(arr, n):
    result = 0
  
    # Find sum of all subarrays and
    # increment result if sum is even
    for i in range(0, n, 1):
        sum = 0
        for j in range(i, n, 1):
            sum = sum + arr[j]
            if (sum % 2 == 0):
                    result = result + 1
  
    return (result)
  
# Driver code
if __name__ == '__main__':
    arr = [1, 2, 2, 3, 4, 1]
    n = len(arr)
    print("The Number of Subarrays"
                  "with even sum is"
               countEvenSum (arr, n))
  
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count number 
// of sub-arrays whose sum is 
// even using brute force 
// Time Complexity - O(N^2)
// Space Complexity - O(1)
using System;
  
class GFG
{
static int countEvenSum(int []arr, 
                        int n)
{
    int result = 0;
  
    // Find sum of all subarrays 
    // and increment result if
    // sum is even
    for (int i = 0; i <= n - 1; i++)
    {
        int sum = 0;
        for (int j = i; j <= n - 1; j++)
        {
            sum = sum + arr[j];
            if (sum % 2 == 0)
                    result++;
        }
    }
  
    return (result);
}
  
// Driver code
static public void Main ()
{
    int []arr = {1, 2, 2, 
                 3, 4, 1};
    int n = arr.Length;
  
    Console.Write("The Number of Subarrays"
                      " with even sum is ");
                      
    Console.WriteLine(countEvenSum(arr, n));
    }
}
  
// This code is contributed by m_kit

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to count number
// of sub-arrays whose sum is
// even using brute force 
// Time Complexity - O(N^2) 
// Space Complexity - O(1) 
function countEvenSum($arr, $n)
{
    $result = 0;
  
    // Find sum of all subarrays
    // and increment result if 
    // sum is even
    for ($i = 0; $i <= $n - 1; $i++)
    {
        $sum = 0;
        for ($j = $i; $j <= $n - 1; $j++)
        {
            $sum = $sum + $arr[$j];
            if ($sum % 2 == 0)
                    $result++;
        }
    }
  
    return ($result);
}
  
// Driver code
$arr = array(1, 2, 2, 3, 4, 1);
$n = sizeof ($arr);
  
echo "The Number of Subarrays "
           "with even sum is "
        countEvenSum ($arr, $n);
  
// This code is contributed by ajit
?>

chevron_right



Output :

The Number of Subarrays with even sum is 9

 
O(n) Time and O(1) Space Method [Efficient]
If we do compute the cumulative sum array in temp[] of our input array, then we can see that the sub-array starting from i and ending at j, has an even sum if temp[] if (temp[j] – temp[i]) % 2 = 0. So, instead of building a cumulative sum array we build a cumulative sum modulo 2 array, and find how many times 0 and 1 appears in temp[] array using handshake formula. [n * (n-1) /2]

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

/* C++ program to count number of sub-arrays
with even sum using an efficient algorithm
Time Complexity - O(N)
Space Complexity - O(1)*/
#include<iostream>
using namespace std;
  
int countEvenSum(int arr[], int n)
{
    // A temporary array of size 2. temp[0] is
    // going to store count of even subarrays
    // and temp[1] count of odd.
    // temp[0] is initialized as 1 because there
    // a single even element is also counted as
    // a subarray
    int temp[2] = {1, 0};
  
    // Initialize count.  sum is sum of elements
    // under modulo 2 and ending with arr[i].
    int result = 0, sum = 0;
  
    // i'th iteration computes sum of arr[0..i]
    // under modulo 2 and increments even/odd count
    // according to sum's value
    for (int i=0; i<=n-1; i++)
    {
        // 2 is added to handle negative numbers
        sum = ( (sum + arr[i]) % 2 + 2) % 2;
  
        // Increment even/odd count
        temp[sum]++;
    }
  
    // Use handshake lemma to count even subarrays
    // (Note that an even cam be formed by two even
    // or two odd)
    result = result + (temp[0]*(temp[0]-1)/2);
    result = result + (temp[1]*(temp[1]-1)/2);
  
    return (result);
}
  
// Driver code
int main()
{
    int arr[] = {1, 2, 2, 3, 4, 1};
    int n = sizeof (arr) / sizeof (arr[0]);
  
    cout << "The Number of Subarrays with even"
            " sum is " << countEvenSum (arr, n);
  
    return (0);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count 
// number of sub-arrays
// with even sum using an 
// efficient algorithm
// Time Complexity - O(N)
// Space Complexity - O(1)
import java.io.*;
  
class GFG 
{
static int countEvenSum(int arr[],  
                        int n)
{
    // A temporary array of size 2. 
    // temp[0] is going to store 
    // count of even subarrays
    // and temp[1] count of odd.
    // temp[0] is initialized as 
    // 1 because there a single even 
    // element is also counted as
    // a subarray
    int temp[] = {1, 0};
  
    // Initialize count. sum is 
    // sum of elements under modulo
    // 2 and ending with arr[i].
    int result = 0, sum = 0;
  
    // i'th iteration computes sum
    // of arr[0..i] under modulo 2 
    // and increments even/odd count
    // according to sum's value
    for (int i = 0; i <= n - 1; i++)
    {
        // 2 is added to handle
        // negative numbers
        sum = ((sum + arr[i]) % 
                    2 + 2) % 2;
  
        // Increment even/odd count
        temp[sum]++;
    }
  
    // Use handshake lemma to
    // count even subarrays
    // (Note that an even cam 
    // be formed by two even
    // or two odd)
    result = result + (temp[0] * 
                      (temp[0] - 1) / 2);
    result = result + (temp[1] * 
                      (temp[1] - 1) / 2);
  
    return (result);
}
  
// Driver code
public static void main (String[] args) 
{
  
int arr[] = {1, 2, 2, 3, 4, 1};
int n = arr.length;
  
System.out.println("The Number of Subarrays"
                       " with even sum is " +
                      countEvenSum (arr, n));
}
}
  
// This code is contributed by ajit

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to count number of sub-arrays
# with even sum using an efficient algorithm
# Time Complexity - O(N)
# Space Complexity - O(1)
def countEvenSum(arr, n):
  
    # A temporary array of size 2. temp[0] is
    # going to store count of even subarrays
    # and temp[1] count of odd.
    # temp[0] is initialized as 1 because there
    # a single even element is also counted as
    # a subarray
    temp = [1, 0]
  
    # Initialize count. sum is sum of elements
    # under modulo 2 and ending with arr[i].
    result = 0
    sum = 0
  
    # i'th iteration computes sum of arr[0..i]
    # under modulo 2 and increments even/odd 
    # count according to sum's value
    for i in range( n):
          
        # 2 is added to handle negative numbers
        sum = ( (sum + arr[i]) % 2 + 2) % 2
  
        # Increment even/odd count
        temp[sum]+= 1
  
    # Use handshake lemma to count even subarrays
    # (Note that an even cam be formed by two even
    # or two odd)
    result = result + (temp[0] * (temp[0] - 1) // 2)
    result = result + (temp[1] * (temp[1] - 1) // 2)
  
    return (result)
  
# Driver code
if __name__ == "__main__":
      
    arr = [1, 2, 2, 3, 4, 1]
    n = len(arr)
    print( "The Number of Subarrays with even"
            " sum is" , countEvenSum (arr, n))
  
# This code is contributed by ita_c

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count 
// number of sub-arrays
// with even sum using an 
// efficient algorithm
// Time Complexity - O(N)
// Space Complexity - O(1)
using System;
  
class GFG
{
static int countEvenSum(int []arr, 
                        int n)
{
    // A temporary array of size 2. 
    // temp[0] is going to store 
    // count of even subarrays
    // and temp[1] count of odd.
    // temp[0] is initialized as 
    // 1 because there a single even 
    // element is also counted as
    // a subarray
    int []temp = {1, 0};
  
    // Initialize count. sum is 
    // sum of elements under modulo
    // 2 and ending with arr[i].
    int result = 0, sum = 0;
  
    // i'th iteration computes sum
    // of arr[0..i] under modulo 2 
    // and increments even/odd count
    // according to sum's value
    for (int i = 0; i <= n - 1; i++)
    {
        // 2 is added to handle
        // negative numbers
        sum = ((sum + arr[i]) % 
                    2 + 2) % 2;
  
        // Increment even
        // or odd count
        temp[sum]++;
    }
  
    // Use handshake lemma to
    // count even subarrays
    // (Note that an even cam 
    // be formed by two even
    // or two odd)
    result = result + (temp[0] * 
                      (temp[0] - 1) / 2);
    result = result + (temp[1] * 
                      (temp[1] - 1) / 2);
  
    return (result);
}
  
// Driver code
static public void Main ()
{
    int []arr = {1, 2, 2, 3, 4, 1};
    int n = arr.Length;
  
    Console.WriteLine("The Number of Subarrays"
                          " with even sum is " +
                         countEvenSum (arr, n));
}
}
  
// This code is contributed 
// by akt_mit

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to count number 
// of sub-arrays with even sum 
// using an efficient algorithm
// Time Complexity - O(N)
// Space Complexity - O(1)*/
function countEvenSum($arr, $n)
{
    // A temporary array of size 2. 
    // temp[0] is going to store 
    // count of even subarrays and 
    // temp[1] count of odd. temp[0]
    // is initialized as 1 because 
    // there a single even element 
    // is also counted as a subarray
    $temp = array(1, 0);
  
    // Initialize count. sum is 
    // sum of elements under 
    // modulo 2 and ending with arr[i].
    $result = 0; $sum = 0;
  
    // i'th iteration computes 
    // sum of arr[0..i] under 
    // modulo 2 and increments
    // even/odd count according
    // to sum's value
    for ($i = 0; $i <= $n - 1; $i++)
    {
        // 2 is added to handle 
        // negative numbers
        $sum = (($sum + $arr[$i]) % 
                        2 + 2) % 2;
  
        // Increment even/odd 
        // count
        $temp[$sum]++;
    }
  
    // Use handshake lemma to 
    // count even subarrays 
    // (Note that an even can 
    // be formed by two even 
    // or two odd)
    $result = $result + (int)($temp[0] * 
                             ($temp[0] - 1) / 2);
    $result = $result + (int)($temp[1] * 
                             ($temp[1] - 1) / 2);
  
    return ($result);
}
  
// Driver code
$arr = array (1, 2, 2, 
              3, 4, 1);
$n = sizeof ($arr);
  
echo "The Number of Subarrays " .
        "with even", " sum is "
         countEvenSum ($arr, $n);
  
// This code is contributed by ajit
?>

chevron_right



Output :

The Number of Subarrays with even sum is 9

This article is contributed by Rachit Belwariar. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above



My Personal Notes arrow_drop_up