5 Best Ways to Find Number of Arithmetic Subsequences from a List in Python

Rate this post

πŸ’‘ Problem Formulation: Given a list of numbers, the task is to find and count all the arithmetic subsequences within that list. An arithmetic subsequence is a sequence of at least three numbers where the difference between consecutive elements is constant. For example, given the list [1, 2, 3, 4], a valid arithmetic subsequence would be [1, 2, 3], and the desired output for the number of such subsequences would be 3.

Method 1: Brute Force Approach

An exhaustive search looks at every possible subsequence and checks if it is arithmetic. It is not efficient for large lists due to its high time complexity, but it is straightforward to implement.

Here’s an example:

def arithmetic_subseq_count_brute(nums):
    count = 0
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            diff = nums[j] - nums[i]
            prev = nums[j]
            subseq = 2
            for k in range(j+1, len(nums)):
                if nums[k] - prev == diff:
                    prev = nums[k]
                    subseq += 1
                    if subseq >= 3:
                        count += 1
    return count

print(arithmetic_subseq_count_brute([1, 2, 3, 4]))

The output of this code snippet would be:


This Python function counts the arithmetic subsequences by checking all possible subsequence combinations in the given list. It only counts subsequences with a length of three or more to ensure they are indeed arithmetic.

Method 2: Using Hash Maps

This method involves using a hash map (dictionary in Python) to keep track of the potential arithmetic subsequences ending at each index. It is more efficient than the brute force approach since it avoids redundant calculations, making it better suited for longer lists of numbers.

Here’s an example:

from collections import defaultdict

def arithmetic_subseq_count_hash(nums):
    count = 0
    dp = [defaultdict(int) for _ in range(len(nums))]
    for i in range(len(nums)):
        for j in range(i):
            diff = nums[i] - nums[j]
            dp[i][diff] += 1
            if diff in dp[j]:
                dp[i][diff] += dp[j][diff]
                count += dp[j][diff]
    return count

print(arithmetic_subseq_count_hash([1, 2, 3, 4]))

The output of this code snippet would be:


In the provided code, a list of dictionaries is created to store the number of times a particular difference (key) appears (value) ending at an index of the list. It updates the count of arithmetic subsequences by adding the number of existing subsequences with the same common difference found in previous positions.

Method 3: Dynamic Programming with Space Optimization

Dynamic programming can be further optimized to reduce space complexity. This method improves upon the second method by optimizing the storage of the hash maps to only the necessary data. This reduces space complexity without sacrificing the time efficiency gains of the hash map method.

Here’s an example:

def arithmetic_subseq_count_dp_optimized(nums):
    count = 0
    dp = defaultdict(int)
    for i in range(len(nums)):
        new_dp = defaultdict(int)
        for j in range(i):
            diff = nums[i] - nums[j]
            new_dp[diff] += dp[diff] + 1
            count += dp[diff]
        dp = new_dp
    return count

print(arithmetic_subseq_count_dp_optimized([1, 2, 3, 4]))

The output of this code snippet would be:


This approach maintains a single dictionary, thereby reducing space complexity. At each step, it creates a new dictionary representing the current state and only transfers necessary count information from the previous state.

Method 4: Recursion with Memoization

Another approach is to use recursion with memoization. It explores each potential arithmetic subsequence and stores already computed results to avoid redundant calculations. While not as efficient as dynamic programming for this particular problem, it is a useful technique for problems with overlapping subproblems.

Here’s an example:

def arithmetic_subseq_count_memo(nums):
    memo = {}
    def count(i, diff, length):
        if (i, diff, length) in memo:
            return memo[(i, diff, length)]
        if i >= len(nums):
            return 1 if length >= 3 else 0
        take = count(i+1, nums[i] - diff, length+1) if length > 1 or nums[i] - diff == diff else 0
        leave = count(i+1, diff, length)
        memo[(i, diff, length)] = take + leave
        return memo[(i, diff, length)]
    ans = 0
    for i in range(len(nums) - 2):
        for j in range(i+1, len(nums) - 1):
            ans += count(j + 1, nums[j] - nums[i], 2)
    return ans

print(arithmetic_subseq_count_memo([1, 2, 3, 4]))

The output of this code snippet would be:


This recursion with memoization function explores both possibilities of including or excluding the current element in an arithmetic subsequence and caches the results for future reference, optimizing overlapping subproblem computations.

Bonus One-Liner Method 5: Naive Recursive Approach

The naive recursive approach generates all possible combinations of sequences and identifies those that are arithmetic. This approach is not recommended for large inputs due to its exponential time complexity but is included as a conceptual illustration.

Here’s an example:

def arithmetic_subseq_count_naive(nums):
    def is_arithmetic(seq):
        return all(seq[i] - seq[i-1] == seq[1] - seq[0] for i in range(2, len(seq)))

    def count_arithmetic_sequences(start=0, sequence=()):
        if len(sequence) >= 3 and is_arithmetic(sequence):
            yield 1
        if start < len(nums):
            yield from count_arithmetic_sequences(start+1, sequence)
            yield from count_arithmetic_sequences(start+1, sequence + (nums[start],))

    return sum(count_arithmetic_sequences())

print(arithmetic_subseq_count_naive([1, 2, 3, 4]))

The output of the above code snippet would be:


This simplistic method relies on recursion to explore all subsequences and a helper function to check whether a subsequence is arithmetic. It is a brute force solution that may serve educational purposes but is impractical for larger datasets due to poor scalability.


  • Method 1: Brute Force Approach. Simple to understand and implement. Not suitable for large lists due to high time complexity.
  • Method 2: Using Hash Maps. More efficient than brute force. Suitable for larger lists but still has higher space complexity.
  • Method 3: Dynamic Programming with Space Optimization. Improved version of the hash map approach with lower space complexity. Ideal for large inputs.
  • Method 4: Recursion with Memoization. Conceptually interesting, but can be slower than other optimization methods. Good for practice with overlapping subproblems.
  • Bonus Method 5: Naive Recursive Approach. Very inefficient for all but the smallest datasets. Included as a conceptual exercise.