# Regular polygon using only 1s in a binary numbered circle

Given an array of binary integers, suppose these values are kept on the circumference of a circle at an equal distance. We need to tell whether is it possible to draw a regular polygon using only 1s as its vertices and if it is possible then print the maximum number of sides that regular polygon has.

```Input : arr[] = [1, 1, 1, 0, 1, 0]
Output : Polygon possible with side length 3
We can draw a regular triangle having 1s as
its vertices as shown in below diagram (a).

Input : arr[] = [1, 0, 1, 0, 1, 0, 1, 0, 1, 1]
Output : Polygon possible with side length 5
We can draw a regular pentagon having 1s as its
vertices as shown in below diagram (b).

```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

We can solve this problem by getting a relation between the number of vertices a possible polygon can have and total number of values in the array. Let a possible regular polygon in circle has K vertices or K sides then it should satisfy two things to be the answer,
If given array size is N, then K should divide N otherwise K vertices can’t divide N vertices in an equally manner to be a regular polygon.
Next thing is there should be one at every vertex of chosen polygon.
After above points, we can see that for solving this problem we need to iterate over divisors of N and then check whether every value of the array at chosen divisor’s distance is 1 or not. If it is 1 then we found our solution. We can iterate over all divisors in O(sqrt(N)) time just by iterating over from 1 to sqrt(N). you can read more about that here.

## C++

```// C++ program to find whether a regular polygon
// is possible in circle with 1s as vertices
#include <bits/stdc++.h>
using namespace std;

// method returns true if polygon is possible with
// 'midpoints' number of midpoints
bool checkPolygonWithMidpoints(int arr[], int N,
int midpoints)
{
// loop for getting first vertex of polygon
for (int j = 0; j < midpoints; j++)
{
int val = 1;

// loop over array values at 'midpoints' distance
for (int k = j; k < N; k += midpoints)
{
// and(&) all those values, if even one of
// them is 0, val will be 0
val &= arr[k];
}

/*  if val is still 1 and (N/midpoints) or (number
of vertices) are more than two (for a polygon
minimum) print result and return true */
if (val && N/midpoints > 2)
{
cout << "Polygon possible with side length " <<
<< (N/midpoints) << endl;
return true;
}
}
return false;
}

// method prints sides in the polygon or print not
// possible in case of no possible polygon
void isPolygonPossible(int arr[], int N)
{
//  limit for iterating over divisors
int limit = sqrt(N);
for (int i = 1; i <= limit; i++)
{
// If i divides N then i and (N/i) will
// be divisors
if (N % i == 0)
{
//  check polygon for both divisors
if (checkPolygonWithMidpoints(arr, N, i) ||
checkPolygonWithMidpoints(arr, N, (N/i)))
return;
}
}

cout << "Not possiblen";
}

// Driver code to test above methods
int main()
{
int arr[] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 1};
int N = sizeof(arr) / sizeof(arr[0]);
isPolygonPossible(arr, N);
return 0;
}
```

## Java

```// Java program to find whether a regular polygon
// is possible in circle with 1s as vertices

class Test
{
// method returns true if polygon is possible with
// 'midpoints' number of midpoints
static boolean checkPolygonWithMidpoints(int arr[], int N,
int midpoints)
{
// loop for getting first vertex of polygon
for (int j = 0; j < midpoints; j++)
{
int val = 1;

// loop over array values at 'midpoints' distance
for (int k = j; k < N; k += midpoints)
{
// and(&) all those values, if even one of
// them is 0, val will be 0
val &= arr[k];
}

/*  if val is still 1 and (N/midpoints) or (number
of vertices) are more than two (for a polygon
minimum) print result and return true */
if (val != 0 && N/midpoints > 2)
{
System.out.println("Polygon possible with side length " +
N/midpoints);
return true;
}
}
return false;
}

// method prints sides in the polygon or print not
// possible in case of no possible polygon
static void isPolygonPossible(int arr[], int N)
{
//  limit for iterating over divisors
int limit = (int)Math.sqrt(N);
for (int i = 1; i <= limit; i++)
{
// If i divides N then i and (N/i) will
// be divisors
if (N % i == 0)
{
//  check polygon for both divisors
if (checkPolygonWithMidpoints(arr, N, i) ||
checkPolygonWithMidpoints(arr, N, (N/i)))
return;
}
}

System.out.println("Not possible");
}

// Driver method
public static void main(String args[])
{
int arr[] = {1, 0, 1, 0, 1, 0, 1, 0, 1, 1};

isPolygonPossible(arr, arr.length);
}
}
```

Output:

```Polygon possible with side length 5
```

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
0 Average Difficulty : 0/5.0