Related Articles
Number of sub arrays with odd sum
• Difficulty Level : Hard
• Last Updated : 03 Nov, 2020

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

 `// C++ code to find count of sub-arrays``// with odd sum``#include ``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);``}`

## 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));``    ``}``}`

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

 ``

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

 `// C++ proggram to find count of sub-arrays``// with odd sum``#include ``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);``}`

## 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));``    ``}``}`

## Python3

 `# 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`

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

 ``

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 :

## C++

 `// C++ program to find number of subarrays with odd sum``#include ``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

## 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 Amit Katiyar`

## 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`

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