Longest Arithmetic Subsequence - Practice Coding Problems

Longest Arithmetic Subsequence - Problem

Given an array nums of integers, find the length of the longest arithmetic subsequence.

An arithmetic subsequence is a sequence where the difference between consecutive elements is constant. For example, [2, 4, 6, 8] has a common difference of 2.

Important: A subsequence maintains the relative order of elements from the original array, but elements don't need to be contiguous. You can skip elements as needed.

Example: In array [3, 6, 9, 12], the entire array forms an arithmetic subsequence of length 4 with difference 3.

Input & Output

example_1.py — Basic Case

$ Input: [3, 6, 9, 12]

› Output: 4

💡 Note: The entire array forms an arithmetic sequence with common difference 3: [3, 6, 9, 12]. Length = 4.

example_2.py — Mixed Sequences

$ Input: [9, 4, 7, 2, 10]

› Output: 3

💡 Note: The longest arithmetic subsequence is [4, 7, 10] with common difference 3, or [9, 7, 2] with difference -2. Both have length 3.

example_3.py — No Long Sequence

$ Input: [20, 1, 15, 3, 10, 5, 8]

› Output: 4

💡 Note: The longest arithmetic subsequence is [20, 15, 10, 5] with common difference -5. Length = 4.

Constraints

2 ≤ nums.length ≤ 1000
-500 ≤ nums[i] ≤ 500
All elements in nums are integers

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Look for pairs of elements that could start an arithmetic sequence

Calculate Intervals

For each pair, determine the common difference (musical interval)

Extend Sequences

Find additional elements that continue each pattern

Track the Longest

Remember the longest arithmetic sequence found

Key Takeaway

🎯 Key Insight: Dynamic programming helps us efficiently track all possible arithmetic patterns by remembering what sequences we've already built, avoiding redundant work.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses dynamic programming to track arithmetic sequences efficiently. For each position and difference, we maintain the length of the longest sequence ending at that position with that difference. This achieves O(n²) time complexity and avoids the redundant calculations of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Pairs)	O(n³)	O(1)	Try every pair as the start of an arithmetic sequence and extend it as far as possible
Dynamic Programming (Optimal)	O(n²)	O(n²)	Use DP table to track arithmetic sequences ending at each position with each difference

Brute Force (Try All Pairs) — Algorithm Steps

For each element at index i, consider it as the first element
For each element at index j > i, consider it as the second element
Calculate the common difference: diff = nums[j] - nums[i]
Scan remaining elements to find how many continue this arithmetic sequence
Keep track of the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose First Pair

Pick two elements as the start of potential sequence

Calculate Difference

Find the common difference between the pair

Extend Sequence

Look for more elements that continue the pattern

Track Maximum

Keep track of the longest sequence found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int max(int a, int b) {
    return a > b ? a : b;
}

int longestArithSeqLength(int* nums, int n) {
    if (n <= 2) return n;
    
    int maxLength = 2;
    
    // Try every pair as the start of arithmetic sequence
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
            // Calculate common difference
            int diff = nums[j] - nums[i];
            int length = 2;
            int lastNum = nums[j];
            
            // Look for more elements that continue this sequence
            for (int k = j + 1; k < n; k++) {
                if (nums[k] == lastNum + diff) {
                    length++;
                    lastNum = nums[k];
                }
            }
            
            maxLength = max(maxLength, length);
        }
    }
    
    return maxLength;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    int num = 0;
    int reading = 0;
    int negative = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading = 1;
        } else if (c == '-') {
            negative = 1;
            reading = 1;
        } else if (reading) {
            nums[n++] = negative ? -num : num;
            num = 0;
            reading = 0;
            negative = 0;
        }
    }
    if (reading) {
        nums[n++] = negative ? -num : num;
    }
    
    printf("%d\n", longestArithSeqLength(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: two for choosing pairs (O(n²)) and one for extending each sequence (O(n))

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

✓ Linear Space

95.7K Views

Medium Frequency

~18 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler