 Open in App
Not now

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

• Last Updated : 27 Dec, 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:

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