Can Make Arithmetic Progression From Sequence

Can Make Arithmetic Progression From Sequence - Problem

Array Sorting Easy

An arithmetic progression (AP) is a sequence where the difference between consecutive elements remains constant. For example, [2, 4, 6, 8] has a common difference of 2, while [10, 7, 4, 1] has a common difference of -3.

Given an array of integers arr, determine if you can rearrange the elements to form an arithmetic progression. Return true if it's possible, false otherwise.

Key insight: You're allowed to reorder the array elements in any way you want - the challenge is determining if such an arrangement exists.

Input & Output

example_1.py — Basic AP

$ Input: arr = [3, 5, 1]

› Output: true

💡 Note: After sorting: [1, 3, 5]. Differences: 3-1=2, 5-3=2. All differences equal 2, so it forms an arithmetic progression.

example_2.py — No valid AP

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

› Output: false

💡 Note: After sorting: [1, 2, 4]. Differences: 2-1=1, 4-2=2. Since 1 ≠ 2, no arithmetic progression is possible.

example_3.py — Two elements

$ Input: arr = [7, 3]

› Output: true

💡 Note: Any array with 2 or fewer elements can always form an arithmetic progression. The difference would be 3-7=-4.

Constraints

2 ≤ arr.length ≤ 1000
-10⁶ ≤ arr[i] ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Scattered Keys

Keys [3, 5, 1] are randomly placed on the table

Arrange in Order

Place them on piano: positions 1, 3, 5

Measure Intervals

Gap from 1→3 is 2 keys, gap from 3→5 is also 2 keys

Equal Intervals!

Since all gaps are equal, we can play a consistent melody

Key Takeaway

🎯 Key Insight: Sort first, then validate - if elements can form an AP, sorting reveals the unique valid arrangement to check!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution sorts the array first (O(n log n)), then validates if consecutive differences are equal (O(n)). Key insight: if elements can form an AP, sorting them gives us the unique valid arrangement to check.

Common Approaches

Approach	Time	Space	Notes
✓ Sort and Validate (Optimal)	O(n log n)	O(1)	Sort the array first, then check if consecutive differences are equal
Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check if any forms an arithmetic progression

Sort and Validate (Optimal) — Algorithm Steps

Sort the array in ascending order
Calculate the difference between the first two elements
Iterate through remaining elements checking if each difference matches
Return true if all differences are equal, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with unsorted array [3, 5, 1]

Sort Array

Sort to get potential AP order [1, 3, 5]

Calculate First Difference

diff = 3 - 1 = 2

Validate All Differences

Check if 5 - 3 = 2 (matches!)

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool canMakeArithmeticProgression(int* arr, int arrSize) {
    if (arrSize <= 2) {
        return true;
    }
    
    // Sort the array
    qsort(arr, arrSize, sizeof(int), compare);
    
    // Check if differences between consecutive elements are equal
    int diff = arr[1] - arr[0];
    for (int i = 2; i < arrSize; i++) {
        if (arr[i] - arr[i-1] != diff) {
            return false;
        }
    }
    
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting step, validation is O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables (excluding sorting space)

✓ Linear Space

28.5K Views

Medium Frequency

~8 min Avg. Time

892 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

Sort and Validate (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler