Open In App

Minimum side of square embedded in Regular polygon with N sides

Improve
Improve
Like Article
Like
Save
Share
Report

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 = 4 
Output:
Explanation: 
Regular polygon with 4 Sides is square with side 1. 
Given polygon can easily embed on the square with side 1. 

Input: N = 6 
Output: 1.931851653 
Explanation : 
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 points
        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 points
            // on X-axis
            let px = Math.cos(2 * pi * j / N + proAngleVar);
 
            // Projection from all N points
            // 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 the number of sides of the polygon.
Auxiliary Space: O(1) 



Last Updated : 25 Oct, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads