# Check if Array can be generated where no element is Geometric mean of neighbours

• Last Updated : 30 May, 2022

Given two integers P and N denoting the frequency of positive and negative values, the task is to check if you can construct an array using P positive elements and N negative elements having the same absolute value (i.e. if you use X, then negative integer will be -X) such that no element is the geometric mean of its neighbours.

Examples:

Input: P = 3, N = 2
Output: True
Explanation: it is possible to create an array : X, X, -X, -X, X

Input: P = 4, N = 0
Output: False

Approach: Below is the observation for the approach:

B is said to be the geometric mean of A and C if B2 = A*C.
Since B2 is always positive, So, either B = X or B = -X and B2 = X2 because X*X = X2 and (-X)*(-X) = X2.

Hence, the Predecessor and Successor have always opposite sign.
So the array will have a pattern like {X, X, -X, -X, X, X}

Based on the above observation the solution can be derived as:

• If the difference between P and N is greater than 2 then the above arrangement is not possible.
• If the difference is exactly 2 then:
• If they occur odd times each, the arrangement won’t be possible as there will be a segment like {X, -X, X} or {-X, X, -X}.
• Otherwise, the arrangement is possible
• If the difference is less than 2, then the arrangement is always possible.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the above approach` `#include ``#define ll long long``using` `namespace` `std;` `// Function to check if it is possible``// to create the array or not``bool` `checkGM(``int` `P, ``int` `N)``{``    ``// Conditions to check if it is possible``    ``// to generate the array``    ``if` `(``abs``(P - N) >= 3)``        ``return` `false``;``    ``if` `(``abs``(P - N) == 2) {``        ``if` `(P & 1)``            ``return` `false``;``        ``else``            ``return` `true``;``    ``}``    ``return` `true``;``}` `// Driver Code``int` `main()``{``    ``ll P = 3, N = 2;` `    ``// Function call``    ``bool` `ans = checkGM(P, N);``    ``if` `(ans)``        ``cout << ``"True"``;``    ``else``        ``cout << ``"False"``;``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// Function to check if it is possible``  ``// to create the array or not``  ``static` `boolean` `checkGM(``int` `P, ``int` `N)``  ``{` `    ``// Conditions to check if it is possible``    ``// to generate the array``    ``if` `(Math.abs(P - N) >= ``3``)``      ``return` `false``;``    ``if` `(Math.abs(P - N) == ``2``) {``      ``if` `((P & ``1``) != ``0``)``        ``return` `false``;``      ``else``        ``return` `true``;``    ``}``    ``return` `true``;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `P = ``3``, N = ``2``;` `    ``// Function call``    ``boolean` `ans = checkGM(P, N);``    ``if` `(ans)``      ``System.out.print(``"True"``);``    ``else``      ``System.out.print(``"False"``);``  ``}``}` `// This code is contributed by sanjoy_62.`

## Python3

 `# Python3 code to implement the above approach` `# Function to check if it is possible``# to create the array or not``def` `checkGM(P, N):``  ` `    ``# Conditions to check if it is possible``    ``# to generate the array``    ``z ``=` `P ``-` `N``    ``if``(z < ``0``):``      ``z ``=` `z``*``(``-``1``)``    ``if``(z >``=` `3``):``        ``return` `0``    ``if` `(z ``=``=` `2``):``        ``if` `(P & ``1``):``            ``return` `0``        ``else``:``            ``return` `1``    ``return` `1` `# Driver Code``P ``=` `3``N ``=` `2` `# Function call``ans ``=` `checkGM(P, N);``if` `(ans ``is` `1``):``    ``print``(``"True"``)``else``:``    ``print``(``"False"``)``    ` `    ``# This code is contributed by ashishsingh13122000.`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG``{``  ``// Function to check if it is possible``  ``// to create the array or not``  ``static` `bool` `checkGM(``int` `P, ``int` `N)``  ``{` `    ``// Conditions to check if it is possible``    ``// to generate the array``    ``if` `(Math.Abs(P - N) >= 3)``      ``return` `false``;``    ``if` `(Math.Abs(P - N) == 2) {``      ``if` `((P & 1) != 0)``        ``return` `false``;``      ``else``        ``return` `true``;``    ``}``    ``return` `true``;``  ``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `P = 3, N = 2;` `    ``// Function call``    ``bool` `ans = checkGM(P, N);``    ``if` `(ans)``      ``Console.WriteLine(``"True"``);``    ``else``      ``Console.WriteLine(``"False"``);``}``}` `// This code is contributed by avijitmondal1998.`

## Javascript

 `// JavaScript code to implement the above approach` `// Function to check if it is possible``// to create the array or not``function` `checkGM(P, N)``{``  ` `    ``// Conditions to check if it is possible``    ``// to generate the array``    ``var` `z = P - N;``    ``if``(z < 0)``      ``z = z*(-1);``    ``if``(z >= 3)``        ``return` `0;``    ``if` `(z == 2)``    ``{``        ``if` `(P & 1)``            ``return` `0;``        ``else``            ``return` `1;``    ``}``    ``return` `1;``}` `// Driver Code``var` `P = 3;``var` `N = 2;` `// Function call``var` `ans = checkGM(P, N);``if` `(ans == 1)``    ``console.log(``"True"``);``else``    ``console.log(``"False"``);``    ` `// This code is contributed by phasing17.`

Output

`True`

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

My Personal Notes arrow_drop_up