Related Articles

# Find three vertices in an N-sided regular polygon such that the angle subtended at a vertex by two other vertices is closest to A

• Last Updated : 09 Jul, 2021

Given an N-sided regular convex polygon and an angle A in degrees, the task is to find any 3 vertices i, j, and k, such that the angle subtended at vertex j by vertex i and k is closest to A

Note: Each vertex is numbered from 1 to N in an anticlockwise direction starting from any vertex.

Examples:

Input: N = 3, A = 15
Output: 2 1 3
Explanation:
The given polygon is a triangle, therefore the minimum angle that can be subtended on any vertex is equal to 30 which is closest to A and includes all the vertices of the polygon.

Input: N = 4, A = 90
Output: 2 1 4

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

• The vertices of a regular polygon lie on a circle.
• The central angle of n sided regular polygon is 360/N.
• The angle subtended on the center of the circle by vertices separated by X edges is equals to (360*X)/N.
• By the theorem, the angle subtended on the circum-circle by an arc is half of the angle subtended at the center by the same arc. Therefore, the angle subtended on a vertex by an arc formed by X edges would be equal to (180*X)/N.
• As the polygon is regular therefore the same angle can be subtended by taking any 2 vertices of edge difference equal to X.

Follow the steps below to solve the problem:

• Initialize two variables, say ans as 0 and minElement as INT_MAX to store the count of edges which subtends the angle closest to A and to store the closest angle respectively.
• Iterate over the range [1, N – 2] using the variable i and perform the following steps:
• Find the angle subtended on circum-circle by an arc formed by i edges using the above formula and store it in a variable, angle.
• Check if the absolute value of (A – angle) is less than the absolute value of (minElement – A), then update the value of i to ans and the value of angle to minElement.
• After completing the above steps, print the vertices {2, 1, 2 + ans} as the resultant vertices.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `#define ll long long``#define MAXN 1000000` `// Function to find three vertices that``// subtends an angle closest to A``void` `closestsAngle(``int` `N, ``int` `A)``{``    ``// Stores the closest angle to A``    ``double` `mi = INT_MAX;` `    ``// Stores the count of edge which``    ``// subtend an angle of A``    ``int` `ans = 0;` `    ``// Iterate in the range [1, N-2]``    ``for` `(``int` `i = 1; i < N - 1; i++) {` `        ``// Stores the angle subtended``        ``double` `angle = 180.0 * i / N;` `        ``// If absolute(angle-A) is less``        ``// than absolute(mi-A)``        ``if` `(``fabs``(angle - A) < ``fabs``(mi - A)) {` `            ``// Update angle to mi, and``            ``// also update i to ans``            ``mi = angle;``            ``ans = i;``        ``}``    ``}` `    ``// Print the vertices``    ``cout << 2 << ``' '` `<< 1 << ``' '``         ``<< 2 + ans;``}` `// Driver Code``int` `main()``{``    ``int` `N = 3, A = 15;``    ``closestsAngle(N, A);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function to find three vertices that``    ``// subtends an angle closest to A``    ``static` `void` `closestsAngle(``int` `N, ``int` `A)``    ``{``        ``// Stores the closest angle to A``        ``double` `mi = Integer.MAX_VALUE;` `        ``// Stores the count of edge which``        ``// subtend an angle of A``        ``int` `ans = ``0``;` `        ``// Iterate in the range [1, N-2]``        ``for` `(``int` `i = ``1``; i < N - ``1``; i++) {` `            ``// Stores the angle subtended``            ``double` `angle = ``180.0` `* i / N;` `            ``// If absolute(angle-A) is less``            ``// than absolute(mi-A)``            ``if` `(Math.abs(angle - A) < Math.abs(mi - A)) {` `                ``// Update angle to mi, and``                ``// also update i to ans``                ``mi = angle;``                ``ans = i;``            ``}``        ``}` `        ``// Print the vertices``        ``System.out.print(``2` `+ ``" "` `+ ``1` `+ ``" "` `+ (``2` `+ ans));``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``3``, A = ``15``;``        ``closestsAngle(N, A);``    ``}``}` `// This code is contributed by subhammahato348.`

## Python3

 `# Python program for the above approach``# Function to find three vertices that``# subtends an angle closest to A``import` `math``import` `sys``def` `closestsAngle(N, A):` `    ``# Stores the closest angle to A``    ``mi ``=` `sys.maxsize` `    ``# Stores the count of edge which``    ``# subtend an angle of A``    ``ans ``=` `0` `    ``# Iterate in the range [1, N-2]``    ``for` `i ``in` `range``(N ):` `        ``# Stores the angle subtended``        ``angle ``=` `180.0` `*` `i ``/` `N` `        ``# If absolute(angle-A) is less``        ``# than absolute(mi-A)``        ``if` `(math.fabs(angle ``-` `A) < math.fabs(mi ``-` `A)): ` `            ``# Update angle to mi, and``            ``# also update i to ans``            ``mi ``=` `angle``            ``i``+``=``1``            ``ans ``=` `i``    ` `    ``# Pr the vertices``    ``print``(``2` `, ``1` `, ``2` `+` `ans)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``     ` `    ``N ``=` `3``    ``A ``=` `15``    ``closestsAngle(N, A)` `# This code is contributed by Shivani`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to find three vertices that``// subtends an angle closest to A``static` `void` `closestsAngle(``int` `N, ``int` `A)``{``    ` `    ``// Stores the closest angle to A``    ``double` `mi = Int32.MaxValue;` `    ``// Stores the count of edge which``    ``// subtend an angle of A``    ``int` `ans = 0;` `    ``// Iterate in the range [1, N-2]``    ``for``(``int` `i = 1; i < N - 1; i++)``    ``{``        ` `        ``// Stores the angle subtended``        ``double` `angle = 180.0 * i / N;` `        ``// If absolute(angle-A) is less``        ``// than absolute(mi-A)``        ``if` `(Math.Abs(angle - A) <``            ``Math.Abs(mi - A))``        ``{``            ` `            ``// Update angle to mi, and``            ``// also update i to ans``            ``mi = angle;``            ``ans = i;``        ``}``    ``}` `    ``// Print the vertices``    ``Console.Write(2 + ``" "` `+ 1 +``                      ``" "` `+ (2 + ans));``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 3, A = 15;``    ``closestsAngle(N, A);``}``}` `// This code is contributed by subhammahato348`

## Javascript

 ``
Output:
`2 1 3`

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up