Codestin Search App

Arithmetic Slices II - Subsequence - Problem

Count All Arithmetic Subsequences

Given an integer array nums, your task is to count all possible arithmetic subsequences that can be formed from the array. An arithmetic subsequence is a sequence of at least 3 elements where the difference between consecutive elements is constant.

What makes this challenging:
• We're looking for subsequences (not subarrays) - elements don't need to be adjacent
• We need to count ALL possible arithmetic subsequences, not just find one
• The common difference can be any integer (positive, negative, or zero)

Examples of arithmetic sequences:
• [1, 3, 5, 7, 9] - difference of 2
• [7, 7, 7, 7] - difference of 0
• [10, 5, 0, -5] - difference of -5

Goal: Return the total count of all arithmetic subsequences of length ≥ 3.

Input & Output

example_1.py — Basic Arithmetic Sequence

$ Input: [2, 4, 6, 8, 10]

› Output: 7

💡 Note: The arithmetic subsequences are: [2,4,6], [4,6,8], [6,8,10], [2,4,6,8], [4,6,8,10], [2,4,6,8,10] (6 total) + [2,6,10] which is NOT arithmetic, so we have exactly 7 valid subsequences with difference 2.

example_2.py — Array with Duplicates

$ Input: [7, 7, 7, 7, 7]

› Output: 16

💡 Note: All elements are the same, so difference = 0. For n=5 identical elements, we can choose any 3 elements (C(5,3)=10), any 4 elements (C(5,4)=5), or all 5 elements (C(5,5)=1). Total: 10+5+1=16 arithmetic subsequences.

example_3.py — Mixed Differences

$ Input: [1, 2, 3, 4]

› Output: 3

💡 Note: Found arithmetic subsequences: [1,2,3] (diff=1), [2,3,4] (diff=1), and [1,2,3,4] (diff=1). Total of 3 subsequences, all with common difference 1.

Constraints

1 ≤ nums.length ≤ 1000
-2³¹ ≤ nums[i] ≤ 2³¹ - 1
The answer is guaranteed to fit in a 32-bit integer
Array elements can be negative, positive, or zero
Arithmetic subsequences must have at least 3 elements

Visualization

Tap to expand

Understanding the Visualization

Scan Each Note Position

For each note (array element), consider it as the end of potential musical scales

Look Back at Previous Notes

Check all previous notes to see what musical intervals we can create

Extend Existing Scales

If we find matching intervals from previous positions, extend those scales

Count Valid Scales

Track all scales with 3+ notes that maintain consistent intervals

Key Takeaway

🎯 Key Insight: Instead of generating all possible subsequences (exponential time), we use dynamic programming to build arithmetic subsequences incrementally, tracking how many end at each position with each possible difference.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Dynamic Programming with HashMap to efficiently count arithmetic subsequences. For each position i, we maintain dp[i][d] representing the number of arithmetic subsequences ending at index i with common difference d. The key insight is that when we extend an arithmetic subsequence, we can count how many new valid subsequences (length ≥ 3) are formed. Time complexity: O(n²), Space complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with HashMap (Optimal)	O(n²)	O(n²)	Use DP with hashmaps to track arithmetic subsequences ending at each position
Brute Force (Generate All Subsequences)	O(2^n * n)	O(n)	Generate all possible subsequences and check which ones are arithmetic

Dynamic Programming with HashMap (Optimal) — Algorithm Steps

For each element at index i, consider it as the last element of arithmetic subsequences
Look at all previous elements j < i and calculate difference d = nums[i] - nums[j]
If dp[j][d] exists, we can extend those subsequences to include nums[i]
Add dp[j][d] to our result (these become valid 3+ length subsequences)
Update dp[i][d] += (dp[j][d] + 1) to track new subsequences ending at i

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Array

Create dp[i] hashmap for each position to store subsequence counts by difference

Process Each Position

For each element, consider it as the end of arithmetic subsequences

Look Back at Previous Elements

Calculate differences and extend existing arithmetic subsequences

Update Counts

Add valid extensions to result and update DP state for future extensions

Code -

solution.c — C

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

#define MAX_SIZE 1000
#define HASH_SIZE 10007

typedef struct HashNode {
    long long key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    HashNode* buckets[HASH_SIZE];
} HashMap;

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

int get(HashMap* map, long long key) {
    int idx = hash(key);
    HashNode* node = map->buckets[idx];
    while (node) {
        if (node->key == key) return node->value;
        node = node->next;
    }
    return 0;
}

void put(HashMap* map, long long key, int value) {
    int idx = hash(key);
    HashNode* node = map->buckets[idx];
    while (node) {
        if (node->key == key) {
            node->value = value;
            return;
        }
        node = node->next;
    }
    node = (HashNode*)malloc(sizeof(HashNode));
    node->key = key;
    node->value = value;
    node->next = map->buckets[idx];
    map->buckets[idx] = node;
}

int numberOfArithmeticSlices(int* nums, int n) {
    if (n < 3) return 0;
    
    HashMap dp[MAX_SIZE];
    for (int i = 0; i < n; i++) {
        memset(&dp[i], 0, sizeof(HashMap));
    }
    
    int result = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            long long diff = (long long)nums[i] - nums[j];
            int countAtJ = get(&dp[j], diff);
            result += countAtJ;
            put(&dp[i], diff, get(&dp[i], diff) + countAtJ + 1);
        }
    }
    
    return result;
}

int main() {
    int nums[MAX_SIZE];
    int n = 0;
    char c;
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", numberOfArithmeticSlices(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loop through all pairs of elements, hashmap operations are O(1)

⚠ Quadratic Growth

Space Complexity

O(n²)

In worst case, each position stores hashmaps with O(n) differences

⚠ Quadratic Space

89.4K Views

High Frequency

~25 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

Dynamic Programming with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler