# Triangle with no point inside

Given N points in 2-dimensional space, we need to find three points such that triangle made by choosing these points should not contain any other points inside. All given points will not lie on the same line so solution will always exist.
Examples:

`In above diagram possible triangle with no point inside can be formed by choosing these triplets,[(0, 0), (2, 0), (1, 1)][(0, 0), (1, 1), (0, 2)][(1, 1), (2, 0), (2, 2)][(1, 1), (0, 2), (2, 2)]So any of the above triplets can be the final answer.`

The solution is based on the fact that if there exist triangle(s) with no points inside, then we can form a triangle with any random point among all points.
We can solve this problem by searching all three points one by one. The first point can be chosen randomly. After choosing the first point, we need two points such that their slope should be different and no point should lie inside the triangle of these three points. We can do this by choosing the second point as nearest point to the first and third point as second nearest point with the different slope. For doing this, we first iterate over all points and choose the point which is nearest to the first one and designate that as second point of the required triangle. Then we iterate one more time to find point which has different slope and has the smallest distance, which will be the third point of our triangle.

## C++

 `// C/C++ program to find triangle with no point inside``#include ``using` `namespace` `std;` `// method to get square of distance between``// (x1, y1) and (x2, y2)``int` `getDistance(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2)``{``    ``return` `(x2 - x1)*(x2 - x1) +``           ``(y2 - y1)*(y2 - y1);``}` `// Method prints points which make triangle with no``// point inside``void` `triangleWithNoPointInside(``int` `points[][2], ``int` `N)``{``    ``//    any point can be chosen as first point of triangle``    ``int` `first = 0;``    ``int` `second, third;``    ``int` `minD = INT_MAX;` `    ``// choose nearest point as second point of triangle``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(i == first)``            ``continue``;` `        ``// Get distance from first point and choose``        ``// nearest one``        ``int` `d = getDistance(points[i][0], points[i][1],``                    ``points[first][0], points[first][1]);``        ``if` `(minD > d)``        ``{``            ``minD = d;``            ``second = i;``        ``}``    ``}` `    ``// Pick third point by finding the second closest``    ``// point with different slope.``    ``minD = INT_MAX;``    ``for` `(``int` `i = 0; i < N; i++)``    ``{``        ``// if already chosen point then skip them``        ``if` `(i == first || i == second)``            ``continue``;` `        ``// get distance from first point``        ``int` `d = getDistance(points[i][0], points[i][1],``                     ``points[first][0], points[first][1]);` `        ``/*  the slope of the third point with the first``            ``point should not be equal to the slope of``            ``second point with first point (otherwise``            ``they'll be collinear)     and among all such``            ``points, we choose point with the smallest``            ``distance  */``        ``// here cross multiplication is compared instead``        ``// of division comparison``        ``if` `((points[i][0] - points[first][0]) *``            ``(points[second][1] - points[first][1]) !=``            ``(points[second][0] - points[first][0]) *``            ``(points[i][1] - points[first][1]) &&``            ``minD > d)``        ``{``            ``minD = d;``            ``third = i;``        ``}``    ``}` `    ``cout << points[first][0] << ``", "``         ``<< points[first][1] << endl;``    ``cout << points[second][0] << ``", "``         ``<< points[second][1] << endl;``    ``cout << points[third][0] << ``", "``         ``<< points[third][1] << endl;``}` `// Driver code to test above methods``int` `main()``{``    ``int` `points[][2] = {{0, 0}, {0, 2}, {2, 0},``                       ``{2, 2}, {1, 1}};``    ``int` `N = ``sizeof``(points) / ``sizeof``(points[0]);``    ``triangleWithNoPointInside(points, N);``    ``return` `0;``}`

## Java

 `// Java program to find triangle``// with no point inside``import` `java.io.*;` `class` `GFG ``{``    ``// method to get square of distance between``    ``// (x1, y1) and (x2, y2)``    ``static` `int` `getDistance(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2)``    ``{``        ``return` `(x2 - x1)*(x2 - x1) +``                  ``(y2 - y1)*(y2 - y1);``    ``}``    ` `    ``// Method prints points which make triangle with no``    ``// point inside``    ``static` `void` `triangleWithNoPointInside(``int` `points[][], ``int` `N)``    ``{``        ``// any point can be chosen as first point of triangle``        ``int` `first = ``0``;``        ``int` `second =``0``;``        ``int` `third =``0``;``        ``int` `minD = Integer.MAX_VALUE;``    ` `        ``// choose nearest point as second point of triangle``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``if` `(i == first)``                ``continue``;``    ` `            ``// Get distance from first point and choose``            ``// nearest one``            ``int` `d = getDistance(points[i][``0``], points[i][``1``],``                        ``points[first][``0``], points[first][``1``]);``            ``if` `(minD > d)``            ``{``                ``minD = d;``                ``second = i;``            ``}``        ``}``    ` `        ``// Pick third point by finding the second closest``        ``// point with different slope.``        ``minD = Integer.MAX_VALUE;``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``// if already chosen point then skip them``            ``if` `(i == first || i == second)``                ``continue``;``    ` `            ``// get distance from first point``            ``int` `d = getDistance(points[i][``0``], points[i][``1``],``                        ``points[first][``0``], points[first][``1``]);``    ` `            ``/* the slope of the third point with the first``                ``point should not be equal to the slope of``                ``second point with first point (otherwise``                ``they'll be collinear) and among all such``                ``points, we choose point with the smallest``                ``distance */``            ``// here cross multiplication is compared instead``            ``// of division comparison``            ``if` `((points[i][``0``] - points[first][``0``]) *``                ``(points[second][``1``] - points[first][``1``]) !=``                ``(points[second][``0``] - points[first][``0``]) *``                ``(points[i][``1``] - points[first][``1``]) &&``                ``minD > d)``            ``{``                ``minD = d;``                ``third = i;``            ``}``        ``}``    ` `        ``System.out.println(points[first][``0``] + ``", "``            ``+ points[first][``1``]);``        ``System.out.println(points[second][``0``]+ ``", "``            ``+ points[second][``1``]) ;``        ``System.out.println(points[third][``0``] +``", "``            ``+ points[third][``1``]);``    ``}``    ` `    ``// Driver code ``    ``public` `static` `void` `main (String[] args) ``    ``{``        ``int` `points[][] = {{``0``, ``0``}, {``0``, ``2``}, {``2``, ``0``},``                         ``{``2``, ``2``}, {``1``, ``1``}};``        ``int` `N = points.length;``        ``triangleWithNoPointInside(points, N);``    ``}``}` `// This article is contributed by vt_m. `

## Python 3

 `# Python3 program to find triangle ``# with no point inside ``import` `sys` `# method to get square of distance between ``# (x1, y1) and (x2, y2)``def` `getDistance(x1, y1, x2, y2):``    ``return` `(x2 ``-` `x1) ``*` `(x2 ``-` `x1) ``+` `\``           ``(y2 ``-` `y1) ``*` `(y2 ``-` `y1)` `# Method prints points which make triangle ``# with no point inside``def` `triangleWithNoPointInside(points, N):``    ` `    ``# any point can be chosen as ``    ``# first point of triangle``    ``first ``=` `0``    ``second ``=` `0``    ``third ``=` `0``    ``minD ``=` `sys.maxsize` `    ``# choose nearest point as ``    ``# second point of triangle``    ``for` `i ``in` `range``(``0``, N):``        ``if` `i ``=``=` `first:``            ``continue` `        ``# Get distance from first point and choose ``        ``# nearest one``        ``d ``=` `getDistance(points[i][``0``], points[i][``1``],``                        ``points[first][``0``], ``                        ``points[first][``1``])``        ``if` `minD > d:``            ``minD ``=` `d``            ``second ``=` `i``    ` `    ``# Pick third point by finding the second closest ``    ``# point with different slope.``    ``minD ``=` `sys.maxsize``    ``for` `i ``in` `range` `(``0``, N):``        ` `        ``# if already chosen point then skip them ``        ``if` `i ``=``=` `first ``or` `i ``=``=` `second:``            ``continue` `        ``# get distance from first point``        ``d ``=` `getDistance(points[i][``0``], points[i][``1``],``                        ``points[first][``0``], ``                        ``points[first][``1``])` `        ``""" the slope of the third point with the first ``            ``point should not be equal to the slope of ``            ``second point with first point (otherwise ``            ``they'll be collinear) and among all such ``            ``points, we choose point with the smallest ``            ``distance """``            ` `        ``# here cross multiplication is compared instead ``        ``# of division comparison``        ``if` `((points[i][``0``] ``-` `points[first][``0``]) ``*``            ``(points[second][``1``] ``-` `points[first][``1``]) !``=``            ``(points[second][``0``] ``-` `points[first][``0``]) ``*``            ``(points[i][``1``] ``-` `points[first][``1``])``            ``and` `minD > d) :``            ``minD ``=` `d``            ``third ``=` `i` `    ``print``(points[first][``0``], ``', '``, points[first][``1``])``    ``print``(points[second][``0``], ``', '``, points[second][``1``])``    ``print``(points[third][``0``], ``', '``, points[third][``1``])` `# Driver code``points ``=` `[[``0``, ``0``], [``0``, ``2``], ``          ``[``2``, ``0``], [``2``, ``2``], [``1``, ``1``]]``N ``=` `len``(points)``triangleWithNoPointInside(points, N)` `# This code is contributed by Gowtham Yuvaraj`

## C#

 `using` `System;` `// C# program to find triangle ``// with no point inside ` `public` `class` `GFG``{``    ``// method to get square of distance between ``    ``// (x1, y1) and (x2, y2) ``    ``public` `static` `int` `getDistance(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2)``    ``{``        ``return` `(x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);``    ``}` `    ``// Method prints points which make triangle with no ``    ``// point inside ``    ``public` `static` `void` `triangleWithNoPointInside(``int``[][] points, ``int` `N)``    ``{``        ``// any point can be chosen as first point of triangle ``        ``int` `first = 0;``        ``int` `second = 0;``        ``int` `third = 0;``        ``int` `minD = ``int``.MaxValue;` `        ``// choose nearest point as second point of triangle ``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``if` `(i == first)``            ``{``                ``continue``;``            ``}` `            ``// Get distance from first point and choose ``            ``// nearest one ``            ``int` `d = getDistance(points[i][0], points[i][1], points[first][0], points[first][1]);``            ``if` `(minD > d)``            ``{``                ``minD = d;``                ``second = i;``            ``}``        ``}` `        ``// Pick third point by finding the second closest ``        ``// point with different slope. ``        ``minD = ``int``.MaxValue;``        ``for` `(``int` `i = 0; i < N; i++)``        ``{``            ``// if already chosen point then skip them ``            ``if` `(i == first || i == second)``            ``{``                ``continue``;``            ``}` `            ``// get distance from first point ``            ``int` `d = getDistance(points[i][0], points[i][1], points[first][0], points[first][1]);` `            ``/* the slope of the third point with the first ``                ``point should not be equal to the slope of ``                ``second point with first point (otherwise ``                ``they'll be collinear) and among all such ``                ``points, we choose point with the smallest ``                ``distance */``            ``// here cross multiplication is compared instead ``            ``// of division comparison ``            ``if` `((points[i][0] - points[first][0]) * (points[second][1] - points[first][1]) != (points[second][0] - points[first][0]) * (points[i][1] - points[first][1]) && minD > d)``            ``{``                ``minD = d;``                ``third = i;``            ``}``        ``}` `        ``Console.WriteLine(points[first][0] + ``", "` `+ points[first][1]);``        ``Console.WriteLine(points[second][0] + ``", "` `+ points[second][1]);``        ``Console.WriteLine(points[third][0] + ``", "` `+ points[third][1]);``    ``}` `    ``// Driver code  ``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[][] points = ``new` `int``[][]``        ``{``            ``new` `int``[] {0, 0},``            ``new` `int``[] {0, 2},``            ``new` `int``[] {2, 0},``            ``new` `int``[] {2, 2},``            ``new` `int``[] {1, 1}``        ``};``        ``int` `N = points.Length;``        ``triangleWithNoPointInside(points, N);``    ``}``}` `  ``// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`0, 01, 10, 2`

Time complexity: O(n)

Auxiliary Space: O(1)

#### Approach#2: Using Brute Force

This code iterates over all possible triangles that can be formed from the given set of points, and checks whether any other point lies inside each triangle. If a triangle is found where no point lies inside, the code returns the triangle. Otherwise, it returns None.

#### Algorithm

1. Iterate through all possible triangles with vertices from the given points.
2. For each triangle, check if any of the remaining points lie inside the triangle.
3. If no points lie inside any triangle, return the coordinates of the first triangle found.

## C++

 `#include ``#include ``#include ` `using` `namespace` `std;` `// Function to calculate the area of a triangle given its three vertices``double` `area(``double` `x1, ``double` `y1, ``double` `x2, ``double` `y2, ``double` `x3, ``double` `y3) {``    ``return` `abs``((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);``}` `// Function to check if a point (x, y) is inside a triangle defined by its vertices (x1, y1), (x2, y2), and (x3, y3)``bool` `isInsideTriangle(``double` `x1, ``double` `y1, ``double` `x2, ``double` `y2, ``double` `x3, ``double` `y3, ``double` `x, ``double` `y) {``    ``double` `A = area(x1, y1, x2, y2, x3, y3);``    ``double` `A1 = area(x, y, x2, y2, x3, y3);``    ``double` `A2 = area(x1, y1, x, y, x3, y3);``    ``double` `A3 = area(x1, y1, x2, y2, x, y);``    ` `    ``return` `abs``(A - (A1 + A2 + A3)) < 1e-9; ``// Use a small epsilon value for comparison due to floating-point precision``}` `// Function to find three points from a list that do not form a triangle with any other point inside``vector> noPointInsideTriangle(vector> points) {``    ``for` `(``int` `i = 0; i < points.size(); ++i) {``        ``for` `(``int` `j = i + 1; j < points.size(); ++j) {``            ``for` `(``int` `k = j + 1; k < points.size(); ++k) {``                ``bool` `inside = ``false``;``                ``for` `(``int` `l = 0; l < points.size(); ++l) {``                    ``if` `(l != i && l != j && l != k) {``                        ``if` `(isInsideTriangle(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1], points[l][0], points[l][1])) {``                            ``inside = ``true``;``                            ``break``;``                        ``}``                    ``}``                ``}``                ``if` `(!inside) {``                    ``vector> result = {points[i], points[j], points[k]};``                    ``return` `result;``                ``}``            ``}``        ``}``    ``}``    ``return` `vector>(); ``// Return an empty vector if no such set of points is found``}` `int` `main() {``    ``vector> points = {{0, 0}, {0, 2}, {2, 0}, {2, 2}, {1, 1}};``    ``vector> result = noPointInsideTriangle(points);``    ` `    ``if` `(!result.empty()) {``        ``cout << ``"Points that do not form a triangle with any other point inside:"` `<< endl;``        ``for` `(``const` `auto``& point : result) {``            ``cout << ``"("` `<< point[0] << ``", "` `<< point[1] << ``")"` `<< endl;``        ``}``    ``} ``else` `{``        ``cout << ``"No such set of points found."` `<< endl;``    ``}` `    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;``import` `java.util.List;` `public` `class` `Main {``    ` `    ``static` `double` `area(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2, ``int` `x3, ``int` `y3) {``        ``return` `Math.abs((x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2))/``2.0``);``    ``}` `    ``static` `boolean` `isInsideTriangle(``int` `x1, ``int` `y1, ``int` `x2, ``int` `y2, ``int` `x3, ``int` `y3, ``int` `x, ``int` `y) {``        ``double` `A = area(x1, y1, x2, y2, x3, y3);``        ``double` `A1 = area(x, y, x2, y2, x3, y3);``        ``double` `A2 = area(x1, y1, x, y, x3, y3);``        ``double` `A3 = area(x1, y1, x2, y2, x, y);``        ``return` `A == A1 + A2 + A3;``    ``}` `    ``static` `List> noPointInsideTriangle(List> points) {``        ``for` `(``int` `i = ``0``; i < points.size(); i++) {``            ``for` `(``int` `j = i+``1``; j < points.size(); j++) {``                ``for` `(``int` `k = j+``1``; k < points.size(); k++) {``                    ``boolean` `inside = ``false``;``                    ``for` `(``int` `l = ``0``; l < points.size(); l++) {``                        ``if` `(l != i && l != j && l != k) {``                            ``if` `(isInsideTriangle(points.get(i).get(``0``), points.get(i).get(``1``), points.get(j).get(``0``), points.get(j).get(``1``), points.get(k).get(``0``), points.get(k).get(``1``), points.get(l).get(``0``), points.get(l).get(``1``))) {``                                ``inside = ``true``;``                                ``break``;``                            ``}``                        ``}``                    ``}``                    ``if` `(!inside) {``                        ``List> result = ``new` `ArrayList<>();``                        ``result.add(points.get(i));``                        ``result.add(points.get(j));``                        ``result.add(points.get(k));``                        ``return` `result;``                    ``}``                ``}``            ``}``        ``}``        ``return` `null``;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``List> points = ``new` `ArrayList<>();``        ``points.add(``new` `ArrayList(){{add(``0``); add(``0``);}});``        ``points.add(``new` `ArrayList(){{add(``0``); add(``2``);}});``        ``points.add(``new` `ArrayList(){{add(``2``); add(``0``);}});``        ``points.add(``new` `ArrayList(){{add(``2``); add(``2``);}});``        ``points.add(``new` `ArrayList(){{add(``1``); add(``1``);}});``        ``List> result = noPointInsideTriangle(points);``        ``if` `(result != ``null``) {``            ``System.out.println(result);``        ``} ``else` `{``            ``System.out.println(``"No triangle found."``);``        ``}``    ``}``}`

