Arithmetic Slices - Practice Coding Problems

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

Understanding the Visualization

Input Analysis

Array [1,2,3,4] with consistent differences

Find Patterns

Identify arithmetic sequences of length ≥3

Count Slices

Total arithmetic subarrays found

Key Takeaway

🎯 Key Insight: Each time we extend an arithmetic sequence, we create multiple new slices at once

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

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n³)	O(1)	Check every possible subarray of length 3 or more for arithmetic property
Dynamic Programming - Count Extensions	O(n)	O(n)	Track how many arithmetic slices end at each position
Space Optimized DP	O(n)	O(1)	Same DP logic but using only constant space

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

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and differences

✓ Linear 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