Longest Arithmetic Progression | DP-35

21 Jun, 2022
Given a set of numbers, find the Length of the Longest Arithmetic Progression (LLAP) in it. 
Examples: 
set[] = {1, 7, 10, 15, 27, 29}
output = 3
The longest arithmetic progression is {1, 15, 29}

set[] = {5, 10, 15, 20, 25, 30}
output = 6
The whole set is in AP
For simplicity, we have assumed that the given set is sorted. We can always add a pre-processing step to first sort the set and then apply the below algorithms.
A simple solution is to one by one consider every pair as first two elements of AP and check for the remaining elements in sorted set. To consider all pairs as first two elements, we need to run a O(n^2) nested loop. Inside the nested loops, we need a third loop which linearly looks for the more elements in Arithmetic Progression (AP). This process takes O(n3) time. We can solve this problem in O(n2) time using Dynamic Programming. To get idea of the DP solution, let us first discuss solution of following simpler problem.
Given a sorted set, find if there exist three elements in Arithmetic Progression or not 
Please note that, the answer is true if there are 3 or more elements in AP, otherwise false. To find the three elements, we first fix an element as middle element and search for other two (one smaller and one greater). We start from the second element and fix every element as middle element. For an element set[j] to be middle of AP, there must exist elements ‘set[i]’ and ‘set[k]’ such that set[i] + set[k] = 2*set[j] where 0 <= i < j and j < k <=n-1. How to efficiently find i and k for a given j? 
We can find i and k in linear time using following simple algorithm. 
Initialize i as j-1 and k as j+1Do following while i >= 0 and k <= n-1If set[i] + set[k] is equal to 2*set[j], then we are done.If set[i] + set[k] > 2*set[j], then decrement i (do i–).Else if set[i] + set[k] < 2*set[j], then increment k (do k++).
Initialize i as j-1 and k as j+1
Do following while i >= 0 and k <= n-1If set[i] + set[k] is equal to 2*set[j], then we are done.If set[i] + set[k] > 2*set[j], then decrement i (do i–).Else if set[i] + set[k] < 2*set[j], then increment k (do k++).
If set[i] + set[k] is equal to 2*set[j], then we are done.
If set[i] + set[k] > 2*set[j], then decrement i (do i–).
Else if set[i] + set[k] < 2*set[j], then increment k (do k++).
Following is the implementation of the above algorithm for the simpler problem.  
C++
C
Java
Python3
C#
Javascript
// The function returns true if there exist three// elements in AP Assumption: set[0..n-1] is sorted.// The code strictly implements the algorithm provided// in the reference.bool arithmeticThree(vector<int> set, int n){         // One by fix every element as middle element    for(int j = 1; j < n - 1; j++)    {                 // Initialize i and k for the current j        int i = j - 1, k = j + 1;         // Find if there exist i and k that form AP        // with j as middle element        while (i >= 0 && k <= n-1)        {            if (set[i] + set[k] == 2 * set[j])                return true;                             (set[i] + set[k] < 2 * set[j]) ? k++ : i--;        }    }    return false;} // This code is contributed by Samim Hossain Mondal.
// The function returns true if there exist three elements in AP// Assumption: set[0..n-1] is sorted.// The code strictly implements the algorithm provided in the reference.bool arithmeticThree(int set[], int n){    // One by fix every element as middle element    for (int j=1; j<n-1; j++)    {        // Initialize i and k for the current j        int i = j-1, k = j+1;         // Find if there exist i and k that form AP        // with j as middle element        while (i >= 0 && k <= n-1)        {            if (set[i] + set[k] == 2*set[j])                return true;            (set[i] + set[k] < 2*set[j])? k++ : i--;        }    }     return false;}
// The function returns true if there exist three elements in AP// Assumption: set[0..n-1] is sorted.// The code strictly implements the algorithm provided in the reference.static boolean arithmeticThree(int set[], int n){    // One by fix every element as middle element    for (int j = 1; j < n - 1; j++)    {        // Initialize i and k for the current j        int i = j - 1, k = j + 1;         // Find if there exist i and k that form AP        // with j as middle element        while (i >= 0 && k <= n-1)        {            if (set[i] + set[k] == 2*set[j])                return true;            (set[i] + set[k] < 2*set[j])? k++ : i--;        }    }     return false;} // This code is contributed by gauravrajput1
# The function returns true if there exist three elements in AP# Assumption: set[0..n-1] is sorted.# The code strictly implements the algorithm provided in the reference.def arithematicThree(set_,n):     # One by fix every element as middle element    for j in range(n):                 # Initialize i and k for the current j        i,k=j-1,j+1         # Find if there exist i and k that form AP        # with j as middle element        while i>-1 and k<n:            if set_[i]+set_[k] == 2*set_[j]:                return True                           elif set_[i]+set_[k]<2*set_[j]:                i-=1                             else:                k+=1    return False  # This code is contributed by Kushagra Bansal
// The function returns true if there exist three elements in AP// Assumption: set[0..n-1] is sorted.// The code strictly implements the algorithm provided in the reference.static bool arithmeticThree(int []set, int n){       // One by fix every element as middle element    for (int j = 1; j < n - 1; j++)    {               // Initialize i and k for the current j        int i = j - 1, k = j + 1;         // Find if there exist i and k that form AP        // with j as middle element        while (i >= 0 && k <= n-1)        {            if (set[i] + set[k] == 2*set[j])                return true;            if(set[i] + set[k] < 2*set[j])                k++;            else                i--;        }    }     return false;} // This code is contributed by gauravrajput1
<script>// The function returns true if there exist three elements in AP// Assumption: set[0..n-1] is sorted.// The code strictly implements the algorithm provided in the reference.function arithmeticThree(set, n){    // One by fix every element as middle element    for (let j=1; j<n-1; j++)    {        // Initialize i and k for the current j        let i = j-1, k = j+1;         // Find if there exist i and k that form AP        // with j as middle element        while (i >= 0 && k <= n-1)        {            if (set[i] + set[k] == 2*set[j])                return true;            (set[i] + set[k] < 2*set[j])? k++ : i--;        }    }     return false;}</script>
How to extend the above solution for the original problem? 
The above function returns a boolean value. The required output of original problem is Length of the Longest Arithmetic Progression (LLAP) which is an integer value. If the given set has two or more elements, then the value of LLAP is at least 2 (Why?). 
The idea is to create a 2D table L[n][n]. An entry L[i][j] in this table stores LLAP with set[i] and set[j] as first two elements of AP and j > i. The last column of the table is always 2 (Why – see the meaning of L[i][j]). Rest of the table is filled from bottom right to top left. To fill rest of the table, j (second element in AP) is first fixed. i and k are searched for a fixed j. If i and k are found such that i, j, k form an AP, then the value of L[i][j] is set as L[j][k] + 1. Note that the value of L[j][k] must have been filled before as the loop traverses from right to left columns.
Following is the implementation of the Dynamic Programming algorithm. 
C++
Java
Python3
C#
PHP
Javascript
// C++ program to find Length of the Longest AP (llap) in a given sorted set.// The code strictly implements the algorithm provided in the reference.#include <iostream>using namespace std; // Returns length of the longest AP subset in a given setint lenghtOfLongestAP(int set[], int n){    if (n <= 2)  return n;     // Create a table and initialize all values as 2. The value of    // L[i][j] stores LLAP with set[i] and set[j] as first two    // elements of AP. Only valid entries are the entries where j>i    int L[n][n];    int llap = 2;  // Initialize the result     // Fill entries in last column as 2. There will always be    // two elements in AP with last number of set as second    // element in AP    for (int i = 0; i < n; i++)        L[i][n-1] = 2;     // Consider every element as second element of AP    for (int j=n-2; j>=1; j--)    {        // Search for i and k for j        int i = j-1, k = j+1;        while (i >= 0 && k <= n-1)        {           if (set[i] + set[k] < 2*set[j])               k++;            // Before changing i, set L[i][j] as 2           else if (set[i] + set[k] > 2*set[j])           {   L[i][j] = 2, i--;   }            else           {               // Found i and k for j, LLAP with i and j as first two               // elements is equal to LLAP with j and k as first two               // elements plus 1. L[j][k] must have been filled               // before as we run the loop from right side               L[i][j] = L[j][k] + 1;                // Update overall LLAP, if needed               llap = max(llap, L[i][j]);                // Change i and k to fill more L[i][j] values for               // current j               i--; k++;           }        }         // If the loop was stopped due to k becoming more than        // n-1, set the remaining entities in column j as 2        while (i >= 0)        {            L[i][j] = 2;            i--;        }    }    return llap;} /* Driver program to test above function*/int main(){    int set1[] = {1, 7, 10, 13, 14, 19};    int n1 = sizeof(set1)/sizeof(set1[0]);    cout <<   lenghtOfLongestAP(set1, n1) << endl;     int set2[] = {1, 7, 10, 15, 27, 29};    int n2 = sizeof(set2)/sizeof(set2[0]);    cout <<   lenghtOfLongestAP(set2, n2) << endl;     int set3[] = {2, 4, 6, 8, 10};    int n3 = sizeof(set3)/sizeof(set3[0]);    cout <<   lenghtOfLongestAP(set3, n3) << endl;     return 0;}
// Java program to find Length of the// Longest AP (llap) in a given sorted set.// The code strictly implements the// algorithm provided in the reference.import java.io.*; class GFG{    // Returns length of the longest    // AP subset in a given set    static int lenghtOfLongestAP(int set[], int n)    {        if (n <= 2) return n;             // Create a table and initialize all        // values as 2. The value ofL[i][j] stores        // LLAP with set[i] and set[j] as first two        // elements of AP. Only valid entries are        // the entries where j>i        int L[][] = new int[n][n];                  // Initialize the result        int llap = 2;             // Fill entries in last column as 2.        // There will always be two elements in        // AP with last number of set as second        // element in AP        for (int i = 0; i < n; i++)            L[i][n - 1] = 2;             // Consider every element as second element of AP        for (int j = n - 2; j >= 1; j--)        {            // Search for i and k for j            int i = j -1 , k = j + 1;            while (i >= 0 && k <= n - 1)            {            if (set[i] + set[k] < 2 * set[j])                k++;                 // Before changing i, set L[i][j] as 2            else if (set[i] + set[k] > 2 * set[j])            {                L[i][j] = 2; i--;                             }                 else            {                // Found i and k for j, LLAP with i and j as first two                // elements is equal to LLAP with j and k as first two                // elements plus 1. L[j][k] must have been filled                // before as we run the loop from right side                L[i][j] = L[j][k] + 1;                     // Update overall LLAP, if needed                llap = Math.max(llap, L[i][j]);                     // Change i and k to fill                // more L[i][j] values for current j                i--; k++;            }            }                 // If the loop was stopped due            // to k becoming more than            // n-1, set the remaining            // entities in column j as 2            while (i >= 0)            {                L[i][j] = 2;                i--;            }        }        return llap;    }         // Driver program    public static void main (String[] args)    {        int set1[] = {1, 7, 10, 13, 14, 19};        int n1 = set1.length;        System.out.println ( lenghtOfLongestAP(set1, n1));             int set2[] = {1, 7, 10, 15, 27, 29};        int n2 = set2.length;        System.out.println(lenghtOfLongestAP(set2, n2));             int set3[] = {2, 4, 6, 8, 10};        int n3 = set3.length;        System.out.println(lenghtOfLongestAP(set3, n3)) ;              }} // This code is contributed by vt_m
# Python 3 program to find Length of the# Longest AP (llap) in a given sorted set.# The code strictly implements the algorithm# provided in the reference # Returns length of the longest AP# subset in a given setdef lenghtOfLongestAP(set, n):     if (n <= 2):        return n     # Create a table and initialize all    # values as 2. The value of L[i][j]    # stores LLAP with set[i] and set[j]    # as first two elements of AP. Only    # valid entries are the entries where j>i    L = [[0 for x in range(n)]            for y in range(n)]    llap = 2 # Initialize the result     # Fill entries in last column as 2.    # There will always be two elements    # in AP with last number of set as    # second element in AP    for i in range(n):        L[i][n - 1] = 2     # Consider every element as second    # element of AP    for j in range(n - 2, 0, -1):         # Search for i and k for j        i = j - 1        k = j + 1        while(i >= 0 and k <= n - 1):             if (set[i] + set[k] < 2 * set[j]):                k += 1             # Before changing i, set L[i][j] as 2            elif (set[i] + set[k] > 2 * set[j]):                L[i][j] = 2                i -= 1             else:                 # Found i and k for j, LLAP with i and j                # as first two elements are equal to LLAP                # with j and k as first two elements plus 1.                # L[j][k] must have been filled before as                # we run the loop from right side                L[i][j] = L[j][k] + 1                 # Update overall LLAP, if needed                llap = max(llap, L[i][j])                 # Change i and k to fill more L[i][j]                # values for current j                i -= 1                k += 1                 # If the loop was stopped due to k                # becoming more than n-1, set the                # remaining entities in column j as 2                while (i >= 0):                    L[i][j] = 2                    i -= 1    return llap # Driver Codeif __name__ == "__main__":         set1 = [1, 7, 10, 13, 14, 19]    n1 = len(set1)    print(lenghtOfLongestAP(set1, n1))     set2 = [1, 7, 10, 15, 27, 29]    n2 = len(set2)    print(lenghtOfLongestAP(set2, n2))     set3 = [2, 4, 6, 8, 10]    n3 = len(set3)    print(lenghtOfLongestAP(set3, n3)) # This code is contributed by ita_c
// C# program to find Length of the// Longest AP (llap) in a given sorted set.// The code strictly implements the// algorithm provided in the reference.using System; class GFG{// Returns length of the longest// AP subset in a given setstatic int lenghtOfLongestAP(int []set,                             int n){    if (n <= 2) return n;     // Create a table and initialize    // all values as 2. The value of    // L[i][j] stores LLAP with set[i]     // and set[j] as first two elements    // of AP. Only valid entries are    // the entries where j>i    int [,]L = new int[n, n];         // Initialize the result    int llap = 2;     // Fill entries in last column as 2.    // There will always be two elements    // in AP with last number of set as    // second element in AP    for (int i = 0; i < n; i++)        L[i, n - 1] = 2;     // Consider every element as    // second element of AP    for (int j = n - 2; j >= 1; j--)    {        // Search for i and k for j        int i = j - 1 , k = j + 1;        while (i >= 0 && k <= n - 1)        {        if (set[i] + set[k] < 2 * set[j])            k++;         // Before changing i, set L[i][j] as 2        else if (set[i] + set[k] > 2 * set[j])        {            L[i, j] = 2; i--;                     }         else        {            // Found i and k for j, LLAP with            // i and j as first two elements            // is equal to LLAP with j and k            // as first two elements plus 1.            // L[j][k] must have been filled            // before as we run the loop from            // right side            L[i, j] = L[j, k] + 1;             // Update overall LLAP, if needed            llap = Math.Max(llap, L[i, j]);             // Change i and k to fill            // more L[i][j] values for current j            i--; k++;        }        }         // If the loop was stopped due        // to k becoming more than        // n-1, set the remaining        // entities in column j as 2        while (i >= 0)        {            L[i, j] = 2;            i--;        }    }    return llap;} // Driver Codestatic public void Main (){    int []set1 = {1, 7, 10, 13, 14, 19};    int n1 = set1.Length;    Console.WriteLine(lenghtOfLongestAP(set1, n1));     int []set2 = {1, 7, 10, 15, 27, 29};    int n2 = set2.Length;    Console.WriteLine(lenghtOfLongestAP(set2, n2));     int []set3 = {2, 4, 6, 8, 10};    int n3 = set3.Length;    Console.WriteLine(lenghtOfLongestAP(set3, n3)) ;}} // This code is contributed by Sach_Code
<?php// PHP program to find Length of the// Longest AP (llap) in a given sorted set. // The code strictly implements the// algorithm provided in the reference. // Returns length of the longest AP// subset in a given setfunction lenghtOfLongestAP($set, $n){    if ($n <= 2)        return $n;     // Create a table and initialize all    // values as 2. The value of L[i][j]    // stores LLAP with set[i] and set[j]    // as first two elements of AP. Only    // valid entries are the entries where j>i    $L[$n][$n] = array(array());    $llap = 2; // Initialize the result     // Fill entries in last column as 2.    // There will always be two elements    // in AP with last number of set as    // second element in AP    for ($i = 0; $i < $n; $i++)        $L[$i][$n - 1] = 2;     // Consider every element as    // second element of AP    for ($j = $n - 2; $j >= 1; $j--)    {        // Search for i and k for j        $i = $j - 1;        $k = $j + 1;        while ($i >= 0 && $k <= $n - 1)        {        if ($set[$i] + $set[$k] < 2 * $set[$j])            $k++;         // Before changing i, set L[i][j] as 2        else if ($set[$i] + $set[$k] > 2 * $set[$j])        {            $L[$i][$j] = 2;            $i--; }         else        {            // Found i and k for j, LLAP with            // i and j as first two elements            // is equal to LLAP with j and k            // as first two elements plus 1.            // L[j][k] must have been filled            // before as we run the loop from            // right side            $L[$i][$j] = $L[$j][$k] + 1;             // Update overall LLAP, if needed            $llap = max($llap, $L[$i][$j]);             // Change i and k to fill more            // L[i][j] values for current j            $i--;            $k++;        }        }         // If the loop was stopped due to k        // becoming more than n-1, set the        // remaining entities in column j as 2        while ($i >= 0)        {            $L[$i][$j] = 2;            $i--;        }    }    return $llap;} // Driver Code$set1 = array(1, 7, 10, 13, 14, 19);$n1 = sizeof($set1);echo lenghtOfLongestAP($set1, $n1),"\n"; $set2 = array(1, 7, 10, 15, 27, 29);$n2 = sizeof($set2);echo lenghtOfLongestAP($set2, $n2),"\n"; $set3 = array(2, 4, 6, 8, 10);$n3 = sizeof($set3);echo lenghtOfLongestAP($set3, $n3),"\n"; // This code is contributed by Sach_Code?>
<script>// Javascript program to find Length of the// Longest AP (llap) in a given sorted set.// The code strictly implements the// algorithm provided in the reference.         // Returns length of the longest    // AP subset in a given set    function lenghtOfLongestAP(set,n)    {        if (n <= 2)            return n;                 // Create a table and initialize all        // values as 2. The value ofL[i][j] stores        // LLAP with set[i] and set[j] as first two        // elements of AP. Only valid entries are        // the entries where j>i        let L=new Array(n);        for(let i=0;i<n;i++)        {            L[i]=new Array(n);        }                 // Initialize the result        let llap = 2;                 // Fill entries in last column as 2.        // There will always be two elements in        // AP with last number of set as second        // element in AP        for (let i = 0; i < n; i++)        {            L[i][n - 1] = 2;        }        // Consider every element as second element of AP        for (let j = n - 2; j >= 1; j--)        {            // Search for i and k for j            let i = j -1 , k = j + 1;            while (i >= 0 && k <= n - 1)            {                if (set[i] + set[k] < 2 * set[j])                    k++;                          // Before changing i, set L[i][j] as 2                else if (set[i] + set[k] > 2 * set[j])                {                    L[i][j] = 2; i--;                                      }                          else                {                    // Found i and k for j, LLAP with i and j as first two                    // elements is equal to LLAP with j and k as first two                    // elements plus 1. L[j][k] must have been filled                    // before as we run the loop from right side                    L[i][j] = L[j][k] + 1;                              // Update overall LLAP, if needed                    llap = Math.max(llap, L[i][j]);                              // Change i and k to fill                    // more L[i][j] values for current j                    i--; k++;                }            }            // If the loop was stopped due            // to k becoming more than            // n-1, set the remaining            // entities in column j as 2            while (i >= 0)            {                L[i][j] = 2;                i--;            }        }        return llap;    }         // Driver program    let set1=[1, 7, 10, 13, 14, 19];    let n1 = set1.length;    document.write( lenghtOfLongestAP(set1, n1)+"<br>");         let set2=[1, 7, 10, 15, 27, 29];    let n2 = set2.length;    document.write( lenghtOfLongestAP(set2, n2)+"<br>");         let set3=[2, 4, 6, 8, 10];    let n3 = set3.length;    document.write( lenghtOfLongestAP(set3, n3)+"<br>");              // This code is contributed by avanitrachhadiya2155     </script>
4
3
5
Time Complexity: O(n2) Auxiliary Space: O(n2)
How to reduce the space complexity for the above solution?We can also reduce space complexity to O(n).Following is the implementation of the Dynamic Programming algorithm with Space Complexity O(n). 
C++
Java
Python3
C#
Javascript
// C++ program to find Length of the// Longest AP (llap) in a given sorted set.#include <bits/stdc++.h> using namespace std; // Returns length of the longest// AP subset in a given setint Solution(vector<int> A){    int ans = 2;    int n = A.size();    if (n <= 2)        return n;     vector<int> llap(n, 2);     sort(A.begin(), A.end());     for (int j = n - 2; j >= 0; j--)    {        int i = j - 1;        int k = j + 1;        while (i >= 0 && k < n)        {            if (A[i] + A[k] == 2 * A[j])            {                llap[j] = max(llap[k] + 1, llap[j]);                ans = max(ans, llap[j]);                i -= 1;                k += 1;            }            else if (A[i] + A[k] < 2 * A[j])                k += 1;            else                i -= 1;        }    }    return ans;} // Driver Codeint main(){    vector<int> a({ 9, 4, 7, 2, 10 });    cout << Solution(a) << endl;    return 0;} // This code is contributed by ashutosh450
// Java program to find Length of the// Longest AP (llap) in a given sorted set.import java.util.*; class GFG{ // Returns length of the longest// AP subset in a given setstatic int Solution(int []A){    int ans = 2;    int n = A.length;    if (n <= 2)        return n;     int []llap = new int[n];    for(int i = 0; i < n; i++)        llap[i] = 2;     Arrays.sort(A);     for (int j = n - 2; j >= 0; j--)    {        int i = j - 1;        int k = j + 1;        while (i >= 0 && k < n)        {            if (A[i] + A[k] == 2 * A[j])            {                llap[j] = Math.max(llap[k] + 1, llap[j]);                ans = Math.max(ans, llap[j]);                i -= 1;                k += 1;            }            else if (A[i] + A[k] < 2 * A[j])                k += 1;            else                i -= 1;        }    }    return ans;} // Driver Codepublic static void main(String[] args){    int []a = { 9, 4, 7, 2, 10 };    System.out.print(Solution(a) +"\n");}} // This code is contributed by Rajput-Ji
# Python program to find Length # of the Longest AP (llap) in a given sorted set.    # Returns length of the longest AP subset in a given set   class Solution:    def Solve(self, A):        ans = 2               n= len(A)        if n<=2 :            return n        llap = [2]*n        A.sort()           for j in range(n-2, -1, -1):            i= j-1            k= j+1            while(i>=0 and k<n):                if A[i]+A[k] == 2*A[j]:                    llap[j] = max(llap[k]+1,llap[j])                    ans = max(ans, llap[j])                    i-=1                    k+=1                elif A[i]+A[k] < 2*A[j]:                    k += 1                else:                    i -= 1           return ans    # Driver program to test above functionobj = Solution()a= [9, 4, 7, 2, 10]print(obj.Solve(a))
// C# program to find Length of the// longest AP (llap) in a given sorted set.using System; class GFG{ // Returns length of the longest// AP subset in a given setstatic int Solution(int []A){    int ans = 2;    int n = A.Length;    if (n <= 2)        return n;     int []llap = new int[n];    for(int i = 0; i < n; i++)        llap[i] = 2;     Array.Sort(A);     for (int j = n - 2; j >= 0; j--)    {        int i = j - 1;        int k = j + 1;        while (i >= 0 && k < n)        {            if (A[i] + A[k] == 2 * A[j])            {                llap[j] = Math.Max(llap[k] + 1, llap[j]);                ans = Math.Max(ans, llap[j]);                i -= 1;                k += 1;            }            else if (A[i] + A[k] < 2 * A[j])                k += 1;            else                i -= 1;        }    }    return ans;} // Driver Codepublic static void Main(String[] args){    int []a = { 9, 4, 7, 2, 10 };    Console.Write(Solution(a) +"\n");}} // This code is contributed by Rajput-Ji
<script>// Javascript program to find Length of the// Longest AP (llap) in a given sorted set.        // Returns length of the longest    // AP subset in a given set    function Solution(A)    {        let ans = 2;        let n = A.length;         if (n <= 2)        {            return n;        }                 let llap = new Array(n);        for(let i = 0; i < n; i++)        {            llap[i] = 2;        }        A.sort(function(a, b){return a-b});        for (let j = n - 2; j >= 0; j--)        {            let i = j - 1;            let k = j + 1;            while (i >= 0 && k < n)            {                if (A[i] + A[k] == (2 * A[j]))                {                    llap[j] = Math.max((llap[k] + 1), llap[j]);                    ans = Math.max(ans, llap[j]);                    i -= 1;                    k += 1;                }                else if (A[i] + A[k] < 2 * A[j])                    k += 1;                else                    i -= 1;            }        }        return ans;    }    // Driver Code         let a=[9, 4, 7, 2, 10 ];    document.write(Solution(a) +"<br>");              // This code is contributed by rag2127     </script>
3
Time Complexity: O(n2) Auxiliary Space: O(n)
Umang Gupta
Sach_Code
ukasp
ashutosh450
nidhi_biet
Rajput-Ji
rutvikchandla3
avanitrachhadiya2155
rag2127
rohitsingh07052
kush11
tekraj15
gabaa406
GauravRajput1
samim2000
amartyaghoshgfg
hardikkoriintern
Amazon
arithmetic progression
Snapdeal
Arrays
Dynamic Programming
Amazon
Snapdeal
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.