Count of integral points that lie at a distance D from origin

Given a positive integer D, the task is to find the number of integer coordinates (x, y) which lie at a distance D from origin.

Example:

Input: D = 1
Output: 4
Explanation: Total valid points are {1, 0}, {0, 1}, {-1, 0}, {0, -1}

Input: D = 5
Output: 12
Explanation: Total valid points are {0, 5}, {0, -5}, {5, 0}, {-5, 0}, {3, 4}, {3, -4}, {-3, 4}, {-3, -4}, {4, 3}, {4, -3}, {-4, 3}, {-4, -3}

Approach: This question can be simplified to count integer coordinates lying on the circumference of the circle centered at the origin, having a radius D and can be solved with the help of the Pythagoras theorem. As the points should be at a distance D from the origin, so they all must satisfy the equation x * x + y * y = D² where (x, y) are the coordinates of the point.
Now, to solve the above problem, follow the below steps:

• Initialize a variable, say count that stores the total count of the possible pairs of coordinates.
• Iterate over all possible x coordinates and calculate the corresponding value of y as sqrt(D² - y*y).
• Since every coordinate whose both x and y are positive integers can form a total of 4 possible valid pairs as {x, y}, {-x, y}, {-x, -y}, {x, -y} and increment the count each possible pair (x, y) by 4 in the variable count.
• Also, there is always an integer coordinate present at the circumference of the circle where it cuts the x-axis and y-axis because the radius of the circle is an integer. So add 4 in count, to compensate these points.
• After completing the above steps, print the value of count as the resultant count of pairs.

Below is the implementation of the above approach:

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the total valid
// integer coordinates at a distance D
// from origin
int countPoints(int D)
{
    // Stores the count of valid points
    int count = 0;

    // Iterate over possible x coordinates
    for (int x = 1; x * x < D * D; x++) {

        // Find the respective y coordinate
        // with the pythagoras theorem
        int y = (int)sqrt(double(D * D - x * x));
        if (x * x + y * y == D * D) {
            count += 4;
        }
    }

    // Adding 4 to compensate the coordinates
    // present on x and y axes.
    count += 4;

    // Return the answer
    return count;
}

// Driver Code
int main()
{
    int D = 5;
    cout << countPoints(D);

    return 0;
}

// Java program for the above approach
import java.io.*;

class GFG {

// Function to find the total valid
// integer coordinates at a distance D
// from origin
static int countPoints(int D)
{
  
    // Stores the count of valid points
    int count = 0;

    // Iterate over possible x coordinates
    for (int x = 1; x * x < D * D; x++) {

        // Find the respective y coordinate
        // with the pythagoras theorem
        int y = (int)Math.sqrt((D * D - x * x));
        if (x * x + y * y == D * D) {
            count += 4;
        }
    }

    // Adding 4 to compensate the coordinates
    // present on x and y axes.
    count += 4;

    // Return the answer
    return count;
}

// Driver Code
public static void main (String[] args) 
{
    int D = 5;
    System.out.println(countPoints(D));
}
}

// this code is contributed by shivanisinghss2110

# python 3 program for the above approach
from math import sqrt

# Function to find the total valid
# integer coordinates at a distance D
# from origin
def countPoints(D):
  
    # Stores the count of valid points
    count = 0

    # Iterate over possible x coordinates
    for x in range(1, int(sqrt(D * D)), 1):

        # Find the respective y coordinate
        # with the pythagoras theorem
        y = int(sqrt((D * D - x * x)))
        if (x * x + y * y == D * D):
            count += 4

    # Adding 4 to compensate the coordinates
    # present on x and y axes.
    count += 4

    # Return the answer
    return count

# Driver Code
if __name__ == '__main__':
    D = 5
    print(countPoints(D))
    
    # This code is contributed by SURENDRA_GANGWAR.

// C# program for the above approach
using System;

// Function to find the total valid
// integer coordinates at a distance D
// from origin
public class GFG{
    static int countPoints(int D){
        
        // Stores the count of valid points
        int count = 0;
        
        // Iterate over possible x coordinates
        for(int x = 1; x*x < D*D; x++){
            int y = (int)Math.Sqrt((D * D - x * x));

            // Find the respective y coordinate
            // with the pythagoras theorem
            if(x * x + y * y == D * D){
              count += 4;   
            }
       }
    // Adding 4 to compensate the coordinates
    // present on x and y axes.
    
    count += 4;

    // Return the answer
    return count;
}
    
    // Driver Code

    public static void Main(){
        int D = 5;
        Console.Write(countPoints(D));
    }
}

// This code is contributed by gfgking

<script>
        // JavaScript Program to implement
        // the above approach

        // Function to find the total valid
        // integer coordinates at a distance D
        // from origin
        function countPoints(D)
        {
        
            // Stores the count of valid points
            let count = 0;

            // Iterate over possible x coordinates
            for (let x = 1; x * x < D * D; x++) {

                // Find the respective y coordinate
                // with the pythagoras theorem
                let y = Math.floor(Math.sqrt(D * D - x * x));
                if (x * x + y * y == D * D) {
                    count += 4;
                }
            }

            // Adding 4 to compensate the coordinates
            // present on x and y axes.
            count += 4;

            // Return the answer
            return count;
        }

        // Driver Code
        let D = 5;
        document.write(countPoints(D));

     // This code is contributed by Potta Lokesh
    </script>

12

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