Skip to content
Related Articles

Related Articles

Number of points lying inside a rectangle as well as a triangle
  • Last Updated : 22 Mar, 2021

Given two 2D arrays rectangle[][] and triangle[][], representing the coordinates of vertices of a rectangle and a triangle respectively, and another array points[][] consisting of N coordinates, the task is to count the number of points that lies inside both the rectangle and the triangle.

Examples:

Input: rectangle[][] = {{1, 1}, {6, 1}, {6, 6}, {1, 6}}, triangle[][] = {{4, 4}, {0, 4}, {0, -2}}, points[][] = {{6, 5}, {2, 2}, {2, 1}, {5, 5}}
Output: 2
Explanation:

From the above image, it is clear that the coordinates (2, 1) and (2, 2) lie inside both the given rectangle and triangle. 
Therefore, the count is 2. 
 



Input: rectangle[][] = {{-2, -2}, {2, -2}, {2, 2}, {-2, 2}}, triangle[][] = {{0, 0}, {1, 1}, {-1, -1}}, points[][] = {{0, 2}, {-2, -2}, {2, -2}}
Output: 2

Approach: The given problem can be solved based on the following observation: 

Any three vertices of a rectangle can be connected to form a triangle. 
Therefore, the number of triangles possible from a given rectangle is 4. 
 

Therefore, to solve the problem, the idea is to check if the given point lies inside the given triangle and any one of the four triangles obtained from the rectangle or not. F>ollow the steps below to solve the problem:

  • Initilize four lists, say triangle1, triangle2, triangle3 and triangle4, to store the coordinates of the vertices of the four triangles possible from a rectangle.
  • Populate the above initialized lists by considering three vertices of the rectangle at a time.
  • Initialize a variable, say ans as 0, to store the number of points that lies inside the triangle as well as the rectangle.
  • Traverse the array points[][] and check if there exists any point that lies inside any of the four obtained triangles as well as inside the given triangle or not. If found to be true, then increment ans by 1.
  • After completing the above steps, print the value of ans as the resultant count.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate area of a triangle
int getArea(int x1,int y1,int x2,int y2,int x3,int y3)
{
   
    // Return the resultant area
    return abs((x1 * (y2 - y3) +
                x2 * (y3 - y1) +
                x3 * (y1 - y2)) / 2);
}
 
// Function to check if a point
// lies inside a triangle or not
int isInside(vector<vector<int>> triangle, vector<int> point)
{
 
    vector<int> A = triangle[0];
    vector<int> B = triangle[1];
    vector<int> C = triangle[2];
    int x = point[0];
    int y = point[1];
 
    // Calculate area of triangle ABC
    int ABC = getArea(A[0], A[1],
                B[0], B[1],
                C[0], C[1]);
 
    // Calculate area of triangle
    // formed by connecting B, C, point
    int BPC = getArea(x, y, B[0],
                B[1], C[0],
                C[1]);
 
    // Calculate area of triangle
    // formed by connecting A, C, point
    int APC = getArea(A[0], A[1], x,
                y, C[0], C[1]);
 
    // Calculate area of triangle
    // formed by connecting A, B, point
    int APB = getArea(A[0], A[1], B[0],
               B[1], x, y);
 
    // Check if the sum of the areas of
    // above three triangles the same as ABC
    return ABC == (APC + APB + BPC);
}
 
// Function to count the number of points
// lying inside a triangle & rectangle
void countPoints(vector<vector<int>> rectangle,vector<vector<int>> triangle,vector<vector<int>> points){
 
    // Stores the coordinates of the
    // vertices of the triangles
    int n = rectangle.size();
    vector<vector<int>> triangle1;
    for(int i = 1; i < n; i++) triangle1.push_back(rectangle[i]);
    vector<vector<int>> triangle2;
 
    for(int i = 0; i < 3; i++) triangle2.push_back(rectangle[i]);
    vector<vector<int>> triangle3;
 
    for(int i = 0; i < 2; i++) triangle3.push_back(rectangle[i]);
    triangle3.push_back(rectangle[3]);
    vector<vector<int>> triangle4;
 
    for(int i = n - 2; i < n; i++) triangle4.push_back(rectangle[i]);
 
    triangle4.push_back(rectangle[0]);
 
    // Stores the number of points lying
    // inside the triangle and rectangle
    int ans = 0;
 
    // Traverse the array of points
    for(auto point:points)
    {
 
        // Stores whether the current point
        // lies inside triangle1 or not
        int condOne = isInside(triangle1, point);
 
        // Stores whether the current point
        // lies inside triangle2 or not
        int condTwo = isInside(triangle2, point);
 
        // Stores whether the current point
        // lies inside triangle3 or not
        int condThree = isInside(triangle3, point);
 
        // Stores whether the current point
        // lies inside triangle4 or not
        int condFour = isInside(triangle4, point);
 
        // Stores whether the current point
        // lies inside given triangle or not
        int condFive = isInside(triangle, point);
 
        // If current point lies inside
        // given triangle as well as inside
        // any of the four obtained triangles
        if ((condOne || condTwo || condThree || condFour) && condFive)
            ans += 1;
        }
 
    // Print the count of points
    cout << ans;
}
 
// Driver Code
int main()
{
  vector<vector<int>> rectangle = {{6, 5}, {2, 2}, {2, 1}, {5, 5}};
  vector<vector<int>> points = {{1, 1}, {6, 1}, {6, 6}, {1, 6}};
  vector<vector<int>> triangle = {{4, 4}, {0, 4}, {0, -2}};
  countPoints(points, triangle, rectangle);
  return 0;
}
 
// This code is contributed by mohit kumar 29.

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to calculate area of a triangle
static int getArea(int x1, int y1, int x2,
                   int y2, int x3, int y3)
{
     
    // Return the resultant area
    return Math.abs((x1 * (y2 - y3) +
                     x2 * (y3 - y1) +
                     x3 * (y1 - y2)) / 2);
}
  
// Function to check if a point
// lies inside a triangle or not
static int isInside(ArrayList<ArrayList<Integer>> triangle,
                    ArrayList<Integer> point)
{
    ArrayList<Integer> A = triangle.get(0);
    ArrayList<Integer> B = triangle.get(1);
    ArrayList<Integer> C = triangle.get(2);
    int x = point.get(0);
    int y = point.get(1);
  
    // Calculate area of triangle ABC
    int ABC = getArea(A.get(0), A.get(1),
                      B.get(0), B.get(1),
                      C.get(0), C.get(1));
  
    // Calculate area of triangle
    // formed by connecting B, C, point
    int BPC = getArea(x, y, B.get(0),
                  B.get(1), C.get(0),
                            C.get(1));
  
    // Calculate area of triangle
    // formed by connecting A, C, point
    int APC = getArea(A.get(0), A.get(1), x,
                   y, C.get(0), C.get(1));
  
    // Calculate area of triangle
    // formed by connecting A, B, point
    int APB = getArea(A.get(0), A.get(1), B.get(0),
                      B.get(1), x, y);
  
    // Check if the sum of the areas of
    // above three triangles the same as ABC
    return ABC == (APC + APB + BPC) ? 1 :0;
}
  
// Function to count the number of points
// lying inside a triangle & rectangle
static void countPoints(ArrayList<ArrayList<Integer>> rectangle,
                        ArrayList<ArrayList<Integer>> triangle,
                        ArrayList<ArrayList<Integer>> points)
{
  
    // Stores the coordinates of the
    // vertices of the triangles
    int n = rectangle.size();
    ArrayList<ArrayList<Integer>> triangle1 = new ArrayList<ArrayList<Integer>>();
     
    for(int i = 1; i < n; i++)
        triangle1.add(rectangle.get(i));
         
    ArrayList<ArrayList<Integer>> triangle2 = new ArrayList<ArrayList<Integer>>();
  
    for(int i = 0; i < 3; i++)
    {
        triangle2.add(rectangle.get(i));
    }
    ArrayList<ArrayList<Integer>> triangle3 = new ArrayList<ArrayList<Integer>>();
  
    for(int i = 0; i < 2; i++)
    {
        triangle3.add(rectangle.get(i));
    }
    triangle3.add(rectangle.get(3));
    ArrayList<ArrayList<Integer>> triangle4 = new ArrayList<ArrayList<Integer>>();
  
    for(int i = n - 2; i < n; i++)
    {
        triangle4.add(rectangle.get(i));
    }
  
    triangle4.add(rectangle.get(0));
  
    // Stores the number of points lying
    // inside the triangle and rectangle
    int ans = 0;
  
    // Traverse the array of points
    for(ArrayList<Integer> point:points)
    {
  
        // Stores whether the current point
        // lies inside triangle1 or not
        int condOne = isInside(triangle1, point);
  
        // Stores whether the current point
        // lies inside triangle2 or not
        int condTwo = isInside(triangle2, point);
  
        // Stores whether the current point
        // lies inside triangle3 or not
        int condThree = isInside(triangle3, point);
  
        // Stores whether the current point
        // lies inside triangle4 or not
        int condFour = isInside(triangle4, point);
  
        // Stores whether the current point
        // lies inside given triangle or not
        int condFive = isInside(triangle, point);
  
        // If current point lies inside
        // given triangle as well as inside
        // any of the four obtained triangles
        if ((condOne != 0 || condTwo != 0 ||
           condThree != 0 || condFour != 0) &&
            condFive != 0)
                ans += 1;
        }
  
    // Print the count of points
    System.out.println(ans);
}
  
