Given a sorted array arr[] consisting of N distinct elements, the task is to find the maximum possible common difference of an arithmetic progression such that the given array is a subsequence of that arithmetic progression.
Examples:
Input: arr[] = { 2, 4, 6, 8 }
Output: 2
Explanation:
Since arr[] is a subsequence of the arithmetic progression { 2, 4, 6, 8, 10, …}, the common difference of the arithmetic progression is 2.Input: arr[] = { 2, 5, 11, 23 }
Output: 3
Explanation:
Since arr[] is a subsequence of the arithmetic progression { 2, 5, 8, 11, 14, …, 23, …}, the common difference of the arithmetic progression is 2.
Naive Approach: The simplest approach to solve this problem is to iterate over the range [(arr[N – 1] – arr[0]), 1] using variable CD(common difference) and for every value in the range, check if the given array can be a subsequent of an arithmetic progressions with the first element as arr[0] and the common difference as CD. This is possible by simply checking if the difference between every pair of adjacent array elements is divisible by CD or not. If found to be true, then print the value of CD as the maximum possible answer.
Time Complexity: O(N * (Maxm – Minm)), where Maxm and Minm are the last and first array elements respectively.
Auxiliary Space: O(1)
Efficient Approach: The above approach can be optimized based on the following observations:
If arr[i] is Xth term and arr[0] is the first term of an arithmetic progression with common difference CD, then:
arr[i] = arr[0] + (X – 1) * CD
=> (arr[i] – arr[0]) = (X – 1) * CDTherefore, the maximum possible common difference of the AP is the GCD of the absolute difference of each pair of adjacent array elements.
Follow the steps below to solve the problem:
- Initialize a variable, say maxCD, to store the maximum possible common difference of an arithmetic progression such that the given array is a subsequence of that arithmetic progression.
- Traverse the array using variable i and update the value of maxCD = GCD(maxCD, (arr[i + 1] – arr[i])).
- Finally, print the value of maxCD.
Below is the implementation of the above approach
// C++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the maximum common // difference of an AP such that arr[] // is a subsequence of that AP int MaxComDiffSubAP( int arr[], int N)
{ // Stores maximum common difference
// of an AP with given conditions
int maxCD = 0;
// Traverse the array
for ( int i = 0; i < N - 1; i++) {
// Update maxCD
maxCD = __gcd(maxCD,
arr[i + 1] - arr[i]);
}
return maxCD;
} // Driver Code int main()
{ int arr[] = { 1, 3, 7, 9 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << MaxComDiffSubAP(arr, N);
return 0;
} |
// Java program to implement // the above approach class GFG
{ // Recursive function to return gcd of a and b
static int gcd( int a, int b)
{
// Everything divides 0
if (a == 0 )
return b;
if (b == 0 )
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a - b, b);
return gcd(a, b - a);
}
// Function to find the maximum common
// difference of an AP such that arr[]
// is a subsequence of that AP
static int MaxComDiffSubAP( int arr[], int N)
{
// Stores maximum common difference
// of an AP with given conditions
int maxCD = 0 ;
// Traverse the array
for ( int i = 0 ; i < N - 1 ; i++)
{
// Update maxCD
maxCD = gcd(maxCD,
arr[i + 1 ] - arr[i]);
}
return maxCD;
}
// Driver Code
public static void main (String[] args)
{
int arr[] = { 1 , 3 , 7 , 9 };
int N = arr.length;
System.out.print(MaxComDiffSubAP(arr, N));
}
} // This code is contributed by AnkThon |
# Python3 program to implement # the above approach from math import gcd
# Function to find the maximum common # difference of an AP such that arr[] # is a subsequence of that AP def MaxComDiffSubAP(arr, N):
# Stores maximum common difference
# of an AP with given conditions
maxCD = 0
# Traverse the array
for i in range (N - 1 ):
# Update maxCD
maxCD = gcd(maxCD, arr[i + 1 ] - arr[i])
return maxCD
# Driver Code if __name__ = = '__main__' :
arr = [ 1 , 3 , 7 , 9 ]
N = len (arr)
print (MaxComDiffSubAP(arr, N))
# This code is contributed by mohit kumar 29 |
// C# program to implement // the above approach using System;
class GFG{
// Recursive function to return // gcd of a and b static int gcd( int a, int b)
{ // Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a - b, b);
return gcd(a, b - a);
} // Function to find the maximum common // difference of an AP such that arr[] // is a subsequence of that AP static int MaxComDiffSubAP( int [] arr, int N)
{ // Stores maximum common difference
// of an AP with given conditions
int maxCD = 0;
// Traverse the array
for ( int i = 0; i < N - 1; i++)
{
// Update maxCD
maxCD = gcd(maxCD,
arr[i + 1] - arr[i]);
}
return maxCD;
} // Driver Code public static void Main ()
{ int [] arr = { 1, 3, 7, 9 };
int N = arr.Length;
Console.WriteLine(MaxComDiffSubAP(arr, N));
} } // This code is contributed by susmitakundugoaldanga |
<script> // Javascript program for the above approach // Recursive function to return gcd of a and b function gcd(a, b)
{ // Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a - b, b);
return gcd(a, b - a);
} // Function to find the maximum common // difference of an AP such that arr[] // is a subsequence of that AP function MaxComDiffSubAP(arr, N)
{ // Stores maximum common difference
// of an AP with given conditions
let maxCD = 0;
// Traverse the array
for (let i = 0; i < N - 1; i++)
{
// Update maxCD
maxCD = gcd(maxCD,
arr[i + 1] - arr[i]);
}
return maxCD;
} // Driver Code let arr = [ 1, 3, 7, 9 ]; let N = arr.length; document.write(MaxComDiffSubAP(arr, N)); // This code is contributed by splevel62 </script> |
2
Time Complexity: O(N)
Auxiliary Space: O(1)