# Number of sides of Polygon when maximum possible number of diagonals is given

• Last Updated : 09 May, 2022

Given a number K which is the maximum possible number of diagonals in any polygon, the task is to find the number of sides of that polygon.

Examples:

Input: 2
Output: 4
Explanation: A quadrilateral has 2 diagonals at max.

Input: 6
Output: -1
Explanation: No polygon has at most 6 diagonals.

Approach: This problem can be solved based on the following mathematical observation:

Intuition:

for an n-sided convex polygon, from each vertex, we can draw (n – 3) diagonals.
Following this way for n-vertices, there will be n*(n – 3) diagonals but each diagonal is calculated twice.
So the total number of diagonals become n*(n – 3)/2

Therefore:
n*(n – 3) / 2 = K
n*(n – 3) – 2 *K = 0
n2 – 3*n -2*K = 0
When this is compared with the general representation of quadratic equation (ax2 + bx + c)
a = 1, b = -3, c = -2 *K
for this equation.

Solve the equation to get the value of n which is:
n = (-b Â± âˆš(b2 – 4ac) )/ 2a

Follow the steps mentioned below to implement the idea:

• Use the formula derived above to find the value of n:
• The discriminant d = b2 – 4ac
• If d > 0: roots will be distinct and one of the positive roots will be the answer
• If  d == 0:  roots will be equal and that will be the answer
• If  d < 0:  roots will be imaginary and answer does not exist

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the roots of quadratic equation` `int` `findRoots(``int` `K)` `{` `    ``int` `a = 1;` `    ``int` `b = -3;` `    ``int` `c = -2 * K;`   `    ``// Finding discriminant` `    ``int` `d = b * b - 4 * a * c;` `    ``double` `sqrt_val = ``sqrt``(``abs``(d));`   `    ``// Root are distinct` `    ``if` `(d > 0) {` `        ``// roots of equation` `        ``double` `x1 = (-b + sqrt_val) / (2 * a);` `        ``double` `x2 = (-b - sqrt_val) / (2 * a);`   `        ``if` `((``int``)x1 == x1 && x1 > 0)` `            ``return` `(``int``(x1));` `        ``else` `if` `((``int``)x2 == x2 && x2 > 0)` `            ``return` `(``int``(x2));` `        ``else` `            ``return` `-1;` `    ``}`   `    ``// Roots are equal` `    ``else` `if` `(d == 0) {` `        ``// roots of equation` `        ``double` `x1 = (-b / (2 * a));` `        ``if` `((``int``)x1 == x1 && x1 > 0)` `            ``return` `(``int``(x1));` `        ``else` `            ``return` `-1;` `    ``}` `    ``// Root are imaginary` `    ``else` `        ``return` `-1;` `}`   `// Driver code` `int` `main()` `{` `    ``// K is number of diagonals` `    ``int` `K = 9;`   `    ``// Function call` `    ``cout << findRoots(K);` `    ``return` `0;` `}`   `// This code is contributed by Rohit Pradhan`

## Java

 `// Java program for the above approach` `import` `java.io.*;`   `class` `GFG {`   `  ``// Function to find the roots of quadratic equation` `  ``static` `double` `findRoots(``int` `K){` `    ``int` `a = ``1``;` `    ``int` `b = -``3``;` `    ``int` `c = -``2` `* K;`   `    ``// Finding discriminant` `    ``int` `d = b * b - ``4` `* a * c;` `    ``double` `sqrt_val = Math.sqrt(Math.abs(d));`   `    ``// Root are distinct` `    ``if` `(d > ``0``) {` `      ``// roots of equation` `      ``double` `x1 = (-b + sqrt_val) / (``2` `* a);` `      ``double` `x2 = (-b - sqrt_val) / (``2` `* a);`   `      ``if` `((``int``)x1 == x1 && x1 > ``0``)` `        ``return` `x1;` `      ``else` `if` `((``int``)x2 == x2 && x2 > ``0``)` `        ``return` `x2;` `      ``else` `        ``return` `-``1``;` `    ``}`   `    ``// Roots are equal` `    ``else` `if` `(d == ``0``) ` `    ``{` `      `  `      ``// roots of equation` `      ``double` `x1 = (-b / (``2` `* a));` `      ``if` `((``int``)x1 == x1 && x1 > ``0``)` `        ``return` `x1;` `      ``else` `        ``return` `-``1``;` `    ``}` `    `  `    ``// Root are imaginary` `    ``else` `      ``return` `-``1``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main (String[] args)` `  ``{` `    `  `    ``// K is number of diagonals` `    ``int` `K = ``9``;`   `    ``// Function call` `    ``System.out.println((``int``) findRoots(K));` `  ``}` `}`   `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python3 program for the above approach`   `import` `math`   `# Function to find the roots of quadratic equation` `def` `findRoots(K):` `    ``a ``=` `1` `    ``b ``=` `-``3` `    ``c ``=` `-``2` `*` `K` `    `  `    ``# Finding discriminant` `    ``d ``=` `b ``*` `b ``-` `4` `*` `a ``*` `c` `    ``sqrt_val ``=` `math.sqrt(``abs``(d))` `    `  `    ``# Root are distinct` `    ``if` `d > ``0``:` `          `  `        ``# roots of equation` `        ``x1 ``=` `(``-``b ``+` `sqrt_val)``/``(``2` `*` `a)` `        ``x2 ``=` `(``-``b ``-` `sqrt_val)``/``(``2` `*` `a)` `        `  `        ``if` `int``(x1) ``=``=` `x1 ``and` `x1 > ``0``:` `            ``return` `(``int``(x1))` `        ``elif` `int``(x2) ``=``=` `x2 ``and` `x2 > ``0``:` `            ``return` `(``int``(x2))` `        ``else``:` `            ``return` `-``1` `    `  `    ``# Roots are equal` `    ``elif` `d ``=``=` `0``:` `       ``# roots of equation` `        ``x1 ``=` `(``-``b ``/` `(``2` `*` `a))` `        ``if` `int``(x1) ``=``=` `x1 ``and` `x1 > ``0``:` `            ``return` `(``int``(x1))` `        ``else``:` `            ``return` `-``1` `            `  `    ``# Root are imaginary        ` `    ``else``:` `        ``return` `-``1`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# K is number of diagonals` `    ``K ``=` `9` `    `  `    ``# Function call` `    ``print``(findRoots(K))`

## C#

 `// C# code for the above discussed approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG ` `{`   `  ``// Function to find the roots of quadratic equation` `  ``static` `double` `findRoots(``int` `K)` `  ``{` `    ``int` `a = 1;` `    ``int` `b = -3;` `    ``int` `c = -2 * K;`   `    ``// Finding discriminant` `    ``int` `d = b * b - 4 * a * c;` `    ``double` `sqrt_val = Math.Sqrt(Math.Abs(d));`   `    ``// Root are distinct` `    ``if` `(d > 0) {` `      ``// roots of equation` `      ``double` `x1 = (-b + sqrt_val) / (2 * a);` `      ``double` `x2 = (-b - sqrt_val) / (2 * a);`   `      ``if` `((``int``)x1 == x1 && x1 > 0)` `        ``return` `x1;` `      ``else` `if` `((``int``)x2 == x2 && x2 > 0)` `        ``return` `x2;` `      ``else` `        ``return` `-1;` `    ``}`   `    ``// Roots are equal` `    ``else` `if` `(d == 0) {`   `      ``// roots of equation` `      ``double` `x1 = (-b / (2 * a));` `      ``if` `((``int``)x1 == x1 && x1 > 0)` `        ``return` `x1;` `      ``else` `        ``return` `-1;` `    ``}`   `    ``// Root are imaginary` `    ``else` `      ``return` `-1;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{ `   `    ``// K is number of diagonals` `    ``int` `K = 9;`   `    ``// Function call` `    ``Console.Write(findRoots(K));` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output

`6`

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

My Personal Notes arrow_drop_up
Related Articles