Given an n-sided regular polygon and an angle ?, the task is to find number of occurrences of angle ( Ai, Aj, Ak ) = ? ( i < j < k) in a regular n-gon (regular polygon with n vertices) with vertices marked as A1, A2, …, An.
Examples:
Input: n = 4, ang = 90 Output: 4 Input: n = 6, ang = 50 Output: 0
Approach:
- First we check whether such an angle can exist or not.
- Consider the vertices to be x, y, and z and the angle to find be ? xyz.
- The number of edges between x and y be a and the number of edges between y and z be b.
- Then ? xyz = 180 – (180*(a+b)) / n.
- Thus ? xyz * n (mod 180) = 0.
- Next we need to find the count of such angles.
- As the polygon is regular we just need to calculate the count of such an angle at one vertex and can directly multiply our result by n (the number of vertices).
- At each vertex the angle can be found at n-1-freq times where freq = (n*ang)/180 and depicts the number of edges remaining after creating the required angle i.e. the number of edges between z and x.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function that calculates occurrences // of given angle that can be created // using any 3 sides int solve( int ang, int n)
{ // Maximum angle in a regular n-gon
// is equal to the interior angle
// If the given angle
// is greater than the interior angle
// then the given angle cannot be created
if ((ang * n) > (180 * (n - 2))) {
return 0;
}
// The given angle times n should be divisible
// by 180 else it cannot be created
else if ((ang * n) % 180 != 0) {
return 0;
}
// Initialise answer
int ans = 1;
// Calculate the frequency
// of given angle for each vertex
int freq = (ang * n) / 180;
// Multiply answer by frequency.
ans = ans * (n - 1 - freq);
// Multiply answer by the number of vertices.
ans = ans * n;
return ans;
} // Driver code int main()
{ int ang = 90, n = 4;
cout << solve(ang, n);
return 0;
} |
Java
// Java implementation of the approach class GFG
{ // Function that calculates occurrences // of given angle that can be created // using any 3 sides static int solve( int ang, int n)
{ // Maximum angle in a regular n-gon
// is equal to the interior angle
// If the given angle
// is greater than the interior angle
// then the given angle cannot be created
if ((ang * n) > ( 180 * (n - 2 )))
{
return 0 ;
}
// The given angle times n should be divisible
// by 180 else it cannot be created
else if ((ang * n) % 180 != 0 )
{
return 0 ;
}
// Initialise answer
int ans = 1 ;
// Calculate the frequency
// of given angle for each vertex
int freq = (ang * n) / 180 ;
// Multiply answer by frequency.
ans = ans * (n - 1 - freq);
// Multiply answer by the number of vertices.
ans = ans * n;
return ans;
} // Driver code public static void main (String[] args)
{ int ang = 90 , n = 4 ;
System.out.println(solve(ang, n));
} } // This code is contributed by Rajput-Ji |
Python3
# Python3 implementation of the approach # Function that calculates occurrences # of given angle that can be created # using any 3 sides def solve(ang, n):
# Maximum angle in a regular n-gon
# is equal to the interior angle
# If the given angle
# is greater than the interior angle
# then the given angle cannot be created
if ((ang * n) > ( 180 * (n - 2 ))):
return 0
# The given angle times n should be divisible
# by 180 else it cannot be created
elif ((ang * n) % 180 ! = 0 ):
return 0
# Initialise answer
ans = 1
# Calculate the frequency
# of given angle for each vertex
freq = (ang * n) / / 180
# Multiply answer by frequency.
ans = ans * (n - 1 - freq)
# Multiply answer by the number of vertices.
ans = ans * n
return ans
# Driver code ang = 90
n = 4
print (solve(ang, n))
# This code is contributed by Mohit Kumar |
C#
// C# implementation of the approach using System;
class GFG
{ // Function that calculates occurrences // of given angle that can be created // using any 3 sides static int solve( int ang, int n)
{ // Maximum angle in a regular n-gon
// is equal to the interior angle
// If the given angle
// is greater than the interior angle
// then the given angle cannot be created
if ((ang * n) > (180 * (n - 2)))
{
return 0;
}
// The given angle times n should be divisible
// by 180 else it cannot be created
else if ((ang * n) % 180 != 0)
{
return 0;
}
// Initialise answer
int ans = 1;
// Calculate the frequency
// of given angle for each vertex
int freq = (ang * n) / 180;
// Multiply answer by frequency.
ans = ans * (n - 1 - freq);
// Multiply answer by the
// number of vertices.
ans = ans * n;
return ans;
} // Driver code public static void Main (String[] args)
{ int ang = 90, n = 4;
Console.WriteLine(solve(ang, n));
} } // This code is contributed by Princi Singh |
Javascript
<script> // JavaScript implementation of the approach // Function that calculates occurrences // of given angle that can be created // using any 3 sides function solve(ang , n)
{ // Maximum angle in a regular n-gon
// is equal to the interior angle
// If the given angle
// is greater than the interior angle
// then the given angle cannot be created
if ((ang * n) > (180 * (n - 2)))
{
return 0;
}
// The given angle times n should be divisible
// by 180 else it cannot be created
else if ((ang * n) % 180 != 0)
{
return 0;
}
// Initialise answer
var ans = 1;
// Calculate the frequency
// of given angle for each vertex
var freq = (ang * n) / 180;
// Multiply answer by frequency.
ans = ans * (n - 1 - freq);
// Multiply answer by the number of vertices.
ans = ans * n;
return ans;
} // Driver code var ang = 90, n = 4;
document.write(solve(ang, n)); // This code contributed by shikhasingrajput </script> |
Output:
4
Time Complexity: O(1)
Auxiliary Space: O(1)
Recommended Articles