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

Given a number N, the task is to find the number of quadruples such that a² + b² = c² + d² where (1 <= a, b, c, d <= N).

Example:

Input: N = 2 
Output: 6 
Explanation:
There are 6 valid quadruples (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 quadruples 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 a² + b² = c² + d²

Time Complexity: O(N⁴) 
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 a² + b² = c² + d².

a² + b² = c² + d²
a² + b² – c² = d²
Taking square root on both sides 
(a² + b² – c²)^1/2 = d 

By using the above formula, we can conclude that d exists only if (a² + b² – c²)^1/2 is a positive integer. 

Time Complexity: O(N³)

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 a² + b² 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 <bits/stdc++.h>
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<ll, ll> 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<Long, Long> 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

<script>


// Javascript program for the above approach

// Function to count the quadruples
function countQuadraples(N)
{
    // Counter variable
    var cnt = 0;

    // Map to store the
    // sum of pair (a^2 + b^2)
    var m = new Map();

    // Iterate till N
    for (var a = 1; a <= N; a++) {

        for (var b = 1; b <= N; b++) {

            // Calculate a^2 + b^2
            var x = a * a + b * b;

            // Increment the value in map
            if(m.has(x))
                m.set(x, m.get(x)+1)
            else
                m.set(x, 1)
        }
    }

    for (var c = 1; c <= N; c++) {
        for (var d = 1; d <= N; d++) {

            var x = c * c + d * d;

            // Check if this sum
            // was also in a^2 + b^2
            if (m.has(x))
                cnt += m.get(x);
        }
    }

    // Return the count
    return cnt;
}

// Driver Code
// Given N
var N = 2;
// Function Call
document.write( countQuadraples(N))


</script>

Output:

6

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