# 5 Best Ways to Find the Length of the Longest Arithmetic Subsequence of a Given List in Python

π‘ Problem Formulation: We are looking to find the longest arithmetic subsequence within a given list of numbers in Python. For instance, given the list `[3, 6, 9, 12]`, the longest arithmetic subsequence is the sequence itself with a common difference of 3, hence the output should be 4.

## Method 1: Dynamic Programming

Dynamic Programming can be used to solve the problem by maintaining a 2D array that keeps track of the length of the arithmetic sequences ending with two indices. Each cell `dp[i][j]` in the array represents the length of the arithmetic sequence ending with elements at indices `i` and `j`. We iterate over pairs of indices to fill this array while keeping track of the longest subsequence found.

Here’s an example:

```def longest_arith_seq_length(A):
n = len(A)
if n <= 2:
return n
dp = [{} for _ in range(n)]
max_length = 2
for i in range(n):
for j in range(i):
diff = A[i] - A[j]
if diff in dp[j]:
dp[i][diff] = dp[j][diff] + 1
else:
dp[i][diff] = 2
max_length = max(max_length, dp[i][diff])
return max_length

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

Output: `4`

This method iterates through each pair of elements in the list, updating the `dp` array with the length of the longest arithmetic subsequence that can be formed by including these two elements. The maximum length found during these updates is the length of the longest arithmetic subsequence in the list.

## Method 2: Recursion with Memoization

Recursion with memoization enhances the basic recursive approach by storing the results of subproblems to avoid redundant computations. We define a recursive function that calculates the length of the longest arithmetic subsequence ending at a given index with a certain common difference, and then we memoize this result to use in future calculations.

Here’s an example:

```def findLAS(A):
def recurse(i, diff, lookup):
if (i, diff) in lookup:
return lookup[(i, diff)]
max_len = 1
for j in range(i):
if A[i] - A[j] == diff:
max_len = max(max_len, recurse(j, diff, lookup) + 1)
lookup[(i, diff)] = max_len
return max_len

max_length = 0
lookup = {}
for i in range(len(A)):
for j in range(i):
diff = A[i] - A[j]
max_length = max(max_length, recurse(i, diff, lookup))
return max_length

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

Output: `4`

In this example, `recurse` is the recursive function that takes the current index and the difference to compute the length of the subsequence. Results are stored in a lookup dictionary to prevent recalculating the same state, which improves the efficiency of the recursive approach.

## Method 3: Hashing with a Single Loop

The single loop with hashing method uses a hash map to store the lengths of arithmetic subsequences with different common differences. This reduces the time complexity of the problem to a single loop, making it more efficient than the previous methods for large inputs.

Here’s an example:

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

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

Output: `4`

The code snippet uses a dictionary `dp` to keep track of the sequences counting the number of times a particular difference appears with different starting indices. It initializes the sequence length to 1 if not already present and then iterates through every pair of indices `i` and `j`, updating the count.

## Method 4: Brute Force

The brute force approach tries out every possible subsequence to check if it is arithmetic or not. It’s the most straightforward method but also the least efficient, particularly for large lists, as it has a time complexity of O(n^2 * 2^n) due to checking all subsequences for each pair of indices.

Here’s an example:

```from itertools import combinations

def check_arithmetic(seq):
if len(seq) < 2:
return True
diff = seq[1] - seq[0]
for i in range(2, len(seq)):
if seq[i] - seq[i-1] != diff:
return False
return True

def longest_arith_seq_length(A):
max_length = 0
for size in range(2, len(A)+1):
for subseq in combinations(A, size):
if check_arithmetic(subseq):
max_length = max(max_length, size)
return max_length

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

Output: `4`

The code applies the brute force strategy by using `combinations` from the itertools module to generate all possible subsequences of the input list. The function `check_arithmetic()` is then used to verify whether a subsequence is arithmetic, updating `max_length` accordingly.

## Bonus One-Liner Method 5: Advanced Mathematical Approaches

It’s also possible to devise an advanced mathematical formula or a heuristic that computes the length of the longest arithmetic subsequence directly, under certain constraints. Such methods may rely on the properties of the input array and require a deep understanding of number theory; however, a generic one-liner solution for this problem is not readily available.

Example and output are not applicable, as the practical implementation of such methods would be beyond the scope of this article.

## Summary/Discussion

• Method 1: Dynamic Programming. Efficient for moderately sized lists. Not suitable for large lists due to O(n^2) space and time complexity.
• Method 2: Recursion with Memoization. Speeds up the recursive solution with less repeated work. Can still be slow for large inputs due to the overhead of recursion and memory usage.
• Method 3: Hashing with a Single Loop. More efficient for larger inputs due to reduced complexity. Requires a good understanding of hash maps.
• Method 4: Brute Force. Simplest to understand and implement but highly inefficient for any input of a non-trivial size.
• Method 5: Advanced Mathematical Approaches. Can be highly efficient if applicable, but is often non-trivial to find and implement.