Arithmetic Slices

Arithmetic Slices - Problem

An integer array 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.

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

A subarray is a contiguous subsequence of the array.

Input & Output

Example 1 — Basic Arithmetic Sequence

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

› Output: 3

💡 Note: Three arithmetic slices: [1,2,3] (diff=1), [2,3,4] (diff=1), and [1,2,3,4] (diff=1)

Example 2 — Constant Sequence

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

› Output: 3

💡 Note: Three arithmetic slices with diff=0: [1,1,1] at positions 0-2, [1,1,1] at positions 1-3, and [1,1,1,1] at positions 0-3

Example 3 — No Arithmetic Slices

$ Input: nums = [1,2,4]

› Output: 0

💡 Note: Only one possible subarray [1,2,4], but differences are 1 and 2, so not arithmetic

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that when we find three consecutive elements with the same difference, we can extend all previous arithmetic slices ending at the previous position and create one new slice. The optimal approach uses dynamic programming in O(n) time and can be space-optimized to O(1). Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

Generate all possible subarrays with at least 3 elements and check if each one has consistent differences between consecutive elements. Count those that satisfy the arithmetic property.

Dynamic Programming - Count Extensions

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

Use dynamic programming where dp[i] represents the number of arithmetic slices ending at position i. When we find three consecutive elements with the same difference, we can extend all previous slices plus create a new one.

Space Optimized DP

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

Instead of maintaining a full DP array, we only need to track the count of arithmetic slices ending at the current position. This reduces space complexity to O(1) while maintaining the same time complexity.

Brute Force - Check All Subarrays — Algorithm Steps

Iterate through all starting positions
For each start, try all ending positions (length ≥ 3)
Check if subarray has consistent differences
Count valid arithmetic subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Try all possible starting and ending positions

Check Each

Verify if differences are consistent

Count Valid

Sum up arithmetic subarrays found

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int count = 0;
    
    // Check all subarrays of length 3 or more
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 2; j < numsSize; j++) {
            // Check if subarray from i to j is arithmetic
            int isArithmetic = 1;
            int diff = nums[i + 1] - nums[i];
            
            for (int k = i + 1; k < j; k++) {
                if (nums[k + 1] - nums[k] != diff) {
                    isArithmetic = 0;
                    break;
                }
            }
            
            if (isArithmetic) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int size = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position, end position, and checking each subarray

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track positions and differences

⚡ Linearithmic Space

87.5K Views

Medium Frequency

~15 min Avg. Time

3.2K 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 - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler