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 = 2Output:9

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 = 3Output:1

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 **0 ^{th}** modulo class and the

**(K / 2)**modulo class of

^{th}**K**.

- If
**K**is**odd**then the result is**cnt[0]**^{3} - If
**K**is**even**then the result is**cnt[0]**.^{3}+ cnt[K / 2]^{3}

Below is the implementation of the above approach:

`// C++ implementation of the above approach ` `#include <bits/stdc++.h> ` `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[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 ` `int` `main() `
`{ ` ` ` `int` `N = 3, K = 2; `
` ` ` ` `// Function Call `
` ` `cout << NoofTriplets(N, K); `
` ` ` ` `return` `0; `
`} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

`// 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[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 `
` ` `static` `public` `void` `Main () `
` ` `{ `
` ` `int` `N = 3, K = 2; `
` ` ` ` `// Function Call `
` ` `Console.Write(NoofTriplets(N, K)); `
` ` `} `
`} ` ` ` `// This code is contributed by ajit ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

9

**Time Complexity:** O(N)

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.

## Recommended Posts:

- Largest number less than N with digit sum greater than the digit sum of N
- Count of integers of length N and value less than K such that they contain digits only from the given set
- Maximum profit such that total stolen value is less than K to get bonus
- Maximum value of B less than A such that A ^ B = A + B
- Find unique pairs such that each element is less than or equal to N
- Largest number with maximum trailing nines which is less than N and greater than N-D
- Sum of elements in 1st array such that number of elements less than or equal to them in 2nd array is maximum
- Sum of largest prime factor of each number less than equal to n
- Highest and Smallest power of K less than and greater than equal to N respectively
- Print a number strictly less than a given number such that all its digits are distinct.
- Largest number less than N whose each digit is prime number
- Largest number M less than N such that XOR of M and N is even
- Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
- Find maximum number of elements such that their absolute difference is less than or equal to 1
- Count pairs with sum as a prime number and less than n
- Count number of triplets (a, b, c) such that a^2 + b^2 = c^2 and 1 <= a <= b <= c <= n
- Count of elements having Euler's Totient value one less than itself
- Count numbers whose maximum sum of distinct digit-sum is less than or equals M
- Largest subset having with sum less than equal to sum of respective indices
- Maximum sum subarray of size K with sum less than X

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.