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 : 25 May, 2021

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 rather than the 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 on the map, then count the sum of each pair stored on 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`

## Javascript

 ``
Output:
`6`

Time Complexity: O(N2 log N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up