Maximum length subarray with LCM equal to product
Given an arr[], the task is to find the maximum length of the sub-array such that the LCM of the sub-array is equal to the product of numbers in the sub-array. If no valid sub-array exists, then print -1.
Note: The length of the sub-array must be ? 2.
Examples:
Input: arr[] = { 6, 10, 21}
Output: 2
The sub-array { 10, 21 } satisfies the condition.
Input: arr[] = { 2, 2, 4}
Output: -1
No sub-array satisfies the condition. Hence, the output is -1.
Naive Approach: Run nested loops to check the condition for every possible sub-array of length ? 2. If the sub-array satisfies the condition, then update ans = max(ans, length(sub-array)). Print the ans in the end.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
int maxLengthSubArray( const int * arr, int n)
{
int maxLen = -1;
for ( int i = 0; i < n - 1; i++) {
for ( int j = i + 1; j < n; j++) {
ll lcm = 1LL * arr[i];
ll product = 1LL * arr[i];
for ( int k = i + 1; k <= j; k++) {
lcm = (((arr[k] * lcm)) /
(gcd(arr[k], lcm)));
product = product * arr[k];
}
if (lcm == product) {
maxLen = max(maxLen, j - i + 1);
}
}
}
return maxLen;
}
int main()
{
int arr[] = { 6, 10, 21 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << maxLengthSubArray(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int gcd( int a, int b)
{
if (b == 0 )
return a;
return gcd(b, a % b);
}
static int maxLengthSubArray( int arr[], int n)
{
int maxLen = - 1 ;
for ( int i = 0 ; i < n - 1 ; i++)
{
for ( int j = i + 1 ; j < n; j++)
{
int lcm = 1 * arr[i];
int product = 1 * arr[i];
for ( int k = i + 1 ; k <= j; k++)
{
lcm = (((arr[k] * lcm)) /
(gcd(arr[k], lcm)));
product = product * arr[k];
}
if (lcm == product)
{
maxLen = Math.max(maxLen, j - i + 1 );
}
}
}
return maxLen;
}
public static void main(String args[])
{
int arr[] = { 6 , 10 , 21 };
int n = arr.length;
System.out.println(maxLengthSubArray(arr, n));
}
}
|
Python3
def gcd(a, b):
if (b = = 0 ):
return a
return gcd(b, a % b)
def maxLengthSubArray(arr, n):
maxLen = - 1
for i in range (n - 1 ):
for j in range (n):
lcm = arr[i]
product = arr[i]
for k in range (i + 1 , j + 1 ):
lcm = (((arr[k] * lcm)) / /
(gcd(arr[k], lcm)))
product = product * arr[k]
if (lcm = = product):
maxLen = max (maxLen, j - i + 1 )
return maxLen
arr = [ 6 , 10 , 21 ]
n = len (arr)
print (maxLengthSubArray(arr, n))
|
C#
using System;
class GFG
{
static int gcd( int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
static int maxLengthSubArray( int [] arr, int n)
{
int maxLen = -1;
for ( int i = 0; i < n - 1; i++)
{
for ( int j = i + 1; j < n; j++)
{
int lcm = 1 * arr[i];
int product = 1 * arr[i];
for ( int k = i + 1; k <= j; k++)
{
lcm = (((arr[k] * lcm)) /
(gcd(arr[k], lcm)));
product = product * arr[k];
}
if (lcm == product)
{
maxLen = Math.Max(maxLen, j - i + 1);
}
}
}
return maxLen;
}
public static void Main()
{
int [] arr = { 6, 10, 21 };
int n = arr.Length;
Console.Write(maxLengthSubArray(arr, n));
}
}
|
PHP
<?php
function gcd( $a , $b )
{
if ( $b == 0)
return $a ;
return gcd( $b , $a % $b );
}
function maxLengthSubArray(& $arr , $n )
{
$maxLen = -1;
for ( $i = 0; $i < $n - 1; $i ++)
{
for ( $j = $i + 1; $j < $n ; $j ++)
{
$lcm = $arr [ $i ];
$product = $arr [ $i ];
for ( $k = $i + 1; $k <= $j ; $k ++)
{
$lcm = ((( $arr [ $k ] * $lcm )) /
(gcd( $arr [ $k ], $lcm )));
$product = $product * $arr [ $k ];
}
if ( $lcm == $product )
{
$maxLen = max( $maxLen , $j - $i + 1);
}
}
}
return $maxLen ;
}
$arr = array (6, 10, 21 );
$n = sizeof( $arr );
echo (maxLengthSubArray( $arr , $n ));
?>
|
Javascript
<script>
function gcd(a,b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
function maxLengthSubArray(arr,n)
{
let maxLen = -1;
for (let i = 0; i < n - 1; i++)
{
for (let j = i + 1; j < n; j++)
{
let lcm = 1 * arr[i];
let product = 1 * arr[i];
for (let k = i + 1; k <= j; k++)
{
lcm = (((arr[k] * lcm)) /
(gcd(arr[k], lcm)));
product = product * arr[k];
}
if (lcm == product)
{
maxLen = Math.max(maxLen, j - i + 1);
}
}
}
return maxLen;
}
let arr=[6, 10, 21 ];
let n = arr.length;
document.write(maxLengthSubArray(arr, n));
</script>
|
Efficient Approach: A sub-array will have its LCM equal to its product when no two elements in the sub-array have any common factor.
For example:
arr[] = { 6, 10, 21 }
Prime factorization yields:
arr[] = { 2 * 3, 2 * 5, 3 * 7 }
[6, 10] has 2 as a common factor.
[6, 10, 21] has 2 as a common factor between 6 and 10.
Sub-array [10, 21] has no common factor between any 2 elements. Therefore, answer = 2.
Firstly, prime factorization of numbers is done to deal with factors. To calculate the sub-array in which no 2 elements have a common factor, we use the two-pointer technique.
Two pointers run, both from the right and they represent the current sub-array. We add elements in the sub-array from the right. Now there are two scenarios:
- An element is added in the current sub-array if it has no factor in common with the current elements in the sub-array. If a common factor is found, then starting from the left, elements are subsequently eliminated until no common factor is found with the newly added element.
- If there are no common factors between the newly added element and existing elements, then update ans = max(ans, length of sub-array)
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
#define pb push_back
#define N 100005
#define MAX 1000002
#define mem(a, b) memset(a, b, sizeof(a))
using namespace std;
int prime[MAX];
vector< int > v[N];
int f[MAX];
void sieve()
{
prime[0] = prime[1] = 1;
for ( int i = 2; i < MAX; i++) {
if (!prime[i]) {
for ( int j = i * 2; j < MAX; j += i) {
if (!prime[j])
prime[j] = i;
}
}
}
for ( int i = 2; i < MAX; i++) {
if (!prime[i])
prime[i] = i;
}
}
int maxLengthSubArray( int * arr, int n)
{
mem(f, -1);
for ( int i = 0; i < n; ++i) {
while (arr[i] > 1) {
int p = prime[arr[i]];
arr[i] /= p;
v[i].pb(p);
}
}
int l = 0, r = 1, ans = -1;
for ( int i : v[0]) {
f[i] = 0;
}
while (l <= r && r < n) {
int flag = 0;
for ( int i = 0; i < v[r].size(); i++) {
if (f[v[r][i]] == -1 || f[v[r][i]] == r) {
f[v[r][i]] = r;
}
else {
flag = 1;
break ;
}
}
if (flag) {
for ( int i : v[l]) {
f[i] = -1;
}
l++;
}
else {
ans = max(ans, r - l + 1);
r++;
}
}
if (ans == 1)
ans = -1;
return ans;
}
int main()
{
sieve();
int arr[] = { 6, 10, 21 };
int n = sizeof (arr) / sizeof (arr[0]);
cout << maxLengthSubArray(arr, n);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
static int N = 100005 ;
static int MAX = 1000002 ;
static int [] prime = new int [MAX];
static ArrayList<
ArrayList<Integer>> v = new ArrayList<
ArrayList<Integer>>();
static int [] f = new int [MAX];
static void sieve()
{
for ( int i = 0 ; i < N; i++)
{
v.add( new ArrayList<Integer>());
}
prime[ 0 ] = prime[ 1 ] = 1 ;
for ( int i = 2 ; i < MAX; i++)
{
if (prime[i] == 0 )
{
for ( int j = i * 2 ; j < MAX; j += i)
{
if (prime[j] == 0 )
{
prime[j] = i;
}
}
}
}
for ( int i = 2 ; i < MAX; i++)
{
if (prime[i] == 0 )
{
prime[i] = i;
}
}
}
static int maxLengthSubArray( int [] arr, int n)
{
Arrays.fill(f, - 1 );
for ( int i = 0 ; i < n; ++i)
{
while (arr[i] > 1 )
{
int p = prime[arr[i]];
arr[i] /= p;
v.get(i).add(p);
}
}
int l = 0 , r = 1 , ans = - 1 ;
for ( int i : v.get( 0 ))
{
f[i] = 0 ;
}
while (l <= r && r < n)
{
int flag = 0 ;
for ( int i = 0 ; i < v.get(r).size(); i++)
{
if (f[v.get(r).get(i)] == - 1 ||
f[v.get(r).get(i)] == r)
{
f[v.get(r).get(i)] = r;
}
else
{
flag = 1 ;
break ;
}
}
if (flag != 0 )
{
for ( int i : v.get(l))
{
f[i] = - 1 ;
}
l++;
}
else
{
ans = Math.max(ans, r - l + 1 );
r++;
}
}
if (ans == 1 )
{
ans = - 1 ;
}
return ans;
}
public static void main(String[] args)
{
sieve();
int arr[] = { 6 , 10 , 21 };
int n = arr.length;
System.out.println(maxLengthSubArray(arr, n));
}
}
|
Python3
N = 100005
MAX = 1000002
prime = [ 0 for i in range ( MAX + 1 )]
v = [[] for i in range (N)]
f = [ - 1 for i in range ( MAX )]
def sieve():
prime[ 0 ], prime[ 1 ] = 1 , 1
for i in range ( 2 , MAX + 1 ):
if (prime[i] = = 0 ):
for j in range (i * 2 , MAX , i):
if (prime[j] = = 0 ):
prime[j] = i
for i in range ( 2 , MAX ):
if (prime[i] = = 0 ):
prime[i] = i
def maxLengthSubArray(arr, n):
for i in range (n):
f[i] = - 1
for i in range (n):
while (arr[i] > 1 ):
p = prime[arr[i]]
arr[i] / / = p
v[i].append(p)
l, r, ans = 0 , 1 , - 1
for i in v[ 0 ]:
f[i] = 0
while (l < = r and r < n):
flag = 0
for i in range ( len (v[r])):
if (f[v[r][i]] = = - 1 or f[v[r][i]] = = r):
f[v[r][i]] = r
else :
flag = 1
break
if (flag):
for i in v[l]:
f[i] = - 1
l + = 1
else :
ans = max (ans, r - l + 1 )
r + = 1
if (ans = = 1 ):
ans = - 1
return ans
sieve()
arr = [ 6 , 10 , 21 ]
n = len (arr)
print (maxLengthSubArray(arr, n))
|
C#
using System;
using System.Collections.Generic;
class GFG
{
static int N = 100005;
static int MAX = 1000002;
static int [] prime = new int [MAX];
static List<List< int >> v = new List<List< int >>();
static int [] f = new int [MAX];
static void sieve()
{
for ( int i = 0; i < N; i++)
{
v.Add( new List< int >());
}
prime[0] = prime[1] = 1;
for ( int i = 2; i < MAX; i++)
{
if (prime[i] == 0)
{
for ( int j = i * 2; j < MAX; j += i)
{
if (prime[j] == 0)
{
prime[j] = i;
}
}
}
}
for ( int i = 2; i < MAX; i++)
{
if (prime[i] == 0)
{
prime[i] = i;
}
}
}
static int maxLengthSubArray( int [] arr, int n)
{
Array.Fill(f, -1);
for ( int i = 0; i < n; ++i)
{
while (arr[i] > 1)
{
int p = prime[arr[i]];
arr[i] /= p;
v[i].Add(p);
}
}
int l = 0, r = 1, ans = -1;
foreach ( int i in v[0])
{
f[i] = 0;
}
while (l <= r && r < n)
{
int flag = 0;
for ( int i = 0; i < v[r].Count; i++)
{
if (f[v[r][i]] == -1 ||
f[v[r][i]] == r)
{
f[v[r][i]] = r;
}
else
{
flag = 1;
break ;
}
}
if (flag != 0)
{
foreach ( int i in v[l])
{
f[i] = -1;
}
l++;
}
else
{
ans = Math.Max(ans, r - l + 1);
r++;
}
}
if (ans == 1)
{
ans = -1;
}
return ans;
}
static public void Main ()
{
sieve();
int [] arr = { 6, 10, 21 };
int n = arr.Length;
Console.WriteLine(maxLengthSubArray(arr, n));
}
}
|
Javascript
<script>
let N = 100005;
let MAX = 1000002;
let prime = new Array(MAX);
for (let i=0;i<prime.length;i++)
{
prime[i]=0;
}
let v = [];
let f = new Array(MAX);
function sieve()
{
for (let i = 0; i < N; i++)
{
v.push([]);
}
prime[0] = prime[1] = 1;
for (let i = 2; i < MAX; i++)
{
if (prime[i] == 0)
{
for (let j = i * 2; j < MAX; j += i)
{
if (prime[j] == 0)
{
prime[j] = i;
}
}
}
}
for (let i = 2; i < MAX; i++)
{
if (prime[i] == 0)
{
prime[i] = i;
}
}
}
function maxLengthSubArray(arr,n)
{
for (let i=0;i<f.length;i++)
{
f[i]=-1;
}
for (let i = 0; i < n; ++i)
{
while (arr[i] > 1)
{
let p = prime[arr[i]];
arr[i] /= p;
v[i].push(p);
}
}
let l = 0, r = 1, ans = -1;
for (let i=0;i< v[0].length;i++)
{
f[v[0][i]] = 0;
}
while (l <= r && r < n)
{
let flag = 0;
for (let i = 0; i < v[r].length; i++)
{
if (f[v[r][i]] == -1 ||
f[v[r][i]] == r)
{
f[v[r][i]] = r;
}
else
{
flag = 1;
break ;
}
}
if (flag != 0)
{
for (let i=0;i<v[l].length;i++)
{
f[v[l][i]] = -1;
}
l++;
}
else
{
ans = Math.max(ans, r - l + 1);
r++;
}
}
if (ans == 1)
{
ans = -1;
}
return ans;
}
sieve();
let arr=[ 6, 10, 21];
let n = arr.length;
document.write(maxLengthSubArray(arr, n));
</script>
|
Last Updated :
03 Jun, 2021
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...