# Number of triplets such that each value is less than N and each pair sum is a multiple of K

Given two integers N and K. Find the numbers of triplets (a, b, c) such that 0 ? a, b, c ? N and (a + b), (b + c) and (c + a) are multiples of K.

Examples:

Input: N = 3, K = 2
Output:
Triplets possible are:
{(1, 1, 1), (1, 1, 3), (1, 3, 1)
(1, 3, 3), (2, 2, 2), (3, 1, 1)
(3, 1, 1), (3, 1, 3), (3, 3, 3)}

Input: N = 5, K = 3
Output:
Only possible triplet is (3, 3, 3)

Approach: Given that (a + b), (b + c) and (c + a) are multiples of K. Hence, we can say that (a + b) % K = 0, (b + c) % K = 0 and (c + a) % K = 0
If a belongs to the x modulo class of K then b should be in the (K – x)th modulo class using the first condition.
From the second condition, it can be seen that c belongs to the x modulo class of K. Now as both a and c belong to the same modulo class and they have to satisfy the third relation which is (a + c) % K = 0. It could be only possible if x = 0 or x = K / 2
When K is an odd integer, x = K / 2 is not valid.

Hence to solve the problem, count the number of elements from 0 to N in the 0th modulo class and the (K / 2)th modulo class of K

• If K is odd then the result is cnt3
• If K is even then the result is cnt3 + cnt[K / 2]3.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ` `using` `namespace` `std;`   `// Function to return the number of triplets` `int` `NoofTriplets(``int` `N, ``int` `K)` `{` `    ``int` `cnt[K];`   `    ``// Initializing the count array` `    ``memset``(cnt, 0, ``sizeof``(cnt));`   `    ``// Storing the frequency of each modulo class` `    ``for` `(``int` `i = 1; i <= N; i += 1) {` `        ``cnt[i % K] += 1;` `    ``}`   `    ``// If K is odd` `    ``if` `(K & 1)` `        ``return` `cnt * cnt * cnt;`   `    ``// If K is even` `    ``else` `{` `        ``return` `(cnt * cnt * cnt` `                ``+ cnt[K / 2] * cnt[K / 2] * cnt[K / 2]);` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 3, K = 2;`   `    ``// Function Call` `    ``cout << NoofTriplets(N, K);`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.Arrays;`   `class` `GFG ` `{`   `    ``// Function to return the number of triplets` `    ``static` `int` `NoofTriplets(``int` `N, ``int` `K) ` `    ``{` `        ``int``[] cnt = ``new` `int``[K];`   `        ``// Initializing the count array` `        ``Arrays.fill(cnt, ``0``, cnt.length, ``0``);`   `        ``// Storing the frequency of each modulo class` `        ``for` `(``int` `i = ``1``; i <= N; i += ``1``)` `        ``{` `            ``cnt[i % K] += ``1``;` `        ``}`   `        ``// If K is odd` `        ``if` `((K & ``1``) != ``0``) ` `        ``{` `            ``return` `cnt[``0``] * cnt[``0``] * cnt[``0``];` `        ``} ` `        ``// If K is even` `        ``else` `        ``{` `            ``return` `(cnt[``0``] * cnt[``0``] * cnt[``0``]` `                    ``+ cnt[K / ``2``] * cnt[K / ``2``] * cnt[K / ``2``]);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args) ` `    ``{`   `        ``int` `N = ``3``, K = ``2``;`   `        ``// Function Call` `        ``System.out.println(NoofTriplets(N, K));` `    ``}` `}`   `// This code is contributed by Princi Singh`

## C#

 `// C# implementation of the approach` `using` `System;`   `class` `GFG` `{` `    `  `    ``// Function to return the number of triplets` `    ``static` `int` `NoofTriplets(``int` `N, ``int` `K) ` `    ``{` `        ``int``[] cnt = ``new` `int``[K];`   `        ``// Initializing the count array` `        ``Array.Fill(cnt, 0, cnt.Length, 0);`   `        ``// Storing the frequency of each modulo class` `        ``for` `(``int` `i = 1; i <= N; i += 1)` `        ``{` `            ``cnt[i % K] += 1;` `        ``}`   `        ``// If K is odd` `        ``if` `((K & 1) != 0) ` `        ``{` `            ``return` `cnt * cnt * cnt;` `        ``} ` `        ``// If K is even` `        ``else` `        ``{` `            ``return` `(cnt * cnt * cnt` `                    ``+ cnt[K / 2] * cnt[K / 2] * cnt[K / 2]);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``static` `public` `void` `Main ()` `    ``{` `            ``int` `N = 3, K = 2;`   `        ``// Function Call` `        ``Console.Write(NoofTriplets(N, K));` `    ``}` `}`   `// This code is contributed by ajit`

## Python3

 `# Python3 implementation of the above approach `   `# Function to return the number of triplets ` `def` `NoofTriplets(N, K) : ` `    `  `    ``# Initializing the count array` `    ``cnt ``=` `[``0``]``*``K; `   `    ``# Storing the frequency of each modulo class ` `    ``for` `i ``in` `range``(``1``, N ``+` `1``) :` `        ``cnt[i ``%` `K] ``+``=` `1``; `   `    ``# If K is odd ` `    ``if` `(K & ``1``) :` `        ``rslt ``=` `cnt[``0``] ``*` `cnt[``0``] ``*` `cnt[``0``]; ` `        ``return` `rslt`   `    ``# If K is even ` `    ``else` `:` `        ``rslt ``=` `(cnt[``0``] ``*` `cnt[``0``] ``*` `cnt[``0``] ``+` `                ``cnt[K ``/``/` `2``] ``*` `cnt[K ``/``/` `2``] ``*` `cnt[K ``/``/` `2``]); ` `        ``return` `rslt`   `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: `   `    ``N ``=` `3``; K ``=` `2``; `   `    ``# Function Call ` `    ``print``(NoofTriplets(N, K)); `   `# This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`9`

Time Complexity: O(N)

Auxiliary Space: O(K)