Can Make Arithmetic Progression From Sequence

Can Make Arithmetic Progression From Sequence - Problem

Array Sorting Easy

A sequence of numbers is called an arithmetic progression if the difference between any two consecutive elements is the same.

Given an array of numbers arr, return true if the array can be rearranged to form an arithmetic progression. Otherwise, return false.

Example: The array [3, 5, 1] can be rearranged to [1, 3, 5] which forms an arithmetic progression with common difference 2.

Input & Output

Example 1 — Basic Case

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

› Output: true

💡 Note: We can rearrange the array as [1,3,5] which forms an arithmetic progression with common difference 2.

Example 2 — Already Sorted

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

› Output: false

💡 Note: The differences are 2-1=1 and 4-2=2. Since 1 ≠ 2, it cannot form an arithmetic progression.

Example 3 — Equal Elements

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

› Output: true

💡 Note: All elements are the same, so the common difference is 0. This forms an arithmetic progression.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that any arithmetic progression, when sorted, will have equal consecutive differences. The optimal approach is to sort the array first, then verify all consecutive differences are identical. Time: O(n log n), Space: O(1).

Common Approaches

✓ Generate All Permutations

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

Generate all possible permutations of the array and check each one to see if it forms an arithmetic progression by verifying consecutive differences are equal.

Mathematical Property Check

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

For an arithmetic progression with n terms, if we know the first and last terms after sorting, we can calculate the expected common difference. Then verify this works for all elements.

Sort and Check Differences

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

Sort the array in ascending order, then check if all consecutive differences are the same. This works because any arithmetic progression, when sorted, will have equal consecutive differences.

Generate All Permutations — Algorithm Steps

Generate all permutations of the array
For each permutation, check if consecutive differences are equal
Return true if any permutation forms arithmetic progression

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements

Check Each

Verify if consecutive differences are equal

Result

Return true if any arrangement works

Code -

solution.c — C

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

bool isArithmeticProgression(int* nums, int size) {
    if (size <= 2) return true;
    int diff = nums[1] - nums[0];
    for (int i = 2; i < size; i++) {
        if (nums[i] - nums[i-1] != diff) return false;
    }
    return true;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

bool permute(int* arr, int start, int end) {
    if (start == end) {
        return isArithmeticProgression(arr, end + 1);
    }
    
    for (int i = start; i <= end; i++) {
        swap(&arr[start], &arr[i]);
        if (permute(arr, start + 1, end)) return true;
        swap(&arr[start], &arr[i]);
    }
    return false;
}

bool solution(int* arr, int size) {
    return permute(arr, 0, size - 1);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    bool result = solution(arr, size);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to verify

⚡ Linearithmic

Space Complexity

O(n)

Space for generating permutations and recursion stack

✓ Linear Space

28.0K Views

Medium Frequency

~10 min Avg. Time

847 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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler