Given N points in 2 dimensional space. The task is to count the number of triplets pairs (A, B, C) such that point B is the midpoint of line segment formed by joining points A and C.
Examples:
Input: points = {{1, 1}, {2, 2}, {3, 3}}
Output: 1
The point (2, 2) is the midpoint of the line segment joining points (1, 1) and (3, 3).
Input: points = {{1, 1}, {1, 2}, {1, 5}}
Output: 0
Approach: Consider a pair of points A and C. The midpoint of the line segment joining these points will be ((A * X + C * X) / 2, (A * Y + C * Y) / 2)). If the point is present in the given list of points, we have found a triplet. To quickly check if a point is in our list of points we can use a set. Doing this for all pairs of points will give us the required count.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the count of possible triplets int countTriplets( int n, vector<pair< int , int > > points)
{ set<pair< int , int > > pts;
int ct = 0;
// Insert all the points in a set
for ( int i = 0; i < n; i++)
pts.insert(points[i]);
for ( int i = 0; i < n; i++)
for ( int j = i + 1; j < n; j++) {
int x = points[i].first + points[j].first;
int y = points[i].second + points[j].second;
// If the mid point exists in the set
if (x % 2 == 0 && y % 2 == 0)
if (pts.find(make_pair(x / 2, y / 2))
!= pts.end())
ct++;
}
// Return the count of valid triplets
return ct;
} // Driver code int main()
{ vector<pair< int , int > > points
= { { 1, 1 }, { 2, 2 }, { 3, 3 } };
int n = points.size();
cout << countTriplets(n, points);
} |
// Java implementation of the approach import java.util.*;
class GFG
{ static class pair
{ int first,second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
} // Function to return the count of possible triplets static int countTriplets( int n, Vector<pair> points)
{ Set<pair> pts = new HashSet<pair>();
int ct = 0 ;
// Insert all the points in a set
for ( int i = 0 ; i < n; i++)
pts.add(points.get(i));
for ( int i = 0 ; i < n; i++)
for ( int j = i + 1 ; j < n; j++)
{
int x = points.get(i).first + points.get(j).first;
int y = points.get(i).second + points.get(j).second;
// If the mid point exists in the set
if (x % 2 == 0 && y % 2 == 0 )
if (!pts.contains( new pair(x / 2 , y / 2 )))
ct++;
}
// Return the count of valid triplets
return ct;
} // Driver code public static void main(String args[])
{ Vector<pair> points = new Vector<>();
points.add( new pair( 1 , 1 ));
points.add( new pair( 2 , 2 ));
points.add( new pair( 3 , 3 ));
int n = points.size();
System.out.println(countTriplets(n, points));
} } // This code is contributed by Princi Singh |
# Python3 implementation of the approach # Function to return the count # of possible triplets def countTriplets(n, points) :
pts = []
ct = 0 ;
# Insert all the points in a set
for i in range (n) :
pts.append(points[i]);
for i in range (n) :
for j in range (i + 1 , n) :
x = points[i][ 0 ] + points[j][ 0 ];
y = points[i][ 1 ] + points[j][ 1 ];
# If the mid point exists in the set
if (x % 2 = = 0 and y % 2 = = 0 ) :
if [x / / 2 , y / / 2 ] in pts :
ct + = 1
# Return the count of valid triplets
return ct
# Driver code if __name__ = = "__main__" :
points = [[ 1 , 1 ], [ 2 , 2 ], [ 3 , 3 ]]
n = len (points)
print (countTriplets(n, points))
# This code is contributed by Ryuga |
// C# implementation of the approach using System;
using System.Collections.Generic;
class GFG
{ public class pair
{ public int first,second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
} // Function to return the count of possible triplets static int countTriplets( int n, List<pair> points)
{ HashSet<pair> pts = new HashSet<pair>();
int ct = 0;
// Insert all the points in a set
for ( int i = 0; i < n; i++)
pts.Add(points[i]);
for ( int i = 0; i < n; i++)
for ( int j = i + 1; j < n; j++)
{
int x = points[i].first + points[j].first;
int y = points[i].second + points[j].second;
// If the mid point exists in the set
if (x % 2 == 0 && y % 2 == 0)
if (!pts.Contains( new pair(x / 2, y / 2)))
ct++;
}
// Return the count of valid triplets
return ct;
} // Driver code public static void Main(String []args)
{ List<pair> points = new List<pair>();
points.Add( new pair(1, 1));
points.Add( new pair(2, 2));
points.Add( new pair(3, 3));
int n = points.Count;
Console.WriteLine(countTriplets(n, points));
} } // This code is contributed by 29AjayKumar |
<?php // PHP implementation of the approach // Function to return the count // of possible triplets function countTriplets( $n , $points )
{ $pts = array ();
$ct = 0;
// Insert all the points in a set
for ( $i = 0; $i < count ( $points ); $i ++)
{
for ( $j = 0;
$j < count ( $points [ $i ]); $j ++)
{
$pts [] = $points [ $i ][ $j ];
}
}
for ( $i = 0; $i < $n ; $i ++)
for ( $j = $i + 1; $j < $n ; $j ++)
{
$x = $points [ $i ][0] + $points [ $j ][0];
$y = $points [ $i ][1] + $points [ $j ][1];
// If the mid point exists in the set
if ( $x % 2 == 0 and $y % 2 == 0)
if (in_array((int)( $x / 2), $pts ) and
in_array((int)( $y / 2), $pts ))
$ct += 1;
}
// Return the count of valid triplets
return $ct ;
} // Driver code $points = array ( array ( 1, 1 ),
array ( 2, 2 ),
array ( 3, 3 ));
$n = count ( $points );
print (countTriplets( $n , $points ));
// This code is contributed by chandan_jnu ?> |
<script> // Javascript implementation of the approach // Function to return the count of possible triplets function countTriplets(n, points)
{ var pts = new Set();
var ct = 0;
// Insert all the points in a set
for ( var i = 0; i < n; i++)
pts.add(points[i].toString());
for ( var i = 0; i < n; i++)
for ( var j = i + 1; j < n; j++) {
var x = points[i][0] + points[j][0];
var y = points[i][1] + points[j][1];
// If the mid point exists in the set
if (x % 2 == 0 && y % 2 == 0)
if (pts.has([(x / 2), (y / 2)].toString()))
ct++;
}
// Return the count of valid triplets
return ct;
} // Driver code var points
= [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ] ];
var n = points.length;
document.write( countTriplets(n, points)) // This code is contributed by famously. </script> |
1
Time Complexity: O(N2 logN), where N represents the size of the given vector.
Auxiliary Space: O(N), where N represents the size of the given vector.