Arrays January 20 ,2026

Longest Arithmetic Subarray

Problem Statement

You are given an array of integers arr of length n.

An arithmetic subarray is a contiguous subarray where the difference between consecutive elements is constant.

Your task is to find the length of the longest arithmetic subarray.

Example 1

Input

arr = [10, 7, 4, 6, 8, 10, 11]

Output

Explanation

The longest arithmetic subarray is:

[4, 6, 8, 10]

Common difference = 2

Example 2

Input

arr = [9, 7, 5, 3]

Output

Constraints

2 ≤ n ≤ 10^5
Elements can be negative
Order matters (subarray, not subsequence)

Why This Problem Is Important

Asked in Google, Amazon, Microsoft
Tests:
- Array traversal
- Difference tracking
- Sliding window intuition
Foundation for:
- Pattern recognition problems
- Optimized window techniques

Approaches Overview

Approach	Technique	Time	Space
Approach 1	Brute Force	O(n³)	O(1)
Approach 2	Fix Start, Extend	O(n²)	O(1)
Approach 3	Sliding Window (Optimal)	O(n)	O(1)

Approach 1: Brute Force (O(n³))

Idea

Check every possible subarray
Verify if it's arithmetic
Track maximum length

Complexity

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

Python

def is_arithmetic(arr, l, r):
    if r - l + 1 < 2:
        return True
    diff = arr[l+1] - arr[l]
    for i in range(l+1, r):
        if arr[i+1] - arr[i] != diff:
            return False
    return True

arr = [10, 7, 4, 6, 8, 10, 11]
n = len(arr)
ans = 2

for i in range(n):
    for j in range(i+1, n):
        if is_arithmetic(arr, i, j):
            ans = max(ans, j - i + 1)

print(ans)

C++

#include 
using namespace std;

bool isArithmetic(vector& arr, int l, int r) {
    int diff = arr[l+1] - arr[l];
    for(int i = l+1; i < r; i++) {
        if(arr[i+1] - arr[i] != diff)
            return false;
    }
    return true;
}

int main() {
    vector arr = {10,7,4,6,8,10,11};
    int n = arr.size(), ans = 2;

    for(int i = 0; i < n; i++) {
        for(int j = i+1; j < n; j++) {
            if(isArithmetic(arr, i, j))
                ans = max(ans, j - i + 1);
        }
    }

    cout << ans;
}

Java

public class Main {
    static boolean isArithmetic(int[] arr, int l, int r) {
        int diff = arr[l+1] - arr[l];
        for(int i = l+1; i < r; i++) {
            if(arr[i+1] - arr[i] != diff)
                return false;
        }
        return true;
    }

    public static void main(String[] args) {
        int[] arr = {10,7,4,6,8,10,11};
        int n = arr.length, ans = 2;

        for(int i=0;i

C

#include 
#include 

bool isArithmetic(int arr[], int l, int r) {
    int diff = arr[l+1] - arr[l];
    for(int i = l+1; i < r; i++) {
        if(arr[i+1] - arr[i] != diff)
            return false;
    }
    return true;
}

int main() {
    int arr[] = {10,7,4,6,8,10,11};
    int n = 7, ans = 2;

    for(int i=0;i ans) ans = j-i+1;
            }
        }
    }

    printf("%d", ans);
    return 0;
}

JavaScript

function isArithmetic(arr, l, r) {
    let diff = arr[l+1] - arr[l];
    for(let i = l+1; i < r; i++) {
        if(arr[i+1] - arr[i] !== diff)
            return false;
    }
    return true;
}

let arr = [10,7,4,6,8,10,11];
let n = arr.length, ans = 2;

for(let i=0;i

Output

Approach 2: Better Brute Force (O(n²))

Idea

Fix starting index
Extend until pattern breaks
Stop early

Complexity

Time: O(n²)
Space: O(1)

Python

arr = [10,7,4,6,8,10,11]
n = len(arr)
ans = 2

for i in range(n-1):
    diff = arr[i+1] - arr[i]
    length = 2

    for j in range(i+2, n):
        if arr[j] - arr[j-1] == diff:
            length += 1
            ans = max(ans, length)
        else:
            break

print(ans)

C++

#include 
using namespace std;

int main() {
    vector arr = {10,7,4,6,8,10,11};
    int n = arr.size(), ans = 2;

    for(int i=0;i

Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {10,7,4,6,8,10,11};
        int n = arr.length, ans = 2;

        for(int i=0;i

C

#include 

int main() {
    int arr[] = {10,7,4,6,8,10,11};
    int n = 7, ans = 2;

    for(int i=0;i ans) ans = len;
            } else break;
        }
    }

    printf("%d", ans);
}

JavaScript

let arr = [10,7,4,6,8,10,11];
let n = arr.length, ans = 2;

for(let i=0;i

Output

Approach 3: Sliding Window (Optimal O(n))

Idea

Track current difference
Expand window if same
Reset if breaks

Complexity

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

Python

arr = [10,7,4,6,8,10,11]
n = len(arr)

if n < 2:
    print(n)
else:
    diff = arr[1] - arr[0]
    curr = 2
    ans = 2

    for i in range(2, n):
        if arr[i] - arr[i-1] == diff:
            curr += 1
        else:
            diff = arr[i] - arr[i-1]
            curr = 2
        ans = max(ans, curr)

    print(ans)

💻 C++

#include 
using namespace std;

int main() {
    vector arr = {10,7,4,6,8,10,11};
    int n = arr.size();

    int diff = arr[1] - arr[0];
    int curr = 2, ans = 2;

    for(int i=2;i

Java

public class Main {
    public static void main(String[] args) {
        int[] arr = {10,7,4,6,8,10,11};
        int n = arr.length;

        int diff = arr[1] - arr[0];
        int curr = 2, ans = 2;

        for(int i=2;i

C

#include 

int main() {
    int arr[] = {10,7,4,6,8,10,11};
    int n = 7;

    int diff = arr[1] - arr[0];
    int curr = 2, ans = 2;

    for(int i=2;i ans) ans = curr;
    }

    printf("%d", ans);
}

JavaScript

let arr = [10,7,4,6,8,10,11];
let n = arr.length;

let diff = arr[1] - arr[0];
let curr = 2, ans = 2;

for(let i=2;i

Output

Final Summary

Brute Force: Concept clarity
Fix Start: Early stopping
Sliding Window: Best & interview preferred
Handles:
- Negative numbers
- Any order
Uses O(1) extra space

Next Problem in the Series

Find the Median in a Stream of Integer

Sanjiv

You must logged in to post comments.

Data Structure

Data Structure

Table of Contents

Longest Arithmetic Subarray

Problem Statement

Example 1

Input

Output

Explanation

Example 2

Input

Output

Constraints

Why This Problem Is Important

Approaches Overview

Approach 1: Brute Force (O(n³))

Idea

Complexity

Python

C++

Java

C

JavaScript

Output

Approach 2: Better Brute Force (O(n²))

Idea

Complexity

Python

C++

Java

C

JavaScript

Output

Approach 3: Sliding Window (Optimal O(n))

Idea

Complexity

Python

💻 C++

Java

C

JavaScript

Output

Final Summary

Next Problem in the Series

Related Blogs

Find the Second Smal...

Array Data Structure

Array Memory Represe...

Array Operations and...

Advantages and Disad...

Arrays in C

Vector in C++ STL

Arrays vs ArrayList...

JavaScript Arrays

Binary Search on Arr...

Two Pointers Techniq...

Prefix Sum Technique

Sliding Window Techn...

Basics of Hashing fo...

Traverse an Array

Find the Sum of All...

Find the Maximum Ele...

Find the Minimum Ele...

Count Even and Odd N...

Search an Element in...

Copy One Array into...

Reverse an Array

Print Alternate Elem...

Find the Length of a...

Check if an Array is...

Find the First Eleme...

Find the Last Elemen...

Count the Number of...

Replace All Elements...

Sum of Elements at E...

Sum of Elements at O...

Find the Average of...

Print Array Elements...

Count the Number of...

Remove Duplicate Ele...