Arithmetic Slices II - Subsequence

Arithmetic Slices II - Subsequence - Problem

Given an integer array nums, return the number of all the arithmetic subsequences of nums.

A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.

For example, [1, 3, 5, 7, 9], [7, 7, 7, 7], and [3, -1, -5, -9] are arithmetic sequences.

For example, [1, 1, 2, 5, 7] is not an arithmetic sequence.

A subsequence of an array is a sequence that can be formed by removing some elements (possibly none) of the array.

For example, [2,5,10] is a subsequence of [1,2,1,2,4,1,5,10].

The test cases are generated so that the answer fits in 32-bit integer.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,4,6,8]

› Output: 3

💡 Note: Three arithmetic subsequences: [2,4,6], [4,6,8], and [2,4,6,8]. All have difference of 2.

Example 2 — Single Element Repeated

$ Input: nums = [7,7,7,7]

› Output: 4

💡 Note: All subsequences of length ≥3 are arithmetic with difference 0: [7,7,7] appears in 4 different ways, plus [7,7,7,7].

Example 3 — No Valid Subsequences

$ Input: nums = [2,3,5]

› Output: 0

💡 Note: Only one subsequence of length 3: [2,3,5]. Differences are 1 and 2, so not arithmetic.

Constraints

1 ≤ nums.length ≤ 1000
-2³¹ ≤ nums[i] ≤ 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 8

The key insight is to use dynamic programming to track arithmetic sequences ending at each position with each difference. For each new element, we extend existing sequences and count those with 3+ elements. The optimal approach uses a 2D DP structure with hashmaps, achieving O(n²) time and O(n²) space complexity.

Common Approaches

✓ Math

⏱️ Time: N/A Space: N/A

Brute Force - Generate All Subsequences

⏱️ Time: O(2ⁿ × n) Space: O(n)

Generate all possible subsequences of length 3 or more and check each one to see if it forms an arithmetic sequence. This involves checking if consecutive differences are equal.

Dynamic Programming with HashMap

⏱️ Time: O(n²) Space: O(n²)

For each position, maintain a map of differences to count how many arithmetic sequences with that difference end at this position. When we see a new element, we can extend all previous sequences.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

// Integer power function to avoid math library dependency
long long intPow(int base, int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

// Count digits without using log10
int countDigits(int n) {
    if (n == 0) return 1;
    int count = 0;
    while (n > 0) {
        count++;
        n /= 10;
    }
    return count;
}

bool solution(int n) {
    if (n < 0) return false;
    if (n == 0) return true;
    
    // Count digits
    int original = n;
    int numDigits = countDigits(n);
    long long digitSum = 0;
    
    // Extract digits and calculate sum
    int temp = n;
    while (temp > 0) {
        int digit = temp % 10;
        digitSum += intPow(digit, numDigits);
        temp /= 10;
    }
    
    return digitSum == original;
}

int main() {
    int n;
    scanf("%d", &n);
    bool result = solution(n);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

67.6K Views

Medium Frequency

~35 min Avg. Time

1.9K 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