// Driver Code
 
public static void main (String[] args)
{
    ArrayList<ArrayList<Integer>> rectangle = new ArrayList<ArrayList<Integer>>();
    ArrayList<ArrayList<Integer>> points = new ArrayList<ArrayList<Integer>>();
    ArrayList<ArrayList<Integer>> triangle = new ArrayList<ArrayList<Integer>>();
     
    rectangle.add(new ArrayList<Integer>(Arrays.asList(6, 5)));
    rectangle.add(new ArrayList<Integer>(Arrays.asList(2, 2)));
    rectangle.add(new ArrayList<Integer>(Arrays.asList(2, 1)));
    rectangle.add(new ArrayList<Integer>(Arrays.asList(5, 5)));
     
    points.add(new ArrayList<Integer>(Arrays.asList(1, 1)));
    points.add(new ArrayList<Integer>(Arrays.asList(6, 1)));
    points.add(new ArrayList<Integer>(Arrays.asList(6, 6)));
    points.add(new ArrayList<Integer>(Arrays.asList(1, 6)));
     
    triangle.add(new ArrayList<Integer>(Arrays.asList(4, 4)));
    triangle.add(new ArrayList<Integer>(Arrays.asList(0, 4)));
    triangle.add(new ArrayList<Integer>(Arrays.asList(0, -2)));
     
    countPoints(points, triangle, rectangle);
}
}
 
// This code is contributed by avanitrachhadiya2155

Python3




# Python3 program for the above approach
 
# Function to calculate area of a triangle
def getArea(x1, y1, x2, y2, x3, y3):
 
    # Return the resultant area
    return abs((x1 * (y2 - y3) +
                x2 * (y3 - y1) +
                x3 * (y1 - y2)) / 2)
 
# Function to check if a point
# lies inside a triangle or not
def isInside(triangle, point):
 
    A, B, C = triangle
    x, y = point
 
    # Calculate area of triangle ABC
    ABC = getArea(A[0], A[1],
                B[0], B[1],
                C[0], C[1])
 
    # Calculate area of triangle
    # formed by connecting B, C, point
    BPC = getArea(x, y, B[0],
                B[1], C[0],
                C[1])
 
    # Calculate area of triangle
    # formed by connecting A, C, point
    APC = getArea(A[0], A[1], x,
                y, C[0], C[1])
 
    # Calculate area of triangle
    # formed by connecting A, B, point
    APB = getArea(A[0], A[1], B[0],
                B[1], x, y)
 
    # Check if the sum of the areas of
    # above three triangles the same as ABC
    return ABC == (APC + APB + BPC)
 
# Function to count the number of points
# lying inside a triangle & rectangle
def countPoints(rectangle, triangle, points):
 
    # Stores the coordinates of the
    # vertices of the triangles
    triangle1 = rectangle[1:]
     
    triangle2 = rectangle[:3]
     
    triangle3 = rectangle[:2]
    triangle3.append(rectangle[3])
     
    triangle4 = rectangle[-2:]
    triangle4.append(rectangle[0])
 
    # Stores the number of points lying
    # inside the triangle and rectangle
    ans = 0
 
    # Traverse the array of points
    for point in points:
     
        # Stores whether the current point
        # lies inside triangle1 or not
        condOne = isInside(triangle1, point)
         
        # Stores whether the current point
        # lies inside triangle2 or not
        condTwo = isInside(triangle2, point)
         
        # Stores whether the current point
        # lies inside triangle3 or not
        condThree = isInside(triangle3, point)
         
        # Stores whether the current point
        # lies inside triangle4 or not
        condFour = isInside(triangle4, point)
 
        # Stores whether the current point
        # lies inside given triangle or not
        condFive = isInside(triangle, point)
 
        # If current point lies inside
        # given triangle as well as inside
        # any of the four obtained triangles
        if (condOne or condTwo or condThree \
            or condFour) and condFive:
            ans += 1
             
    # Print the count of points
    print(ans)
 
 
# Driver Code
 
rectangle = [[6, 5], [2, 2], [2, 1], [5, 5]]
points = [[1, 1], [6, 1], [6, 6], [1, 6]]
triangle = [[4, 4], [0, 4], [0, -2]]
 
countPoints(points, triangle, rectangle)

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
  // Function to calculate area of a triangle
  static int getArea(int x1, int y1, int x2,
                     int y2, int x3, int y3)
  {
 
    // Return the resultant area
    return Math.Abs((x1 * (y2 - y3) +
                     x2 * (y3 - y1) +
                     x3 * (y1 - y2)) / 2);
  }
 
  // Function to check if a point
  // lies inside a triangle or not
  static int isInside(List<List<int>> triangle,
                      List<int> point)
  {
    List<int> A = triangle[0];
    List<int> B = triangle[1];
    List<int> C = triangle[2];
    int x = point[0];
    int y = point[1];
 
    // Calculate area of triangle ABC
    int ABC = getArea(A[0], A[1],
                      B[0], B[1],
                      C[0], C[1]);
 
    // Calculate area of triangle
    // formed by connecting B, C, point
    int BPC = getArea(x, y, B[0],
                      B[1], C[0],
                      C[1]);
 
    // Calculate area of triangle
    // formed by connecting A, C, point
    int APC = getArea(A[0], A[1], x,
                      y, C[0], C[1]);
 
    // Calculate area of triangle
    // formed by connecting A, B, point
    int APB = getArea(A[0], A[1], B[0],
                      B[1], x, y);
 
    // Check if the sum of the areas of
    // above three triangles the same as ABC
    return ABC == (APC + APB + BPC) ? 1 :0;
  }
 
  // Function to count the number of points
  // lying inside a triangle & rectangle
  static void countPoints(List<List<int>> rectangle,
                          List<List<int>> triangle,
                          List<List<int>> points)
  {
 
    // Stores the coordinates of the
    // vertices of the triangles
    int n = rectangle.Count;
    List<List<int>> triangle1 = new List<List<int>>();
    for(int i = 1; i < n; i++)
      triangle1.Add(rectangle[i]);
    List<List<int>> triangle2 = new List<List<int>>();
    for(int i = 0; i < 3; i++)
    {
      triangle2.Add(rectangle[i]);
    }
    List<List<int>> triangle3 = new List<List<int>>();
 
    for(int i = 0; i < 2; i++)
    {
      triangle3.Add(rectangle[i]);
    }
    triangle3.Add(rectangle[3]);
    List<List<int>> triangle4 = new List<List<int>>();
 
    for(int i = n - 2; i < n; i++)
    {
      triangle4.Add(rectangle[i]);
    }
 
    triangle4.Add(rectangle[0]);
 
    // Stores the number of points lying
    // inside the triangle and rectangle
    int ans = 0;
 
    // Traverse the array of points
    foreach(List<int> point in points)
    {
 
      // Stores whether the current point
      // lies inside triangle1 or not
      int condOne = isInside(triangle1, point);
 
      // Stores whether the current point
      // lies inside triangle2 or not
      int condTwo = isInside(triangle2, point);
 
      // Stores whether the current point
      // lies inside triangle3 or not
      int condThree = isInside(triangle3, point);
 
      // Stores whether the current point
      // lies inside triangle4 or not
      int condFour = isInside(triangle4, point);
 
      // Stores whether the current point
      // lies inside given triangle or not
      int condFive = isInside(triangle, point);
 
      // If current point lies inside
      // given triangle as well as inside
      // any of the four obtained triangles
      if ((condOne != 0 || condTwo != 0 ||
           condThree != 0 || condFour != 0) &&
          condFive != 0)
        ans += 1;
    }
 
    // Print the count of points
    Console.WriteLine(ans);
  }
 
  // Driver Code
  static public void Main ()
  {
    List<List<int>> rectangle = new List<List<int>>();
    List<List<int>> points = new List<List<int>>();
    List<List<int>> triangle = new List<List<int>>();
 
    rectangle.Add(new List<int>(){6, 5});
    rectangle.Add(new List<int>(){2, 2});
    rectangle.Add(new List<int>(){2, 1});
    rectangle.Add(new List<int>(){5, 5});
 
    points.Add(new List<int>(){1, 1});
    points.Add(new List<int>(){6, 1});
    points.Add(new List<int>(){6, 6});
    points.Add(new List<int>(){1, 6});
 
    triangle.Add(new List<int>(){4, 4});
    triangle.Add(new List<int>(){0, 4});
    triangle.Add(new List<int>(){0, -2});
 
    countPoints(points, triangle, rectangle);
  }
}
 
// This code is contributed by rag2127
Output: 
2

 

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :