# Count of even sum triplets in the array for Q range queries

• Last Updated : 21 Sep, 2021

Given an array arr[] of size N and Q queries of the form (L, R), the task is to count number of triplets with even sum for the elements in the range L and R for each query.

Examples:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 6, arr[ ] = {1, 2, 3, 4, 5, 6}, Q[ ] = {{1, 3}, {2, 5}}
Output: 1 2
Explanation:
For Query (1, 3): only triplet (1, 2, 3) exists with even sum
For Query (2, 5): Triplets (2, 3, 5) and (3, 4, 5) have even sum.
Hence the output is 1 and 2 respectively

Input: N = 3, arr[ ] = {1, 2, 5}, Q[ ] = {{1, 2}}
Output: 0

Approach: The above problem can be solved with the observations that for a triplet sum to be even, the elements must be one of the below pattern:

• even + even + even = even
• odd + odd + even = even

Follow the steps below to solve the problem:

• Initialize two arrays, say arr_even[] and arr_odd[] of length size + 1.
• Initialize variables, say even = 0 and odd = 0, to store the count of even and odd numbers.
• Traverse the array arr[] and for each i store even numbers till index i in arr_even[i] and odd numbers till index i in arr_odd[i].
• Iterate over the queries Q[] and for each pair (l, r):
• Find count of even numbers in (l, r) as arr_even[r] – arr_even[l-1] and count of odd numbers in (l, r) as arr_odd[r] – arr_odd[l-1].
• Find count of triplets in variable say ans as sum of (even*(even-1)*(even-2))/6 and (odd*(odd-1)/2)*even.
• Finally, print the ans for each query.

Below is the implementation of the above approach:

## C++

 `// C++ program for above approach``#include ``using` `namespace` `std;` `// Function to count number of triplets``// with even sum in range l, r for each``// query``void` `countTriplets(``int` `size, ``int` `queries,``                   ``int` `arr[], ``int` `Q[])``{` `    ``// Initialization of array``    ``int` `arr_even[size + 1], arr_odd[size + 1];` `    ``// Initialization of variables``    ``int` `even = 0, odd = 0;``    ``arr_even = 0;``    ``arr_odd = 0;` `    ``// Traversing array``    ``for` `(``int` `i = 0; i < size; i++) {` `        ``// If element is odd``        ``if` `(arr[i] % 2) {``            ``odd++;``        ``}` `        ``// If element is even``        ``else` `{``            ``even++;``        ``}` `        ``// Storing count of even and odd``        ``// till each i``        ``arr_even[i + 1] = even;``        ``arr_odd[i + 1] = odd;``    ``}` `    ``// Traversing each query``    ``for` `(``int` `i = 0; i < queries; i++) {``        ``int` `l = Q[i], r = Q[i];` `        ``// Count of odd numbers in l to r``        ``int` `odd = arr_odd[r] - arr_odd[l - 1];` `        ``// Count of even numbers in l to r``        ``int` `even = arr_even[r] - arr_even[l - 1];` `        ``// Finding the ans``        ``int` `ans = (even * (even - 1)``                   ``* (even - 2))``                      ``/ 6``                  ``+ (odd * (odd - 1) / 2)``                        ``* even;` `        ``// Printing the ans``        ``cout << ans << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given Input``    ``int` `N = 6, Q = 2;``    ``int` `arr[] = { 1, 2, 3, 4, 5, 6 };``    ``int` `queries[] = { { 1, 3 }, { 2, 5 } };` `    ``// Function Call``    ``countTriplets(N, Q, arr, queries);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG {``    ``// Function to count number of triplets``    ``// with even sum in range l, r for each``    ``// query``    ``static` `void` `countTriplets(``int` `size, ``int` `queries,``                              ``int``[] arr, ``int``[][] Q)``    ``{` `        ``// Initialization of array``        ``int``[] arr_even = ``new` `int``[size + ``1``];``        ``int` `[]arr_odd = ``new` `int``[size + ``1``];` `        ``// Initialization of variables``        ``int` `even = ``0``;``      ``int` `odd = ``0``;``        ``arr_even[``0``] = ``0``;``        ``arr_odd[``0``] = ``0``;` `        ``// Traversing array``        ``for` `(``int` `i = ``0``; i < size; i++) {` `            ``// If element is odd``            ``if` `(arr[i] % ``2` `== ``1``) {``                ``odd++;``            ``}` `            ``// If element is even``            ``else` `{``                ``even++;``            ``}` `            ``// Storing count of even and odd``            ``// till each i``            ``arr_even[i + ``1``] = even;``            ``arr_odd[i + ``1``] = odd;``        ``}` `        ``// Traversing each query``        ``for` `(``int` `i = ``0``; i < queries; i++) {``            ``int` `l = Q[i][``0``], r = Q[i][``1``];` `            ``// Count of odd numbers in l to r``             ``odd = arr_odd[r] - arr_odd[l - ``1``];` `            ``// Count of even numbers in l to r``             ``even = arr_even[r] - arr_even[l - ``1``];` `            ``// Finding the ans``            ``int` `ans = (even * (even - ``1``) * (even - ``2``)) / ``6``                      ``+ (odd * (odd - ``1``) / ``2``) * even;` `            ``// Printing the ans``            ``System.out.print(ans + ``" "``);``        ``}``    ``}` `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given Input``        ``int` `N = ``6``, Q = ``2``;``        ``int``[] arr = { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `};``        ``int``[][] queries = { { ``1``, ``3` `}, { ``2``, ``5` `} };``        ``countTriplets(N, Q, arr, queries);``    ``}``}` `// This code is contributed by maddler.`

## Python3

 `# Python 3 program for above approach` `# Function to count number of triplets``# with even sum in range l, r for each``# query``def` `countTriplets(size, queries, arr, Q):``  ` `    ``# Initialization of array``    ``arr_even ``=` `[``0` `for` `i ``in` `range``(size ``+` `1``)]``    ``arr_odd ``=` `[``0` `for` `i ``in` `range``(size ``+` `1``)]` `    ``# Initialization of variables``    ``even ``=` `0``    ``odd ``=` `0``    ``arr_even[``0``] ``=` `0``    ``arr_odd[``0``] ``=` `0` `    ``# Traversing array``    ``for` `i ``in` `range``(size):``      ` `        ``# If element is odd``        ``if` `(arr[i] ``%` `2``):``            ``odd ``+``=` `1` `        ``# If element is even``        ``else``:``            ``even ``+``=` `1` `        ``# Storing count of even and odd``        ``# till each i``        ``arr_even[i ``+` `1``] ``=` `even``        ``arr_odd[i ``+` `1``] ``=` `odd` `    ``# Traversing each query``    ``for` `i ``in` `range``(queries):``        ``l ``=` `Q[i][``0``]``        ``r ``=` `Q[i][``1``]` `        ``# Count of odd numbers in l to r``        ``odd ``=` `arr_odd[r] ``-` `arr_odd[l ``-` `1``]` `        ``# Count of even numbers in l to r``        ``even ``=` `arr_even[r] ``-` `arr_even[l ``-` `1``]` `        ``# Finding the ans``        ``ans ``=` `(even ``*` `(even ``-` `1``)``*``(even ``-` `2``)) ``/``/` `6` `+` `(odd ``*` `(odd ``-` `1``) ``/``/` `2``)``*` `even` `        ``# Printing the ans``        ``print``(ans,end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``# Given Input``    ``N ``=` `6``    ``Q ``=` `2``    ``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``6``]``    ``queries ``=` `[[``1``, ``3``],[``2``, ``5``]]` `    ``# Function Call``    ``countTriplets(N, Q, arr, queries)``    ` `    ``# This code is contributed by ipg2016107.`

## C#

 `// C# program for above approach``using` `System;` `class` `GFG``{``  ` `    ``// Function to count number of triplets``    ``// with even sum in range l, r for each``    ``// query``    ``static` `void` `countTriplets(``int` `size, ``int` `queries,``                              ``int``[] arr, ``int``[, ] Q)``    ``{` `        ``// Initialization of array``        ``int``[] arr_even = ``new` `int``[size + 1];``        ``int``[] arr_odd = ``new` `int``[size + 1];` `        ``// Initialization of variables``        ``int` `even = 0;``        ``int` `odd = 0;``        ``arr_even = 0;``        ``arr_odd = 0;` `        ``// Traversing array``        ``for` `(``int` `i = 0; i < size; i++) {` `            ``// If element is odd``            ``if` `(arr[i] % 2 == 1) {``                ``odd++;``            ``}` `            ``// If element is even``            ``else` `{``                ``even++;``            ``}` `            ``// Storing count of even and odd``            ``// till each i``            ``arr_even[i + 1] = even;``            ``arr_odd[i + 1] = odd;``        ``}` `        ``// Traversing each query``        ``for` `(``int` `i = 0; i < queries; i++) {``            ``int` `l = Q[i, 0], r = Q[i, 1];` `            ``// Count of odd numbers in l to r``            ``odd = arr_odd[r] - arr_odd[l - 1];` `            ``// Count of even numbers in l to r``            ``even = arr_even[r] - arr_even[l - 1];` `            ``// Finding the ans``            ``int` `ans = (even * (even - 1) * (even - 2)) / 6``                      ``+ (odd * (odd - 1) / 2) * even;` `            ``// Printing the ans``            ``Console.Write(ans + ``" "``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``      ` `        ``// Given Input``        ``int` `N = 6, Q = 2;``        ``int``[] arr = { 1, 2, 3, 4, 5, 6 };``        ``int``[, ] queries = { { 1, 3 }, { 2, 5 } };``        ``countTriplets(N, Q, arr, queries);``    ``}``}` `// This code is contributed by subham348.`

## Javascript

 `  ```

Output:
`1 2`

Time Complexity: O(N*Q)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up