## Python3

 `def` `area(x1, y1, x2, y2, x3, y3):``    ``return` `abs``((x1``*``(y2``-``y3) ``+` `x2``*``(y3``-``y1) ``+` `x3``*``(y1``-``y2))``/``2.0``)` `def` `is_inside_triangle(x1, y1, x2, y2, x3, y3, x, y):``    ``A ``=` `area(x1, y1, x2, y2, x3, y3)``    ``A1 ``=` `area(x, y, x2, y2, x3, y3)``    ``A2 ``=` `area(x1, y1, x, y, x3, y3)``    ``A3 ``=` `area(x1, y1, x2, y2, x, y)``    ``return` `A ``=``=` `A1 ``+` `A2 ``+` `A3` `def` `no_point_inside_triangle(points):``    ``for` `i ``in` `range``(``len``(points)):``        ``for` `j ``in` `range``(i``+``1``, ``len``(points)):``            ``for` `k ``in` `range``(j``+``1``, ``len``(points)):``                ``inside ``=` `False``                ``for` `l ``in` `range``(``len``(points)):``                    ``if` `l !``=` `i ``and` `l !``=` `j ``and` `l !``=` `k:``                        ``if` `is_inside_triangle(points[i][``0``], points[i][``1``], points[j][``0``], points[j][``1``], points[k][``0``], points[k][``1``], points[l][``0``], points[l][``1``]):``                            ``inside ``=` `True``                            ``break``                ``if` `not` `inside:``                    ``return` `[points[i], points[j], points[k]]``    ``return` `None` `# Example usage``points ``=` `[[``0``, ``0``], [``0``, ``2``], [``2``, ``0``], [``2``, ``2``], [``1``, ``1``]]``print``(no_point_inside_triangle(points))`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program``{``    ``// Function to calculate the area of a triangle given its three vertices``    ``static` `double` `Area(``double` `x1, ``double` `y1, ``double` `x2, ``double` `y2, ``double` `x3, ``double` `y3)``    ``{``        ``return` `Math.Abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);``    ``}` `    ``// Function to check if a point (x, y) is inside a triangle defined by its vertices (x1, y1), (x2, y2), and (x3, y3)``    ``static` `bool` `IsInsideTriangle(``double` `x1, ``double` `y1, ``double` `x2, ``double` `y2, ``double` `x3, ``double` `y3, ``double` `x, ``double` `y)``    ``{``        ``double` `A = Area(x1, y1, x2, y2, x3, y3);``        ``double` `A1 = Area(x, y, x2, y2, x3, y3);``        ``double` `A2 = Area(x1, y1, x, y, x3, y3);``        ``double` `A3 = Area(x1, y1, x2, y2, x, y);` `        ``return` `Math.Abs(A - (A1 + A2 + A3)) < 1e-9; ``// Use a small epsilon value for comparison due to floating-point precision``    ``}` `    ``// Function to find three points from a list that do not form a triangle with any other point inside``    ``static` `List<``double``[]> NoPointInsideTriangle(List<``double``[]> points)``    ``{``        ``for` `(``int` `i = 0; i < points.Count; ++i)``        ``{``            ``for` `(``int` `j = i + 1; j < points.Count; ++j)``            ``{``                ``for` `(``int` `k = j + 1; k < points.Count; ++k)``                ``{``                    ``bool` `inside = ``false``;``                    ``for` `(``int` `l = 0; l < points.Count; ++l)``                    ``{``                        ``if` `(l != i && l != j && l != k)``                        ``{``                            ``if` `(IsInsideTriangle(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1], points[l][0], points[l][1]))``                            ``{``                                ``inside = ``true``;``                                ``break``;``                            ``}``                        ``}``                    ``}``                    ``if` `(!inside)``                    ``{``                        ``List<``double``[]> result = ``new` `List<``double``[]>``                        ``{``                            ``points[i],``                            ``points[j],``                            ``points[k]``                        ``};``                        ``return` `result;``                    ``}``                ``}``            ``}``        ``}``        ``return` `new` `List<``double``[]>(); ``// Return an empty list if no such set of points is found``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``List<``double``[]> points = ``new` `List<``double``[]>``        ``{``            ``new` `double``[] {0, 0},``            ``new` `double``[] {0, 2},``            ``new` `double``[] {2, 0},``            ``new` `double``[] {2, 2},``            ``new` `double``[] {1, 1}``        ``};``        ``List<``double``[]> result = NoPointInsideTriangle(points);` `        ``if` `(result.Count > 0)``        ``{``            ``Console.WriteLine(``"Points that do not form a triangle with any other point inside:"``);``            ``foreach` `(``var` `point ``in` `result)``            ``{``                ``Console.WriteLine(\$``"({point[0]}, {point[1]})"``);``            ``}``        ``}``        ``else``        ``{``            ``Console.WriteLine(``"No such set of points found."``);``        ``}``    ``}``}`

## Javascript

 `// JavaScript equivalent of the Python code above` `function` `area(x1, y1, x2, y2, x3, y3) {``return` `Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);``}` `function` `is_inside_triangle(x1, y1, x2, y2, x3, y3, x, y) {``const A = area(x1, y1, x2, y2, x3, y3);``const A1 = area(x, y, x2, y2, x3, y3);``const A2 = area(x1, y1, x, y, x3, y3);``const A3 = area(x1, y1, x2, y2, x, y);``return` `A === A1 + A2 + A3;``}` `function` `no_point_inside_triangle(points) {``for` `(let i = 0; i < points.length; i++) {``for` `(let j = i + 1; j < points.length; j++) {``for` `(let k = j + 1; k < points.length; k++) {``let inside = ``false``;``for` `(let l = 0; l < points.length; l++) {``if` `(l !== i && l !== j && l !== k) {``if` `(is_inside_triangle(points[i][0], points[i][1], points[j][0], points[j][1], points[k][0], points[k][1], points[l][0], points[l][1])) {``inside = ``true``;``break``;``}``}``}``if` `(!inside) {``return` `[points[i], points[j], points[k]];``}``}``}``}``return` `null``;``}` `// Example usage``const points = [[0, 0], [0, 2], [2, 0], [2, 2], [1, 1]];``console.log(no_point_inside_triangle(points));`

Output
```[[0, 0], [0, 2], [1, 1]]

```

Time complexity: O(n^4), where n is the number of points. This is because we need to iterate through all possible triangles, which is n choose 3, and then check if each of the remaining points lies inside the triangle, which is O(n).

Space complexity: O(1), since we only store a few variables at a time.

Previous
Next