Arithmetic Slices - Practice Coding Problems

Arithmetic Slices - Problem

An arithmetic slice is like finding patterns in sequences! Given an integer array, we need to count how many contiguous subarrays form arithmetic progressions.

An arithmetic sequence requires:

At least 3 elements
Constant difference between consecutive elements

For example, in [1,3,5,7,9], the difference is always 2. In [7,7,7,7], the difference is 0. Even [3,-1,-5,-9] works with difference -4!

Goal: Count all possible arithmetic subarrays of length ≥ 3 in the given array.

Input: An integer array nums

Output: Total number of arithmetic subarrays

Input & Output

example_1.py — Basic Arithmetic Sequence

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

› Output: 3

💡 Note: Three arithmetic slices: [1,2,3], [2,3,4], and [1,2,3,4]. All have common difference of 1.

example_2.py — Single Arithmetic Slice

$ Input: [1,3,5,7,9]

› Output: 6

💡 Note: Six slices with difference 2: [1,3,5], [3,5,7], [5,7,9], [1,3,5,7], [3,5,7,9], [1,3,5,7,9].

example_3.py — No Arithmetic Slices

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

› Output: 0

💡 Note: No arithmetic slices possible as differences are not constant: 1, 2, 4 respectively.

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern Start

Find where arithmetic sequence begins (when 3 consecutive elements have same difference)

Track Pattern Length

Continue counting while the pattern holds, reset when it breaks

Calculate Contributions

Each position in a sequence of length L contributes L new slices ending at that position

Key Takeaway

🎯 Key Insight: Instead of checking every subarray, track the length of current arithmetic sequence. When sequence length is L, it contributes L new slices ending at current position!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only need to track current sequence length, no extra arrays needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000
Arithmetic slice requires at least 3 elements

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal solution uses dynamic programming to solve this in O(n) time. Key insight: track the length of current arithmetic sequence and add it to total count, as a sequence of length k contributes k new slices ending at current position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray of length ≥ 3 to see if it's arithmetic
Dynamic Programming (Optimal)	O(n)	O(1)	Track the length of current arithmetic sequence and calculate contributions

Brute Force (Check All Subarrays) — Algorithm Steps

For each starting position i
For each ending position j (where j-i ≥ 2)
Check if subarray from i to j has constant difference
If yes, increment counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subarrays

Start with every possible starting position

Check Each Subarray

For each subarray ≥ 3 elements, verify arithmetic property

Count Valid Ones

Increment counter when arithmetic sequence is found

Code -

solution.c — C

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

int numberOfArithmeticSlices(int* nums, int numsSize) {
    if (numsSize < 3) return 0;
    
    int count = 0;
    
    // Check all possible subarrays of length >= 3
    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 diff = nums[i + 1] - nums[i];
            int isArithmetic = 1;
            
            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() {
    int nums[1000];
    int size = 0;
    char ch;
    int num = 0;
    int sign = 1;
    
    scanf("%c", &ch); // skip '['
    while (scanf("%c", &ch) && ch != ']') {
        if (ch >= '0' && ch <= '9') {
            num = num * 10 + (ch - '0');
        } else if (ch == '-') {
            sign = -1;
        } else if (ch == ',' || ch == ']') {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
        }
    }
    if (num != 0) nums[size++] = num * sign;
    
    printf("%d\n", numberOfArithmeticSlices(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) for generating subarrays and O(n) for checking each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and differences

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5000
-1000 ≤ nums[i] ≤ 1000
Arithmetic slice requires at least 3 elements

42.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler