Array With Elements Not Equal to Average of Neighbors

Array With Elements Not Equal to Average of Neighbors - Problem

You're given an array of distinct integers and need to rearrange them strategically! 🎯

The challenge: Create a new arrangement where no element equals the average of its neighbors. For any element at position i (where 1 ≤ i < array.length - 1), it should satisfy:

nums[i] ≠ (nums[i-1] + nums[i+1]) / 2

In other words, avoid creating arithmetic sequences of length 3! For example, if you have [2, 4, 6], the middle element 4 equals (2 + 6) / 2 = 4, which violates our rule.

Your task: Return any valid rearrangement that satisfies this constraint. Multiple correct answers exist!

Input & Output

example_1.py — Basic Case

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

› Output: [1,5,2,4,3]

💡 Note: After sorting and using two pointers: alternately pick from ends. Check: 5≠(1+2)/2=1.5, 2≠(5+4)/2=4.5, 4≠(2+3)/2=2.5 ✓

example_2.py — Small Array

$ Input: [6,2,0,9,7]

› Output: [0,9,2,7,6]

💡 Note: Sorted: [0,2,6,7,9]. Alternating picks create [0,9,2,7,6]. Verify: 9≠(0+2)/2=1, 2≠(9+7)/2=8, 7≠(2+6)/2=4 ✓

example_3.py — Edge Case

$ Input: [1,2,3]

› Output: [1,3,2]

💡 Note: Original [1,2,3] has 2=(1+3)/2. After rearranging to [1,3,2]: check 3≠(1+2)/2=1.5 ✓. Problem solved!

Constraints

3 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
All integers in nums are distinct
It is guaranteed that a valid arrangement exists

Visualization

Tap to expand

Understanding the Visualization

Sort by Height

Arrange people from shortest to tallest: [1,3,4,6,9]

Create Peaks and Valleys

Alternate between shortest and tallest: pick 1, then 9, then 3, then 6, then 4

Final Arrangement

Result: [1,9,3,6,4] - no one is average height of neighbors!

Key Takeaway

🎯 Key Insight: By alternating between extreme values (smallest and largest), we maximize the differences between adjacent elements, making it impossible for any middle element to equal the average of its neighbors!

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 22

The optimal approach is the Two Pointers (Wiggle Sort) pattern: sort the array and alternate between picking the smallest and largest remaining elements. This creates maximum differences between adjacent elements, guaranteeing no element can be the average of its neighbors. Time complexity: O(n log n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Permutations)	O(n! × n)	O(n)	Generate all possible arrangements and check each one for validity
Two Pointers (Wiggle Sort Pattern)	O(n log n)	O(n)	Sort array and alternate between smallest and largest remaining elements

Brute Force (Try All Permutations) — Algorithm Steps

Generate all permutations of the input array
For each permutation, check every middle element
Verify that nums[i] ≠ (nums[i-1] + nums[i+1]) / 2 for all valid i
Return the first valid permutation found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]

Check Each Arrangement

For each permutation, verify no middle element equals average of neighbors

Return First Valid

Stop at first arrangement that satisfies all constraints

Code -

solution.c — C

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

bool isValid(int* arr, int n) {
    for (int i = 1; i < n - 1; i++) {
        if (2 * arr[i] == arr[i-1] + arr[i+1]) {
            return false;
        }
    }
    return true;
}

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

bool generatePermutations(int* nums, int n, int start) {
    if (start == n) {
        return isValid(nums, n);
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        if (generatePermutations(nums, n, start + 1)) {
            return true;
        }
        swap(&nums[start], &nums[i]);
    }
    
    return false;
}

int* rearrangeArray(int* nums, int n) {
    int* result = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        result[i] = nums[i];
    }
    
    generatePermutations(result, n, 0);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    
    int* result = rearrangeArray(nums, n);
    
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(" ");
    }
    printf("\n");
    
    free(nums);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

O(n!) to generate all permutations, O(n) to check each permutation

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing one permutation and recursion stack

⚡ Linearithmic Space

52.3K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler