5 Best Ways to Find the Length of the Longest Arithmetic Subsequence with Constant Difference in Python

Rate this post

πŸ’‘ Problem Formulation: A common challenge in algorithm design is to find the longest arithmetic subsequence within a sequence of numbers where the difference between consecutive elements is constant. For instance, given the array [3, 6, 9, 12], the longest arithmetic subsequence with a constant difference of 3 is the entire sequence with a length of 4.

Method 1: Dynamic Programming

Dynamic Programming can be a very efficient way to solve this problem. It involves creating a table that stores the length of the longest arithmetic subsequence ending with two indices at each combination. As you iterate over the array, you update the table with the counts reflecting the differences between the elements.

Here’s an example:

def longest_arith_seq_length(A):
    dp = {}
    for i in range(len(A)):
        for j in range(i):
            d = A[i] - A[j]
            if (j, d) in dp:
                dp[(i, d)] = dp[(j, d)] + 1
                dp[(i, d)] = 2
    return max(dp.values())

# Example usage:
print(longest_arith_seq_length([3, 6, 9, 12]))

The output of this code snippet:


This implementation uses a Python dictionary as a hashtable to store each pair of (index, difference) as a key and the longest arithmetic subsequence ending at that index with that difference as a value. The method iterates over all pairs of indices in the array, populating the hashtable with the maximum sequence lengths found.

Method 2: Recursion with Memoization

Recursion with Memoization is an approach where a recursive formula defines the solution and intermediate results are stored to avoid re-computation. This method can be slower due to the overhead of recursion but requires less space complexity compared to dynamic programming.

Here’s an example:

def recursive_with_memo(A):
    memo = {}
    def recurse(i, d):
        if (i, d) in memo:
            return memo[(i, d)]
        max_length = 1
        for j in range(i):
            if A[i] - A[j] == d:
                max_length = max(max_length, recurse(j, d) + 1)
        memo[(i, d)] = max_length
        return max_length
    max_seq_length = 0
    for i in range(len(A)):
        for j in range(i):
            d = A[i] - A[j]
            max_seq_length = max(max_seq_length, recurse(i, d))

    return max_seq_length

# Example usage:
print(recursive_with_memo([3, 6, 9, 12]))

The output of this code snippet:


This recursive solution explores all possible arithmetic subsequences and uses a memoization dictionary to store the length of the longest subsequence for a given end index and common difference to prevent redundant calculations.

Method 3: Hash Table with Linear Traversal

The hash table with linear traversal is similar to dynamic programming but optimized for space complexity. It involves traversing the array while using a hash table to store the length of the longest arithmetic subsequence having seen with a specific common difference thus far.

Here’s an example:

def hash_table_linear_traversal(A):
    dp = [{} for _ in range(len(A))]
    max_length = 0
    for i in range(1, len(A)):
        for j in range(i):
            diff = A[i] - A[j]
            dp[i][diff] = dp[j].get(diff, 1) + 1
            max_length = max(max_length, dp[i][diff])
    return max_length

# Example usage:
print(hash_table_linear_traversal([1, 5, 7, 8, 5, 3, 4, 2]))

The output of this code snippet:


The code employs a list of dictionaries to keep track of the longest subsequence for each starting point and difference. The algorithm calculates the differences for each pair of numbers and updates the hash tables accordingly, keeping track of the current maximum length found.

Method 4: Binary Search Tree (BST) Optimization

Using a Binary Search Tree can help optimize the search for the required arithmetic difference in sequences. Though not common for this particular problem, BST can improve time complexity in specific cases where data is inserted in a particular order.

Here’s an example:

from sortedcontainers import SortedList
def bst_optimization(A):
    # This is a conceptual approach and might not be 
    # directly applicable to arithmetic subsequences.
    # Pseudo-code is provided for understanding purposes.
    # Initialize the BST equivalent structure
    seq_diffs = SortedList()
    # Logic to insert and search for arithmetic sequence differences
    # using the bst operations to optimize performance
    # Return the found maximum length
    return max_length

# Example usage:
# Please note that this is a pseudo-explanation and not an executable code snippet
# print(bst_optimization([5, 1, 3, 2, 5, 7, 10]))

In lieu of concrete results, we acknowledge that this is a high-level pseudo-code example. Implementing BST optimization requires careful consideration of tree balancing and search algorithms, which is beyond the scope of a direct approach to the problem.

Bonus One-Liner Method 5: Using Built-in Functions

A compact and elegant solution can sometimes be achieved using built-in Python functions. While not always the most efficient, this method often brings clarity and conciseness to the code.

Here’s an example:

# Important note: As of the current knowledge cut-off, Python does not
# provide a direct one-liner built-in function for this specific challenge.

# Example usage:
# print(one_liner_method([3, 6, 9, 12]))

Given the specificity of this algorithmic problem, a one-liner built-in function approach may not be applicable without significant pre-processing or the use of third-party libraries, thereby moving away from the ‘one-liner’ concept.


  • Method 1: Dynamic Programming. Highly efficient in many cases. Can have high memory usage with large arrays.
  • Method 2: Recursion with Memoization. A classic approach that’s more intuitive but can be slower due to recursive calls and function call overhead.
  • Method 3: Hash Table with Linear Traversal. Optimizes for space efficiency over pure dynamic programming and is quite readable.
  • Method 4: Binary Search Tree (BST) Optimization. Offers a theoretical optimization that might outperform in certain cases but requires a complex implementation.
  • Bonus Method 5: Using Built-in Functions. A one-liner solution for specialty problems usually isn’t available, but exploring Python’s built-ins can lead to unexpected simplifications.