# Minimum side of square embedded in Regular polygon with N sides

Given an even number **N** which represents the number of sides of a regular polygon with **N** vertices, the task is to find the square of the minimum size such that given **Polygon** can completely embed in the square.

A Polygon is a convex figure and has equal sides and equal angles. All sides have length

1.

**Embedding:** Place **Polygon** in the square in such way that each point which lies inside or on a border of **N** should also lie inside or on a border of the square.**Examples:**

Input:N = 4Output:1Explanation:

Regular polygon with 4 Sides is square with side 1.

Given polygon can easily embed on the square with side 1.Input:N = 6Output:1.931851653Explanation :

Regular polygon with 6 Sides is Hexagon with side 1.

Given polygon can easily embed on the square with side 1.931851653.

**Approach:** The idea is to observe that on a 3-D plane, when a polygon is embedded in a square, it might be rotated. A similar approach has been discussed in Hexagon problem and Octagon problem . Therefore, we take the projection of each side on both the axis using the mathematical functions *sin()* and *cos()*. The overall sum of all the projections is the minimum side of the square required in this problem.

Below is the implementation of the above approach:

## C++

`// C++ program to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// PI value in C++ using` `// acos function` `const` `double` `pi = ` `acos` `(-1.0);` `// Function to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `double` `nGon(` `int` `N)` `{` ` ` `// Projection angle variation` ` ` `// from axes` ` ` `double` `proAngleVar;` ` ` `// Projection angle variation` ` ` `// when the number of` ` ` `// sides are in multiple of 4` ` ` `if` `(N % 4 == 0) {` ` ` `proAngleVar` ` ` `= pi * (180.0 / N)` ` ` `/ 180;` ` ` `}` ` ` `else` `{` ` ` `proAngleVar` ` ` `= pi * (180.0 / (2 * N))` ` ` `/ 180;` ` ` `}` ` ` `// Distance between the end points` ` ` `double` `negX = 1.0e+99,` ` ` `posX = -1.0e+99,` ` ` `negY = 1.0e+99,` ` ` `posY = -1.0e+99;` ` ` `for` `(` `int` `j = 0; j < N; ++j) {` ` ` `// Projection from all N points` ` ` `// on X-axis` ` ` `double` `px = ` `cos` `(2 * pi * j / N` ` ` `+ proAngleVar);` ` ` `// Projection from all N points` ` ` `// on Y-axis` ` ` `double` `py = ` `sin` `(2 * pi * j / N` ` ` `+ proAngleVar);` ` ` `negX = min(negX, px);` ` ` `posX = max(posX, px);` ` ` `negY = min(negY, py);` ` ` `posY = max(posY, py);` ` ` `}` ` ` `// Maximum side` ` ` `double` `opt2 = max(posX - negX,` ` ` `posY - negY);` ` ` `// Return the portion of side` ` ` `// forming the square` ` ` `return` `(` `double` `)opt2` ` ` `/ ` `sin` `(pi / N) / 2;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `N = 10;` ` ` `cout << nGon(N);` ` ` `return` `0;` `}` |

## Java

`// Java program to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `class` `GFG{` `// PI value in Java using` `// acos function` `static` `double` `pi = Math.acos(-` `1.0` `);` `// Function to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `static` `double` `nGon(` `int` `N)` `{` ` ` `// Projection angle variation` ` ` `// from axes` ` ` `double` `proAngleVar;` ` ` `// Projection angle variation` ` ` `// when the number of` ` ` `// sides are in multiple of 4` ` ` `if` `(N % ` `4` `== ` `0` `)` ` ` `{` ` ` `proAngleVar = pi * (` `180.0` `/ N) / ` `180` `;` ` ` `}` ` ` `else` ` ` `{` ` ` `proAngleVar = pi * (` `180.0` `/ (` `2` `* N)) / ` `180` `;` ` ` `}` ` ` `// Distance between the end points` ` ` `double` `negX = ` `1` `.0e+` `99` `,` ` ` `posX = -` `1` `.0e+` `99` `,` ` ` `negY = ` `1` `.0e+` `99` `,` ` ` `posY = -` `1` `.0e+` `99` `;` ` ` `for` `(` `int` `j = ` `0` `; j < N; ++j)` ` ` `{` ` ` `// Projection from all N points` ` ` `// on X-axis` ` ` `double` `px = Math.cos(` `2` `* pi * j / N +` ` ` `proAngleVar);` ` ` `// Projection from all N points` ` ` `// on Y-axis` ` ` `double` `py = Math.sin(` `2` `* pi * j / N +` ` ` `proAngleVar);` ` ` `negX = Math.min(negX, px);` ` ` `posX = Math.max(posX, px);` ` ` `negY = Math.min(negY, py);` ` ` `posY = Math.max(posY, py);` ` ` `}` ` ` `// Maximum side` ` ` `double` `opt2 = Math.max(posX - negX,` ` ` `posY - negY);` ` ` `// Return the portion of side` ` ` `// forming the square` ` ` `return` `(` `double` `)opt2 /` ` ` `Math.sin(pi / N) / ` `2` `;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `10` `;` ` ` `System.out.printf(` `"%.5f"` `,nGon(N));` `}` `}` `// This code is contributed by 29AjayKumar` |

## Python3

`# Python 3 program to find the minimum` `# side of the square in which` `# a regular polygon with even sides` `# can completely embed` `import` `math` `# PI value in Python 3 using` `# acos function` `pi ` `=` `math.acos(` `-` `1.0` `)` `# Function to find the minimum` `# side of the square in which` `# a regular polygon with even sides` `# can completely embed` `def` `nGon(N):` ` ` `# Projection angle variation` ` ` `# from axes` ` ` `proAngleVar ` `=` `0` ` ` `# Projection angle variation` ` ` `# when the number of` ` ` `# sides are in multiple of 4` ` ` `if` `(N ` `%` `4` `=` `=` `0` `):` ` ` `proAngleVar ` `=` `(pi ` `*` `(` `180.0` `/` `N)` ` ` `/` `180` `)` ` ` `else` `:` ` ` `proAngleVar ` `=` `(pi ` `*` `(` `180.0` `/` `(` `2` `*` `N))` ` ` `/` `180` `)` ` ` `# Distance between the end points` ` ` `negX ` `=` `1.0e` `+` `99` ` ` `posX ` `=` `-` `1.0e` `+` `99` ` ` `negY ` `=` `1.0e` `+` `99` ` ` `posY ` `=` `-` `1.0e` `+` `99` ` ` `for` `j ` `in` `range` `(N):` ` ` `# Projection from all N points` ` ` `# on X-axis` ` ` `px ` `=` `math.cos(` `2` `*` `pi ` `*` `j ` `/` `N` ` ` `+` `proAngleVar)` ` ` `# Projection from all N points` ` ` `# on Y-axis` ` ` `py ` `=` `math.sin(` `2` `*` `pi ` `*` `j ` `/` `N` ` ` `+` `proAngleVar)` ` ` `negX ` `=` `min` `(negX, px)` ` ` `posX ` `=` `max` `(posX, px)` ` ` `negY ` `=` `min` `(negY, py)` ` ` `posY ` `=` `max` `(posY, py)` ` ` `# Maximum side` ` ` `opt2 ` `=` `max` `(posX ` `-` `negX,` ` ` `posY ` `-` `negY)` ` ` `# Return the portion of side` ` ` `# forming the square` ` ` `return` `(opt2 ` `/` `math.sin(pi ` `/` `N) ` `/` `2` `)` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N ` `=` `10` ` ` `print` `(` `'%.5f'` `%` `nGon(N))` ` ` `# This code is contributed by ukasp.` |

## C#

`// C# program to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `using` `System;` `class` `GFG{` `// PI value in Java using` `// acos function` `static` `double` `pi = Math.Acos(-1.0);` `// Function to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` `static` `double` `nGon(` `int` `N)` `{` ` ` `// Projection angle variation` ` ` `// from axes` ` ` `double` `proAngleVar;` ` ` `// Projection angle variation` ` ` `// when the number of` ` ` `// sides are in multiple of 4` ` ` `if` `(N % 4 == 0)` ` ` `{` ` ` `proAngleVar = pi * (180.0 / N) / 180;` ` ` `}` ` ` `else` ` ` `{` ` ` `proAngleVar = pi * (180.0 / (2 * N)) / 180;` ` ` `}` ` ` `// Distance between the end points` ` ` `double` `negX = 1.0e+99,` ` ` `posX = -1.0e+99,` ` ` `negY = 1.0e+99,` ` ` `posY = -1.0e+99;` ` ` `for` `(` `int` `j = 0; j < N; ++j)` ` ` `{` ` ` `// Projection from all N points` ` ` `// on X-axis` ` ` `double` `px = Math.Cos(2 * pi * j / N +` ` ` `proAngleVar);` ` ` `// Projection from all N points` ` ` `// on Y-axis` ` ` `double` `py = Math.Sin(2 * pi * j / N +` ` ` `proAngleVar);` ` ` `negX = Math.Min(negX, px);` ` ` `posX = Math.Max(posX, px);` ` ` `negY = Math.Min(negY, py);` ` ` `posY = Math.Max(posY, py);` ` ` `}` ` ` `// Maximum side` ` ` `double` `opt2 = Math.Max(posX - negX,` ` ` `posY - negY);` ` ` `// Return the portion of side` ` ` `// forming the square` ` ` `return` `(` `double` `)opt2 /` ` ` `Math.Sin(pi / N) / 2;` `}` `// Driver code` `public` `static` `void` `Main()` `{` ` ` `int` `N = 10;` ` ` `Console.Write(` `string` `.Format(` `"{0:F5}"` `, nGon(N)));` `}` `}` `// This code is contributed by Nidhi_biet` |

## Javascript

`<script>` `// Javascript program to find the minimum` `// side of the square in which` `// a regular polygon with even sides` `// can completely embed` ` ` `// PI value in Java using` ` ` `// acos function` ` ` `let pi = Math.acos(-1.0);` ` ` `// Function to find the minimum` ` ` `// side of the square in which` ` ` `// a regular polygon with even sides` ` ` `// can completely embed` ` ` `function` `nGon( N) {` ` ` `// Projection angle variation` ` ` `// from axes` ` ` `let proAngleVar;` ` ` `// Projection angle variation` ` ` `// when the number of` ` ` `// sides are in multiple of 4` ` ` `if` `(N % 4 == 0) {` ` ` `proAngleVar = pi * (180.0 / N) / 180;` ` ` `} ` `else` `{` ` ` `proAngleVar = pi * (180.0 / (2 * N)) / 180;` ` ` `}` ` ` `// Distance between the end polets` ` ` `let negX = 1.0e+99, posX = -1.0e+99, negY = 1.0e+99, posY = -1.0e+99;` ` ` `for` `( let j = 0; j < N; ++j) {` ` ` `// Projection from all N polets` ` ` `// on X-axis` ` ` `let px = Math.cos(2 * pi * j / N + proAngleVar);` ` ` `// Projection from all N polets` ` ` `// on Y-axis` ` ` `let py = Math.sin(2 * pi * j / N + proAngleVar);` ` ` `negX = Math.min(negX, px);` ` ` `posX = Math.max(posX, px);` ` ` `negY = Math.min(negY, py);` ` ` `posY = Math.max(posY, py);` ` ` `}` ` ` `// Maximum side` ` ` `let opt2 = Math.max(posX - negX, posY - negY);` ` ` `// Return the portion of side` ` ` `// forming the square` ` ` `return` `opt2 / Math.sin(pi / N) / 2;` ` ` `}` ` ` `// Driver code` ` ` `let N = 10;` ` ` `document.write(nGon(N).toFixed(5));` `// This code is contributed by Princi Singh` `</script>` |

**Output:**

3.19623

**Time Complexity:** *O(N)*, where N is number of sides of polygon.

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**.