# Number of Integral Points between Two Points

Given two points p (x1, y1) and q (x2, y2), calculate the number of integral points lying on the line joining them.

Example : If points are (0, 2) and (4, 0), then the number of integral points lying on it is only one and that is (2, 1).
Similarly, if points are (1, 9) and (8, 16), the integral points lying on it are 6 and they are (2, 10), (3, 11), (4, 12), (5, 13), (6, 14) and (7, 15).

## We strongly recommend that you click here and practice it, before moving on to the solution.

Simple Approach
Start from any of the given points, reach the other end point by using loops. For every point inside the loop, check if it lies on the line that joins given two points. If yes, then increment the count by 1. Time Complexity for this approach will be O(min(x2-x1, y2-y1)).

Optimal Approach

```1. If the edge formed by joining p and q is parallel
to the X-axis, then the number of integral points
between the vertices is :
abs(p.y - q.y)-1

2. Similarly if edge is parallel to the Y-axis, then
the number of integral points in between is :
abs(p.x - q.y)-1

3. Else, we can find the integral points between the
vertices using below formula:
GCD(abs(p.x - p.x), abs(p.y - q.y)) - 1
```

How does the GCD formula work?

The idea is to find the equation of the line in simplest form, i.e., in equation ax + by +x, coefficients a, b and c become co-prime. We can do this by calculating the GCD (greatest common divisor) of a, b and c and convert a, b and c in the simplest form.
Then, the answer will be (difference of y coordinates) divided by (a) – 1. This is because after calculating ax + by + c = 0, for different y values, x will be number of y values which are exactly divisible by a.

Below is C++ implementation of above idea.

```// C++ code to find the number of integral points
// lying on the line joining the two given points
#include <iostream>
#include <cmath>
using namespace std;

// Class to represent an Integral point on XY plane.
class Point
{
public:
int x, y;
Point(int a=0, int b=0):x(a),y(b) {}
};

// Utility function to find GCD of two numbers
// GCD of a and b
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a%b);
}

// Finds the no. of Integral points between
// two given points.
int getCount(Point p, Point q)
{
// If line joining p and q is parallel to
// x axis, then count is difference of y
// values
if (p.x==q.x)
return abs(p.y - q.y) - 1;

// If line joining p and q is parallel to
// y axis, then count is difference of x
// values
if (p.y == q.y)
return abs(p.x-q.x) - 1;

return gcd(abs(p.x-q.x), abs(p.y-q.y))-1;
}

// Driver program to test above
int main()
{
Point p(1, 9);
Point q(8, 16);

cout << "The number of integral points between "
<< "(" << p.x << ", " << p.y << ") and ("
<< q.x << ", " << q.y << ") is "
<< getCount(p, q);

return 0;
}
```

Output:

`The number of integral points between (1, 9) and (8, 16) is 6`

This article has been contributed by Paridhi Johari. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
3.6 Average Difficulty : 3.6/5.0
Based on 8 vote(s)