Tutorialspoint.dev

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.

Example:

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



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);
    }
}

/div>

Python3

# Python3 program to find whether a 
# regular polygon is possible in circle
# with 1s as vertices 
from math import sqrt 
  
# method returns true if polygon is 
# possible with 'midpoints' number
# of midpoints 
def checkPolygonWithMidpoints(arr, N, midpoints) :
  
    # loop for getting first vertex of polygon 
    for j in range(midpoints) :
      
        val = 1
  
        # loop over array values at 
        # 'midpoints' distance 
        for k in range(j , N, 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 and N // midpoints > 2) :
          
            print("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 
def isPolygonPossible(arr, N) :
  
    # limit for iterating over divisors 
    limit = sqrt(N)
    for i in range(1, int(limit) + 1) : 
          
        # 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) or
                checkPolygonWithMidpoints(arr, N, (N // i))):
                return
          
    print("Not possiblen")
  
# Driver code 
if __name__ == "__main__"
  
    arr = [1, 0, 1, 0, 1, 0, 1, 0, 1, 1
    N = len(arr) 
    isPolygonPossible(arr, N)
  
# This code is contributed by Ryuga

C#

// C# program to find whether 
// a regular polygon is possible
// in circle with 1s as vertices
using System;
  
class GFG
{
      
// method returns true if 
// polygon is possible 
// with 'midpoints' number
// of midpoints
static 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 != 0 && N / midpoints > 2)
        {
            Console.WriteLine("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;
        }
    }
  
    Console.WriteLine("Not possible");
}
  
// Driver Code
static public void Main ()
{
    int []arr = {1, 0, 1, 0, 1,
                 0, 1, 0, 1, 1};
  
    isPolygonPossible(arr, arr.Length);
}
}
  
// This code is contributed by jit_t

PHP

<?php
// PHP program to find whether 
// a regular polygon is possible 
// in circle with 1s as vertices
// method returns true if polygon 
// is possible with 'midpoints' 
// number of midpoints
  
function checkPolygonWithMidpoints($arr, $N
                                   $midpoints)
{
    // loop for getting first 
    // vertex of polygon
    for ($j = 0; $j < $midpoints; $j++)
    {
        $val = 1;
  
        // loop over array values 
        // at 'midpoints' distance
        for ($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)
        {
            echo "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
function isPolygonPossible($arr, $N)
{
    // limit for iterating
    // over divisors
    $limit = sqrt($N);
    for ($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;
        }
    }
  
echo "Not possiblen";
}
  
// Driver Code
$arr = array(1, 0, 1, 0, 1,
             0, 1, 0, 1, 1);
$N = sizeof($arr);
isPolygonPossible($arr, $N);
  
// This code is contributed by ajit
?>


Output:

Polygon possible with side length 5

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



This article is attributed to GeeksforGeeks.org

You Might Also Like

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter