Skip to content
Related Articles

Related Articles

Number of sub arrays with odd sum

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 30 Aug, 2022
Improve Article
Save Article

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.

Implementation:

C++




// 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 arr[] = { 5, 4, 4, 5, 1, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "The Number of Subarrays with odd sum is "
         << countOddSum(arr, n);
    return (0);
}
 
// This code is contributed by Sania Kumari Gupta


C




// C++ code to find count of sub-arrays with odd sum
#include <stdio.h>
 
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 arr[] = { 5, 4, 4, 5, 1, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("The Number of Subarrays with odd sum is %d",
           countOddSum(arr, n));
    return (0);
}
 
// This code is contributed by Sania Kumari Gupta


Java




// 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));
    }
}
 
// This code is contributed by Sania Kumari Gupta


Python3




# 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


C#




// 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.


PHP




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


Javascript




<script>
 
// Javascript code to find count of
// sub-arrays with odd sum
function countOddSum(ar, n)
{
    let result = 0;
 
    // Find sum of all subarrays
    // and increment result if
    // sum is odd
    for(let i = 0; i <= n - 1; i++)
    {
        let val = 0;
        for(let j = i; j <= n - 1; j++)
        {
            val = val + ar[j];
             
            if (val % 2 != 0)
                result++;
        }
    }
    return (result);
}
 
// Driver code
let ar = [ 5, 4, 4, 5, 1, 3 ];
let n = ar.length;
document.write("The Number of Subarrays" +
               " with odd sum is ");
 
document.write(countOddSum(ar, n));
 
// This code is contributed by avanitrachhadiya2155
 
</script>


Output

The Number of Subarrays with odd sum is 12

Complexity Analysis:

  • Time Complexity: O(n2)
  • Auxiliary Space: O(1)

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




// C++ program 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);
}
 
// This code is contributed by Sania Kumari Gupta


C




// C++ program to find count of sub-arrays
// with odd sum
#include <stdio.h>
 
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]);
    printf("The Number of Subarrays with odd sum is %d",
           countOddSum(ar, n));
    return (0);
}
 
// This code is contributed by Sania Kumari Gupta


Java




// 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));
    }
}
 
// This code is contributed by Sania Kumari Gupta


Python3




# Python 3 program 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


C#




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


PHP




<?php
// PHP program 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
?>


Javascript




<script>
 
// Javascript code 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 a single odd
    // element is also counted as
    // a subarray
    let temp = [1, 0];
 
    // Initialize count. sum is
    // sum of elements under modulo
    // 2 and ending with arr[i].
    let 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(let 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
let ar = [ 5, 4, 4, 5, 1, 3 ];
let n = ar.length;
 
document.write("The Number of Subarrays" +
               " with odd sum is " +
               countOddSum(ar, n));
                      
// This code is contributed by rameshtravel07  
 
</script>


Output

The Number of Subarrays with odd sum is 12

Complexity Analysis:

  • Time Complexity: O(n)
  • Auxiliary Space: O(1)

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.

Implementation:

C++




// C++ 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);
}
 
// This code is contributed by Sania Kumari Gupta


C




// C++ program to find number of subarrays with odd sum
#include <stdio.h>
 
// 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]);
    printf("The Number of Subarrays with odd sum is %d",
           countOddSum(ar, n));
    return (0);
}
 
// This code is contributed by Sania Kumari Gupta


Java




// Java program to find number of subarrays
// with odd sum
import java.util.*;
 
class GFG {
 
    // Function to find number of subarrays with odd sum
    static 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 c_odd = 0, result = 0;
        boolean odd = false;
 
        // First find number of odd sum subarrays starting
        // at 0th index
        for (int i = 0; i < n; i++) {
            if (a[i] % 2 == 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] % 2 == 1)
                c_odd = (n - i - c_odd);
        }
        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 "
            + countOddSum(ar, n));
    }
}
 
// This code is contributed by Sania Kumari Gupta


Python3




# Python3 program to find
# number of subarrays with
# odd sum
 
# Function to find number
# of subarrays with odd sum
 
def countOddSum(a, 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
    c_odd = 0;
    result = 0;
    odd = False;
 
    # First find number of odd
    # sum subarrays starting at
    # 0th index
    for i in range(n):
        if (a[i] % 2 == 1):
            if(odd == True):
                odd = False;
            else:
                odd = True;
 
        if (odd):
            c_odd += 1;
 
    # Find number of odd sum
    # subarrays starting at ith
    # index add to result
    for i in range(n):
        result += c_odd;
        if (a[i] % 2 == 1):
            c_odd = (n - i - c_odd);
 
    return result;
 
# Driver code
if __name__ == '__main__':
   
    ar = [5, 4, 4, 5, 1, 3];
    n = len(ar);
    print("The Number of Subarrays" +
          "with odd sum is " ,
          countOddSum(ar, n));
 
# This code is contributed by shikhasingrajput


C#




// C# program to find number of subarrays
// with odd sum
using System;
 
public class GFG{
 
// Function to find number of
// subarrays with odd sum
static 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  c_odd = 0, result = 0;
    bool odd = false;
     
    // First find number of odd sum
    // subarrays starting at 0th index
    for(int i = 0; i < n; i++)
    {
        if (a[i] % 2 == 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] % 2 == 1)
        {
            c_odd = (n - i - c_odd);
        }
    }
    return result;
}
 
// Driver code
public static void Main(String[] args)
{
    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 29AjayKumar


Javascript




<script>
 
  // JavaScript program to find number
  // of subarrays with odd sum
   
  // Function to find number of
  // subarrays with odd sum
  function countOddSum(a, 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
      let  c_odd = 0, result = 0;
      let odd = false;
        
      // First find number of odd sum
      // subarrays starting at 0th index
      for(let i = 0; i < n; i++)
      {
          if (a[i] % 2 == 1)
          {
              odd = !odd;
          }
          if (odd)
          {
              c_odd++;
          }
      }
    
      // Find number of odd sum subarrays
      // starting at ith index add to result
      for(let i = 0; i < n; i++)
      {
          result += c_odd;
          if (a[i] % 2 == 1)
          {
              c_odd = (n - i - c_odd);
          }
      }
      return result;
  }
   
  let ar = [ 5, 4, 4, 5, 1, 3 ];
  let n = ar.length;
 
  document.write("The Number of Subarrays " +
                   "with odd sum is " +
                   countOddSum(ar, n));
     
</script>


Output

The Number of Subarrays with odd sum is 12

Complexity Analysis:

  • Time Complexity: O(n)
  • Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!