Related Articles
Count quadruplets(A, B, C, D) till N such that sum of square of A and B is equal to that of C and D
• Difficulty Level : Hard
• Last Updated : 30 Sep, 2020

Given a number N, the task is to find the number of quadraples such that a2 + b2 = c2 + d2 where (1 <= a, b, c, d <= N).

Example:

Input: N = 2
Output:
Explanation:
There are 6 valid quadraples (1, 1, 1, 1), (1, 2, 1, 2), (1, 2, 2, 1), (2, 1, 1, 2), (2, 1, 2, 1), (2, 2, 2, 2).

Input: N = 4
Output 28
Explanation:
There are 28 valid quadraples for N = 4.

Naive Approach: The naive approach is to use 4 nested loops in the range [1, N] and count those quadruplets (a, b, c, d) such that a2 + b2 = c2 + d2

Time Complexity: O(N4
Auxiliary Space: O(1)

Efficient approach than Naive approach: The above solution can be reduced in terms of time complexity using some mathematics. Find the quadruplets such that a2 + b2 = c2 + d2.

a2 + b2 = c2 + d2
a2 + b2 – c2 = d2
Taking square root on both sides
(a2 + b2 – c2)1/2 = d

By using the above formula, we can conclude that d exists only if (a2 + b2 – c2)1/2 is a positive integer.

Time Complexity: O(N3)

Efficient Approach: The idea is to use Hashing. Below are the steps:

1. Traverse over all the pairs(say (a, b)) over [1, N] and store the value of a2 + b2 with its occurrence in a Map.
2. Iterate over all the pairs [1, N] and if the sum exists in the map then count the sum of each pair stored in the map.
3. Print the count.

Below is the implementation of the approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` `typedef` `long` `long` `int` `ll; `   `// Function to count the quadruples ` `ll countQuadraples(ll N) ` `{ ` `    ``// Counter variable ` `    ``ll cnt = 0; `   `    ``// Map to store the ` `    ``// sum of pair (a^2 + b^2) ` `    ``map m; `   `    ``// Iterate till N ` `    ``for` `(ll a = 1; a <= N; a++) { `   `        ``for` `(ll b = 1; b <= N; b++) { `   `            ``// Calculate a^2 + b^2 ` `            ``ll x = a * a + b * b; `   `            ``// Increment the value in map ` `            ``m[x] += 1; ` `        ``} ` `    ``} `   `    ``for` `(ll c = 1; c <= N; c++) { ` `        ``for` `(ll d = 1; d <= N; d++) { `   `            ``ll x = c * c + d * d; `   `            ``// Check if this sum ` `            ``// was also in a^2 + b^2 ` `            ``if` `(m.find(x) != m.end()) ` `                ``cnt += m[x]; ` `        ``} ` `    ``} `   `    ``// Return the count ` `    ``return` `cnt; ` `} `   `// Driver Code ` `int` `main() ` `{ ` `    ``// Given N ` `    ``ll N = 2; `   `    ``// Function Call ` `    ``cout << countQuadraples(N) ` `        ``<< endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*;`   `class` `GFG{`   `// Function to count the quadruples` `static` `long` `countQuadraples(``long` `N)` `{` `    `  `    ``// Counter variable` `    ``long` `cnt = ``0``;`   `    ``// Map to store the` `    ``// sum of pair (a^2 + b^2)` `    ``Map m = ``new` `HashMap<>();`   `    ``// Iterate till N` `    ``for``(``long` `a = ``1``; a <= N; a++)` `    ``{` `        ``for``(``long` `b = ``1``; b <= N; b++) ` `        ``{` `            `  `            ``// Calculate a^2 + b^2` `            ``long` `x = a * a + b * b;`   `            ``// Increment the value in map` `            ``m.put(x, m.getOrDefault(x, 0l) + ``1``);` `        ``}` `    ``}` `    `  `    ``for``(``long` `c = ``1``; c <= N; c++)` `    ``{` `        ``for``(``long` `d = ``1``; d <= N; d++)` `        ``{` `            ``long` `x = c * c + d * d;`   `            ``// Check if this sum` `            ``// was also in a^2 + b^2` `            ``if` `(m.containsKey(x))` `                ``cnt += m.get(x);` `        ``}` `    ``}` `    `  `    ``// Return the count` `    ``return` `cnt;` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``// Given N` `    ``long` `N = ``2``;` `    `  `    ``// Function call` `    ``System.out.println(countQuadraples(N));` `}` `}`   `// This code is contributed by offbeat`

## Python3

 `# Python3 program for ` `# the above approach ` `from` `collections ``import` `defaultdict`   `# Function to count ` `# the quadruples ` `def` `countQuadraples(N):`   `    ``# Counter variable ` `    ``cnt ``=` `0` ` `  `    ``# Map to store the ` `    ``# sum of pair (a^2 + b^2) ` `    ``m ``=` `defaultdict (``int``)` ` `  `    ``# Iterate till N ` `    ``for` `a ``in` `range` `(``1``, N ``+` `1``):` ` `  `        ``for` `b ``in` `range` `(``1``, N ``+` `1``):` ` `  `            ``# Calculate a^2 + b^2 ` `            ``x ``=` `a ``*` `a ``+` `b ``*` `b` ` `  `            ``# Increment the value in map ` `            ``m[x] ``+``=` `1` ` `  `    ``for` `c ``in` `range` `(``1``, N ``+` `1``):` `        ``for` `d ``in` `range` `(``1``, N ``+` `1``):` ` `  `            ``x ``=` `c ``*` `c ``+` `d ``*` `d ` ` `  `            ``# Check if this sum ` `            ``# was also in a^2 + b^2 ` `            ``if` `x ``in` `m:` `                ``cnt ``+``=` `m[x] ` `        `  `    ``# Return the count ` `    ``return` `cnt` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:`   `    ``# Given N ` `    ``N ``=` `2` ` `  `    ``# Function Call ` `    ``print` `(countQuadraples(N))` `        `  `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach ` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to count the quadruples` `static` `long` `countQuadraples(``long` `N)` `{` `    `  `    ``// Counter variable` `    ``long` `cnt = 0;`   `    ``// Map to store the` `    ``// sum of pair (a^2 + b^2)` `    ``Dictionary<``long``, ` `               ``long``> m = ``new` `Dictionary<``long``, ` `                                        ``long``>();`   `    ``// Iterate till N` `    ``for``(``long` `a = 1; a <= N; a++)` `    ``{` `        ``for``(``long` `b = 1; b <= N; b++) ` `        ``{` `            `  `            ``// Calculate a^2 + b^2` `            ``long` `x = a * a + b * b;`   `            ``// Increment the value in map` `            ``if` `(m.ContainsKey(x))` `                ``m[x] = m[x] + 1;` `            ``else` `                ``m.Add(x, 1);` `        ``}` `    ``}` `    `  `    ``for``(``long` `c = 1; c <= N; c++)` `    ``{` `        ``for``(``long` `d = 1; d <= N; d++)` `        ``{` `            ``long` `x = c * c + d * d;`   `            ``// Check if this sum` `            ``// was also in a^2 + b^2` `            ``if` `(m.ContainsKey(x))` `                ``cnt += m[x];` `        ``}` `    ``}` `    `  `    ``// Return the count` `    ``return` `cnt;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Given N` `    ``long` `N = 2;` `    `  `    ``// Function call` `    ``Console.WriteLine(countQuadraples(N));` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:

```6

```

Time Complexity: O(N2 log N)
Auxiliary Space: O(N) My Personal Notes arrow_drop_up
Recommended Articles
Page :