 Open in App
Not now

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

• Last Updated : 13 Jun, 2022

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 = D2 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(D2 – 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++

 `// C++ program for the above approach`   `#include ` `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

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

## Python3

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

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

## Javascript

 ``

Output

`12`

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

My Personal Notes arrow_drop_up
Related Articles