# Pizza Problem

Given an integer N and a pizza which can be cut into pieces, each cut should be a straight line going from the center of the pizza to its border. Also, the angle between any two cuts must be a positive integer. Two pieces are equal if their appropriate angles are equal. The given pizza can be cut in following three ways:

1. Cut the pizza into N equal pieces.
2. Cut the pizza into N pieces of any size.
3. Cut the pizza into N pieces such that no two of them are equal.

The task is to find if it is possible to cut the pizza in the above ways for a given value of N. Print 1 if possible else 0 for all the cases i.e. print 111 if all the cases are possible.

Examples:

Input: N = 4
Output: 1 1 1
Explanation:
Case 1: All four pieces can have angle = 90
Case 2: Same cut as Case 1
Case 3: 1, 2, 3 and 354 are the respective angles of the four pieces cut.

Input: N = 7
Output: 0 1 1

Approach:

• Case 1 will only be possible if 360 is divisible by N.
• For case 2 to be possible, N must be ? 360.
• An ideal solution for case 3 would be to choose pieces in such a way that the angles they form are 1, 2, 3, … respectively. So, in order for this case to be possible, (N * (N + 1)) / 2 must be ? 360.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to check if it is possible ` `// to cut the pizza in the given way ` `void` `cutPizza(``int` `n) ` `{ ` `    ``// Case 1 ` `    ``cout << (360 % n == 0) ? ``"1"` `: ``"0"``; ` ` `  `    ``// Case 2 ` `    ``cout << (n <= 360) ? ``"1"` `: ``"0"``; ` ` `  `    ``// Case 3 ` `    ``cout << (((n * (n + 1)) / 2) <= 360) ? ``"1"` `: ``"0"``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 7; ` `    ``cutPizza(n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GFG ` `{ ` ` `  `// Function to check if it is possible  ` `// to cut the pizza in the given way  ` `static` `void` `cutPizza(``int` `n)  ` `{  ` `    ``// Case 1  ` `    ``System.out.print( (``360` `% n == ``0``) ? ``"1"` `: ``"0"``);  ` ` `  `    ``// Case 2  ` `    ``System.out.print( (n <= ``360``) ? ``"1"` `: ``"0"``);  ` ` `  `    ``// Case 3  ` `    ``System.out.print( (((n * (n + ``1``)) / ``2``) <= ``360``) ? ``"1"` `: ``"0"``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``int` `n = ``7``;  ` `    ``cutPizza(n);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to check if it is possible ` `# to cut the pizza in the given way ` `def` `cutPizza(n): ` ` `  `    ``# Case 1 ` `    ``if``(``360` `%` `n ``=``=` `0``):  ` `        ``print``(``"1"``, end ``=` `"")  ` `    ``else``: ` `        ``print``(``"0"``, end ``=` `""); ` ` `  `    ``# Case 2 ` `    ``if``(n <``=` `360``): ` `        ``print``(``"1"``, end ``=` `"")  ` `    ``else``: ` `        ``print``(``"0"``, end ``=` `""); ` ` `  `    ``# Case 3 ` `    ``if``(((n ``*` `(n ``+` `1``)) ``/` `2``) <``=` `360``):  ` `        ``print``(``"1"``, end ``=` `"") ` `    ``else``: ` `        ``print``(``"0"``, end ``=` `""); ` ` `  ` `  `# Driver code ` `n ``=` `7``; ` `cutPizza(n); ` ` `  `# This code is contributed ` `# by Akanksha Rai `

## C#

 `// C# implementation of the approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Function to check if it is possible  ` `// to cut the pizza in the given way  ` `static` `void` `cutPizza(``int` `n)  ` `{  ` `    ``// Case 1  ` `    ``Console.Write((360 % n == 0) ? ``"1"` `: ``"0"``);  ` ` `  `    ``// Case 2  ` `    ``Console.Write((n <= 360) ? ``"1"` `: ``"0"``);  ` ` `  `    ``// Case 3  ` `    ``Console.Write((((n * (n + 1)) / 2) <= 360) ? ``"1"` `: ``"0"``);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main(String []args) ` `{  ` `    ``int` `n = 7;  ` `    ``cutPizza(n);  ` `} ` `}  ` ` `  `// This code is contributed by Arnab Kundu `

## PHP

 ` `

## Javascript

 ` `

Output:

`011`

Time Complexity: O(1)
Auxiliary Space: O(1)