# Smallest perfect square divisible by all elements of an array

Given an array arr[], the task is to find the smallest perfect square which is divisible by all the elements of the given array.

Examples:

Input: arr[] = {2, 3, 4, 5, 7}
Output: 44100

Input: arr[] = {20, 25, 14, 21, 100, 18, 42, 16, 55}
Output: 21344400

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: Check one by one all square number starting from 1 and select the one which is divisible by all the elements of the array.

Efficient Approach: Find the least common multiple of all the elements of the array and store it in a variable lcm. Find all prime factor of the found LCM.
Now check if there are any prime factors which divide the lcm odd number of times. If there are such factors, multiply LCM by those factors. Print the updated LCM in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `#define ll long long int ` ` `  `// Function to return the gcd of two numbers ` `ll gcd(ll a, ll b) ` `{ ` `    ``if` `(b == 0) ` `        ``return` `a; ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` ` `  `// Function to return the lcm of ` `// all the elements of the array ` `ll lcmOfArray(``int` `arr[], ``int` `n) ` `{ ` `    ``if` `(n < 1) ` `        ``return` `0; ` ` `  `    ``ll lcm = arr[0]; ` ` `  `    ``// To calculate lcm of two numbers ` `    ``// multiply them and divide the result ` `    ``// by gcd of both the numbers ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``lcm = (lcm * arr[i]) / gcd(lcm, arr[i]); ` ` `  `    ``// Return the LCM of the array elements ` `    ``return` `lcm; ` `} ` ` `  `// Function to return the smallest perfect square ` `// divisible by all the elements of arr[] ` `int` `minPerfectSquare(``int` `arr[], ``int` `n) ` `{ ` `    ``ll minPerfectSq; ` ` `  `    ``// LCM of all the elements of arr[] ` `    ``ll lcm = lcmOfArray(arr, n); ` `    ``minPerfectSq = (``long` `long``)lcm; ` ` `  `    ``// Check if 2 divides lcm odd number of times ` `    ``int` `cnt = 0; ` `    ``while` `(lcm > 1 && lcm % 2 == 0) { ` `        ``cnt++; ` `        ``lcm /= 2; ` `    ``} ` `    ``if` `(cnt % 2 != 0) ` `        ``minPerfectSq *= 2; ` ` `  `    ``int` `i = 3; ` ` `  `    ``// Check all the numbers that divide lcm ` `    ``// odd number of times ` `    ``while` `(lcm > 1) { ` `        ``cnt = 0; ` `        ``while` `(lcm % i == 0) { ` `            ``cnt++; ` `            ``lcm /= i; ` `        ``} ` ` `  `        ``// If i divided lcm odd number of times ` `        ``// then multiply the lcm with i ` `        ``if` `(cnt % 2 != 0) ` `            ``minPerfectSq *= i; ` ` `  `        ``i += 2; ` `    ``} ` ` `  `    ``// Return the answer ` `    ``return` `minPerfectSq; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 3, 4, 5, 7 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << minPerfectSquare(arr, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `solution ` `{ ` ` `  `// Function to return the gcd of two numbers ` `static` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(b == ``0``) ` `        ``return` `a; ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` ` `  `// Function to return the lcm of ` `// all the elements of the array ` `static` `int` `lcmOfArray(``int` `arr[], ``int` `n) ` `{ ` `    ``if` `(n < ``1``) ` `        ``return` `0``; ` ` `  `    ``int` `lcm = arr[``0``]; ` ` `  `    ``// To calculate lcm of two numbers ` `    ``// multiply them and divide the result ` `    ``// by gcd of both the numbers ` `    ``for` `(``int` `i = ``1``; i < n; i++) ` `        ``lcm = (lcm * arr[i]) / gcd(lcm, arr[i]); ` ` `  `    ``// Return the LCM of the array elements ` `    ``return` `lcm; ` `} ` ` `  `// Function to return the smallest perfect square ` `// divisible by all the elements of arr[] ` `static` `int` `minPerfectSquare(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `minPerfectSq; ` ` `  `    ``// LCM of all the elements of arr[] ` `    ``int` `lcm = lcmOfArray(arr, n); ` `    ``minPerfectSq = (``int``)lcm; ` ` `  `    ``// Check if 2 divides lcm odd number of times ` `    ``int` `cnt = ``0``; ` `    ``while` `(lcm > ``1` `&& lcm % ``2` `== ``0``) { ` `        ``cnt++; ` `        ``lcm /= ``2``; ` `    ``} ` `    ``if` `(cnt % ``2` `!= ``0``) ` `        ``minPerfectSq *= ``2``; ` ` `  `    ``int` `i = ``3``; ` ` `  `    ``// Check all the numbers that divide lcm ` `    ``// odd number of times ` `    ``while` `(lcm > ``1``) { ` `        ``cnt = ``0``; ` `        ``while` `(lcm % i == ``0``) { ` `            ``cnt++; ` `            ``lcm /= i; ` `        ``} ` ` `  `        ``// If i divided lcm odd number of times ` `        ``// then multiply the lcm with i ` `        ``if` `(cnt % ``2` `!= ``0``) ` `            ``minPerfectSq *= i; ` ` `  `        ``i += ``2``; ` `    ``} ` ` `  `    ``// Return the answer ` `    ``return` `minPerfectSq; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = { ``2``, ``3``, ``4``, ``5``, ``7` `}; ` `    ``int` `n = arr.length; ` `    ``System.out.println(minPerfectSquare(arr, n)); ` ` `  `} ` `} ` ` `  `// This code is contributed by ` `// Shashank_Sharma `

## Python3

 `# Python 3 implementation of the approach ` `from` `math ``import` `gcd ` ` `  `# Function to return the lcm of ` `# all the elements of the array ` `def` `lcmOfArray(arr, n): ` `    ``if` `(n < ``1``): ` `        ``return` `0` ` `  `    ``lcm ``=` `arr[``0``] ` ` `  `    ``# To calculate lcm of two numbers ` `    ``# multiply them and divide the result ` `    ``# by gcd of both the numbers ` `    ``for` `i ``in` `range``(``1``, n, ``1``): ` `        ``lcm ``=` `int``((lcm ``*` `arr[i]) ``/`  `               ``gcd(lcm, arr[i])) ` ` `  `    ``# Return the LCM of the array elements ` `    ``return` `lcm ` ` `  `# Function to return the smallest perfect  ` `# square divisible by all the elements of arr[] ` `def` `minPerfectSquare(arr, n): ` `     `  `    ``# LCM of all the elements of arr[] ` `    ``lcm ``=` `lcmOfArray(arr, n) ` `    ``minPerfectSq ``=` `int``(lcm) ` ` `  `    ``# Check if 2 divides lcm odd ` `    ``# number of times ` `    ``cnt ``=` `0` `    ``while` `(lcm > ``1` `and` `lcm ``%` `2` `=``=` `0``): ` `        ``cnt ``+``=` `1` `        ``lcm ``/``=` `2` `     `  `    ``if` `(cnt ``%` `2` `!``=` `0``): ` `        ``minPerfectSq ``*``=` `2` ` `  `    ``i ``=` `3` `     `  `    ``# Check all the numbers that divide  ` `    ``# lcm odd number of times ` `    ``while` `(lcm > ``1``): ` `        ``cnt ``=` `0``; ` `        ``while` `(lcm ``%` `i ``=``=` `0``): ` `            ``cnt ``+``=` `1` `            ``lcm ``/``=` `i ` ` `  `        ``# If i divided lcm odd number of  ` `        ``# times then multiply the lcm with i ` `        ``if` `(cnt ``%` `2` `!``=` `0``): ` `            ``minPerfectSq ``*``=` `i ` ` `  `        ``i ``+``=` `2` ` `  `    ``# Return the answer ` `    ``return` `minPerfectSq ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``arr ``=` `[``2``, ``3``, ``4``, ``5``, ``7``] ` `    ``n ``=` `len``(arr) ` `    ``print``(minPerfectSquare(arr, n)) ` ` `  `# This code is contributed by ` `# Sanjit_Prasad `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `public` `class` `GFG{ ` `     `  `// Function to return the gcd of two numbers ` `static` `int` `gcd(``int` `a, ``int` `b) ` `{ ` `    ``if` `(b == 0) ` `        ``return` `a; ` `    ``else` `        ``return` `gcd(b, a % b); ` `} ` ` `  `// Function to return the lcm of ` `// all the elements of the array ` `static` `int` `lcmOfArray(``int` `[]arr, ``int` `n) ` `{ ` `    ``if` `(n < 1) ` `        ``return` `0; ` ` `  `    ``int` `lcm = arr[0]; ` ` `  `    ``// To calculate lcm of two numbers ` `    ``// multiply them and divide the result ` `    ``// by gcd of both the numbers ` `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``lcm = (lcm * arr[i]) / gcd(lcm, arr[i]); ` ` `  `    ``// Return the LCM of the array elements ` `    ``return` `lcm; ` `} ` ` `  `// Function to return the smallest perfect square ` `// divisible by all the elements of arr[] ` `static` `int` `minPerfectSquare(``int` `[]arr, ``int` `n) ` `{ ` `    ``int` `minPerfectSq; ` ` `  `    ``// LCM of all the elements of arr[] ` `    ``int` `lcm = lcmOfArray(arr, n); ` `    ``minPerfectSq = (``int``)lcm; ` ` `  `    ``// Check if 2 divides lcm odd number of times ` `    ``int` `cnt = 0; ` `    ``while` `(lcm > 1 && lcm % 2 == 0) { ` `        ``cnt++; ` `        ``lcm /= 2; ` `    ``} ` `    ``if` `(cnt % 2 != 0) ` `        ``minPerfectSq *= 2; ` ` `  `    ``int` `i = 3; ` ` `  `    ``// Check all the numbers that divide lcm ` `    ``// odd number of times ` `    ``while` `(lcm > 1) { ` `        ``cnt = 0; ` `        ``while` `(lcm % i == 0) { ` `            ``cnt++; ` `            ``lcm /= i; ` `        ``} ` ` `  `        ``// If i divided lcm odd number of times ` `        ``// then multiply the lcm with i ` `        ``if` `(cnt % 2 != 0) ` `            ``minPerfectSq *= i; ` ` `  `        ``i += 2; ` `    ``} ` ` `  `    ``// Return the answer ` `    ``return` `minPerfectSq; ` `} ` ` `  `// Driver code ` `    ``static` `public` `void` `Main (){ ` `         `  `    ``int` `[]arr = { 2, 3, 4, 5, 7 }; ` `    ``int` `n = arr.Length; ` `    ``Console.WriteLine(minPerfectSquare(arr, n)); ` ` `  `    ``} ` `} ` `//This code is contributed by ajit. `

## PHP

 ` 1 && ``\$lcm` `% 2 == 0)  ` `    ``{  ` `        ``\$cnt``++;  ` `        ``\$lcm` `= ``floor``(``\$lcm` `/ 2);  ` `    ``}  ` `    ``if` `(``\$cnt` `% 2 != 0)  ` `        ``\$minPerfectSq` `*= 2;  ` ` `  `    ``\$i` `= 3;  ` ` `  `    ``// Check all the numbers that divide  ` `    ``// lcm odd number of times  ` `    ``while` `(``\$lcm` `> 1)  ` `    ``{  ` `        ``\$cnt` `= 0;  ` `        ``while` `(``\$lcm` `% ``\$i` `== 0)  ` `        ``{  ` `            ``\$cnt``++;  ` `            ``\$lcm` `= ``\$lcm` `/ ``\$i``;  ` `        ``}  ` ` `  `        ``// If i divided lcm odd number of times  ` `        ``// then multiply the lcm with i  ` `        ``if` `(``\$cnt` `% 2 != 0)  ` `            ``\$minPerfectSq` `*= ``\$i``;  ` ` `  `        ``\$i` `+= 2;  ` `    ``}  ` ` `  `    ``// Return the answer  ` `    ``return` `\$minPerfectSq``;  ` `}  ` ` `  `// Driver code  ` `\$arr` `= ``array``( 2, 3, 4, 5, 7 ); ` `\$n` `= sizeof(``\$arr``); ` `echo` `minPerfectSquare(``\$arr``, ``\$n``);  ` ` `  `// This code is contributed by Ryuga ` `?> `

Output:

```44100
```

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.