Maximize the common difference of an AP having the given array as a subsequence

• Last Updated : 29 Nov, 2021

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:
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:
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), 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 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 is the first term of an arithmetic progression with common difference CD, then:

arr[i] = arr + (X – 1) * CD
=> (arr[i] – arr) = (X – 1) * CD

Therefore, 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:

Below is the implementation of the above approach

C++

 // C++ program to implement// the above approach #include using namespace std; // Function to find the maximum common// difference of an AP such that arr[]// is a subsequence of that APint 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 Codeint main(){    int arr[] = { 1, 3, 7, 9 };    int N = sizeof(arr) / sizeof(arr);     cout << MaxComDiffSubAP(arr, N);     return 0;}

Java

 // 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

 # Python3 program to implement# the above approachfrom math import gcd # Function to find the maximum common# difference of an AP such that arr[]# is a subsequence of that APdef 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 Codeif __name__ == '__main__':     arr = [ 1, 3, 7, 9 ]    N = len(arr)         print(MaxComDiffSubAP(arr, N)) # This code is contributed by mohit kumar 29

C#

 // C# program to implement// the above approach using System; class GFG{  // Recursive function to return// gcd of a and bstatic 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 APstatic 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 Codepublic static void Main (){    int[] arr = { 1, 3, 7, 9 };    int N = arr.Length;         Console.WriteLine(MaxComDiffSubAP(arr, N));}} // This code is contributed by susmitakundugoaldanga

Javascript


Output:
2

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

My Personal Notes arrow_drop_up