Number of sub arrays with odd sum

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

Examples:

Input : arr[] = {5, 4, 4, 5, 1, 3} 
Output : 12

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

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 odd or not. If it is odd then we will count that sub-array otherwise neglect it.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ code to find count of sub-arrays
// with odd sum
#include <bits/stdc++.h>
using namespace std;
  
int countOddSum(int ar[], int n)
{
    int result = 0;
  
    // Find sum of all subarrays and increment
    // result if sum is odd
    for (int i = 0; i <= n - 1; i++) {
        int val = 0;
        for (int j = i; j <= n - 1; j++) {
            val = val + ar[j];
            if (val % 2 != 0)
                result++;
        }
    }
  
    return (result);
}
  
// Driver code
int main()
{
    int ar[] = { 5, 4, 4, 5, 1, 3 };
    int n = sizeof(ar) / sizeof(ar[0]);
  
    cout << "The Number of Subarrays with odd"
            " sum is "
         << countOddSum(ar, n);
  
    return (0);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code to find count of sub-arrays
// with odd sum
import java.io.*;
  
class GFG {
    static int countOddSum(int ar[],
                           int n)
    {
        int result = 0;
  
        // Find sum of all subarrays
        // and increment result if
        // sum is odd
        for (int i = 0; i <= n - 1; i++) {
            int val = 0;
            for (int j = i; j <= n - 1; j++) {
                val = val + ar[j];
                if (val % 2 != 0)
                    result++;
            }
        }
  
        return (result);
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int ar[] = { 5, 4, 4, 5, 1, 3 };
        int n = ar.length;
  
        System.out.print("The Number of Subarrays"
                         + " with odd sum is ");
  
        System.out.println(countOddSum(ar, n));
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 code to find count 
# of sub-arrays with odd sum
  
def countOddSum(ar, n):
    result = 0
  
    # Find sum of all subarrays and 
    # increment result if sum is odd
    for i in range(n):
        val = 0
        for j in range(i, n ): 
            val = val + ar[j]
            if (val % 2 != 0):
                result +=1
  
    return (result)
  
# Driver code
ar = [ 5, 4, 4, 5, 1, 3 ]
  
print("The Number of Subarrays"
            "with odd", end = "")
  
print(" sum is "+ str(countOddSum(ar, 6)))
  
# This code is contributed
# by ChitraNayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code to find count 
// of sub-arrays with odd sum
using System;
  
class GFG 
{
static int countOddSum(int []ar,
                       int n)
{
    int result = 0;
  
    // Find sum of all subarrays
    // and increment result if
    // sum is odd
    for (int i = 0;
             i <= n - 1; i++) 
    {
        int val = 0;
        for (int j = i; 
                 j <= n - 1; j++) 
        {
            val = val + ar[j];
            if (val % 2 != 0)
                result++;
        }
    }
  
    return (result);
}
  
// Driver code
public static void Main()
{
    int []ar = {5, 4, 4, 5, 1, 3};
    int n = ar.Length;
  
    Console.Write("The Number of Subarrays"
                        " with odd sum is ");
  
    Console.WriteLine(countOddSum(ar, n));
}
}
  
// This code is contributed
// by chandan_jnu.

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP code to find count 
// of sub-arrays with odd sum
  
function countOddSum(&$ar, $n)
{
    $result = 0;
  
    // Find sum of all subarrays and 
    // increment result if sum is odd
    for ($i = 0; $i <= $n - 1; $i++)
    {
        $val = 0;
        for ($j = $i
             $j <= $n - 1; $j++)
        {
            $val = $val + $ar[$j];
            if ($val % 2 != 0)
                $result++;
        }
    }
  
    return ($result);
}
  
// Driver code
$ar = array(5, 4, 4, 5, 1, 3);
$n = sizeof($ar);
  
echo "The Number of Subarrays with odd ";
echo "sum is ".countOddSum($ar, $n);
  
// This code is contributed
// by ChitraNayal
?>

chevron_right



Output :

The Number of Subarrays with odd sum is 12

 
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. Then calculating odd-even pairs will give the required result i.e. temp[0]*temp[1].



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ proggram to find count of sub-arrays
// with odd sum
#include <bits/stdc++.h>
using namespace std;
  
int countOddSum(int ar[], 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 odd 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, val = 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
        val = ((val + ar[i]) % 2 + 2) % 2;
  
        // Increment even/odd count
        temp[val]++;
    }
  
    // An odd can be formed by even-odd pair
    result = (temp[0] * temp[1]);
  
    return (result);
}
  
// Driver code
int main()
{
    int ar[] = { 5, 4, 4, 5, 1, 3 };
    int n = sizeof(ar) / sizeof(ar[0]);
  
    cout << "The Number of Subarrays with odd"
            " sum is "
         << countOddSum(ar, n);
  
    return (0);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code to find count of sub-arrays
// with odd sum
import java.io.*;
  
class GFG {
    static int countOddSum(int ar[],
                           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 odd
        // 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, val = 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
            val = ((val + ar[i]) % 2 + 2) % 2;
  
            // Increment even/odd count
            temp[val]++;
        }
  
        // An odd can be formed by an even-odd pair
        result = temp[0] * temp[1];
  
        return (result);
    }
  
    // Driver code
    public static void main(String[] args)
    {
  
        int ar[] = { 5, 4, 4, 5, 1, 3 };
        int n = ar.length;
  
        System.out.println("The Number of Subarrays"
                           + " with odd sum is " + countOddSum(ar, n));
    }
}

chevron_right


Python 3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 proggram to  
# find count of sub-arrays
# with odd sum
def countOddSum(ar, 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 is a single odd 
    # 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
    val = 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
        val = ((val + ar[i]) % 2 + 2) % 2
  
        # Increment even/odd count
        temp[val] += 1
  
    # An odd can be formed 
    # by even-odd pair
    result = (temp[0] * temp[1])
  
    return (result)
  
# Driver code
ar = [ 5, 4, 4, 5, 1, 3 ]
  
print("The Number of Subarrays"
           " with odd sum is "+
       str(countOddSum(ar, 6)))
         
# This code is contributed 
# by ChitraNayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code to find count of 
// sub-arrays with odd sum
using System;
  
class GFG 
{
static int countOddSum(int[] ar,
                       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 odd
    // 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, val = 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
        val = ((val + ar[i]) % 2 + 2) % 2;
  
        // Increment even/odd count
        temp[val]++;
    }
  
    // An odd can be formed 
    // by an even-odd pair
    result = temp[0] * temp[1];
  
    return (result);
}
  
// Driver code
public static void Main()
{
  
    int[] ar = { 5, 4, 4, 5, 1, 3 };
    int n = ar.Length;
  
    Console.Write("The Number of Subarrays"
                        " with odd sum is "
                         countOddSum(ar, n));
}
}
  
// This code is contributed
// by ChitraNayal

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP proggram to find count 
// of sub-arrays with odd sum
  
function countOddSum($ar, $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 is a single odd 
    // 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;
    $val = 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
        $val = (($val + $ar[$i]) % 
                       2 + 2) % 2;
  
        // Increment even/odd count
        $temp[$val]++;
    }
  
    // An odd can be formed
    // by even-odd pair
    $result = ($temp[0] * $temp[1]);
  
    return ($result);
}
  
// Driver code
$ar = array(5, 4, 4, 5, 1, 3);
$n = sizeof($ar);
  
echo "The Number of Subarrays with odd".
        " sum is ".countOddSum($ar, $n);
  
// This code is contributed 
// by ChitraNayal
?>

chevron_right



Output :

The Number of Subarrays with odd sum is 12

Another efficient approach is to first find the number of subarrays starting at index 0 and having an odd sum. Then traverse the array and update the number of subarrays starting at index i and having an odd sum.

Below is the implementation of the above approach :

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to find number of subarrays with odd sum
#include <bits/stdc++.h>
using namespace std;
  
// Function to find number of subarrays with odd sum
int countOddSum(int a[], int n) 
{
    // 'odd' stores number of odd numbers upto ith index
    // 'c_odd' stores number of odd sum subarrays starting at ith index
    // 'Result' stores the number of odd sum subarrays
    int odd = 0, c_odd=0, result = 0;
      
    // First find number of odd sum subarrays starting at 0th index 
    for(int i=0;i <n;i++) {
        if(a[i]&1) {
            odd = !odd;
        }
        if(odd) {
            c_odd++;
        }
    }
  
    // Find number of odd sum subarrays starting at ith index
    // add to result 
    for(int i=0; i<n; i++) {
        result += c_odd;
        if(a[i]&1) {
            c_odd = (n-i-c_odd);
        }
    }
      
    return result;
}
  
// Driver code
int main() 
    int ar[] = { 5, 4, 4, 5, 1, 3 }; 
    int n = sizeof(ar) / sizeof(ar[0]); 
  
    cout << "The Number of Subarrays with odd sum is "
        << countOddSum(ar, n); 
  
    return (0); 
}

chevron_right


Output :

The Number of Subarrays with odd sum is 12

Time Complexity: O(N)
Space Complexity: 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.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.