Number of Integral Points between Two Points
Last Updated :
07 Oct, 2022
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).
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.x)-1
3. Else, we can find the integral points between the
vertices using below formula:
GCD(abs(p.x - q.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 +c, 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 the implementation of above idea.
C++
#include <iostream>
#include <cmath>
using namespace std;
class Point
{
public :
int x, y;
Point( int a=0, int b=0):x(a),y(b) {}
};
int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a%b);
}
int getCount(Point p, Point q)
{
if (p.x==q.x)
return abs (p.y - q.y) - 1;
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;
}
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;
}
|
Java
class GFG
{
static class Point
{
int x, y;
Point( int a, int b)
{
this .x = a;
this .y = b;
}
};
static int gcd( int a, int b)
{
if (b == 0 )
return a;
return gcd(b, a % b);
}
static int getCount(Point p, Point q)
{
if (p.x == q.x)
return Math.abs(p.y - q.y) - 1 ;
if (p.y == q.y)
return Math.abs(p.x - q.x) - 1 ;
return gcd(Math.abs(p.x - q.x), Math.abs(p.y - q.y)) - 1 ;
}
public static void main(String[] args)
{
Point p = new Point( 1 , 9 );
Point q = new Point( 8 , 16 );
System.out.println( "The number of integral points between "
+ "(" + p.x + ", " + p.y + ") and ("
+ q.x + ", " + q.y + ") is "
+ getCount(p, q));
}
}
|
Python3
class Point:
def __init__( self , a, b):
self .x = a
self .y = b
def gcd(a, b):
if b = = 0 :
return a
return gcd(b, a % b)
def getCount(p, q):
if p.x = = q.x:
return abs (p.y - q.y) - 1
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
if __name__ = = "__main__" :
p = Point( 1 , 9 )
q = Point( 8 , 16 )
print ( "The number of integral points" ,
"between ({}, {}) and ({}, {}) is {}" .
format (p.x, p.y, q.x, q.y, getCount(p, q)))
|
C#
using System;
class GFG
{
public class Point
{
public int x, y;
public Point( int a, int b)
{
this .x = a;
this .y = b;
}
};
static int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static int getCount(Point p, Point q)
{
if (p.x == q.x)
return Math.Abs(p.y - q.y) - 1;
if (p.y == q.y)
return Math.Abs(p.x - q.x) - 1;
return gcd(Math.Abs(p.x - q.x), Math.Abs(p.y - q.y)) - 1;
}
public static void Main(String[] args)
{
Point p = new Point(1, 9);
Point q = new Point(8, 16);
Console.WriteLine( "The number of integral points between "
+ "(" + p.x + ", " + p.y + ") and ("
+ q.x + ", " + q.y + ") is "
+ getCount(p, q));
}
}
|
Javascript
<script>
class Point {
constructor(a , b) {
this .x = a;
this .y = b;
}
}
function gcd(a , b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
function getCount( p, q)
{
if (p.x == q.x)
return Math.abs(p.y - q.y) - 1;
if (p.y == q.y)
return Math.abs(p.x - q.x) - 1;
return gcd(Math.abs(p.x - q.x), Math.abs(p.y - q.y)) - 1;
}
p = new Point(1, 9);
q = new Point(8, 16);
document.write( "The number of integral points between " + "(" + p.x + ", " + p.y + ") and (" + q.x + ", "
+ q.y + ") is " + getCount(p, q));
</script>
|
Output:
The number of integral points between (1, 9) and (8, 16) is 6
Time Complexity: O(log(min(a,b))), as we are using recursion to find the GCD.
Auxiliary Space: O(log(min(a,b))), for recursive stack space.
Reference :
https://www.geeksforgeeks.org/count-integral-points-inside-a-triangle/
This article has been contributed by Paridhi Johari.
Share your thoughts in the comments
Please Login to comment...