Longest Arithmetic Subsequence of Given Difference

Longest Arithmetic Subsequence of Given Difference - Problem

You're given an integer array arr and an integer difference. Your task is to find the longest arithmetic subsequence where consecutive elements have exactly the specified difference.

An arithmetic subsequence is a sequence where each element differs from the previous one by a constant value. A subsequence maintains the original order of elements but allows skipping elements.

Example: In array [1, 3, 5, 7] with difference = 2, the entire array forms an arithmetic subsequence of length 4, since each element is 2 more than the previous: 1→3→5→7.

Goal: Return the length of the longest such subsequence.

Input & Output

example_1.py — Basic Sequence

$ Input: arr = [1,2,3,4], difference = 1

› Output: 4

💡 Note: The entire array forms an arithmetic sequence with difference 1: 1→2→3→4. Each element differs from the previous by exactly 1.

example_2.py — Sparse Sequence

$ Input: arr = [1,3,5,7], difference = 2

› Output: 4

💡 Note: The entire array forms an arithmetic sequence with difference 2: 1→3→5→7. Each element differs from the previous by exactly 2.

example_3.py — Mixed Elements

$ Input: arr = [1,5,7,8,5,3,4,2,1], difference = -2

› Output: 4

💡 Note: The longest sequence with difference -2 is: 7→5→3→1. This subsequence maintains the original order and each element is 2 less than the previous.

Constraints

1 ≤ arr.length ≤ 10⁵
-10⁴ ≤ arr[i], difference ≤ 10⁴
Array elements can be negative, zero, or positive

Visualization

Tap to expand

Understanding the Visualization

Encounter Element

For each array element, we ask: 'Can I extend an existing chain?'

Look Backward

Check if (current_number - difference) has an existing chain

Extend or Start

If found, extend that chain by 1; otherwise start a new chain of length 1

Update Records

Store the new chain length for the current number and track the maximum

Key Takeaway

🎯 Key Insight: Instead of trying every possible starting point (O(n²)), we build chains by looking backward for predecessors. Each element can extend at most one existing chain, making this O(n) optimal.

Asked in

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

The optimal solution uses a hash map to track the longest arithmetic subsequence ending at each value. For each element, we check if we can extend a previous sequence by looking for (current_element - difference) in our hash map. This approach runs in O(n) time and O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Use hash map to track longest sequence ending at each value
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible starting position and extend chains element by element

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash map to store longest sequence length ending at each value
Iterate through each element in the array
For current element, check if (element - difference) exists in hash map
If exists, extend that sequence: length = hash_map[element - difference] + 1
If not exists, start new sequence: length = 1
Update hash map with current element and its sequence length
Track the maximum sequence length seen

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Predecessor

For each element, look for (element - difference) in hash map

Extend or Start

If predecessor exists, extend its chain; otherwise start new chain

Update Map

Store the longest chain length ending at current element

Track Maximum

Keep track of the longest chain seen so far

Code -

solution.c — C

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

#define HASH_SIZE 100003

typedef struct Node {
    int key;
    int value;
    struct Node* next;
} Node;

Node* hashTable[HASH_SIZE];

int hash(int key) {
    return ((key % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
}

void put(int key, int value) {
    int h = hash(key);
    Node* node = hashTable[h];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    Node* newNode = malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = hashTable[h];
    hashTable[h] = newNode;
}

int get(int key) {
    int h = hash(key);
    Node* node = hashTable[h];
    while (node) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

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

int longestSubsequence(int* arr, int arrSize, int difference) {
    int maxLength = 1;
    
    for (int i = 0; i < arrSize; i++) {
        int num = arr[i];
        int prevLength = get(num - difference);
        int currentLength = prevLength + 1;
        put(num, currentLength);
        maxLength = max(maxLength, currentLength);
    }
    
    return maxLength;
}

int main() {
    int arr[] = {1, 2, 3, 4};
    int arrSize = 4;
    int difference = 1;
    printf("%d\n", longestSubsequence(arr, arrSize, difference));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with O(1) hash map operations per element

✓ Linear Growth

Space Complexity

O(n)

Hash map can store up to n unique elements in worst case

⚡ Linearithmic Space

58.2K Views

High Frequency

~18 min Avg. Time

1.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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler