Array With Elements Not Equal to Average of Neighbors

Array With Elements Not Equal to Average of Neighbors - Problem

You are given a 0-indexed array nums of distinct integers. You want to rearrange the elements in the array such that every element in the rearranged array is not equal to the average of its neighbors.

More formally, the rearranged array should have the property such that for every i in the range 1 <= i < nums.length - 1, (nums[i-1] + nums[i+1]) / 2 is not equal to nums[i].

Return any rearrangement of nums that meets the requirements.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,1,3,2]

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

💡 Note: Rearranged so that (1+2)/2 = 1.5 ≠ 4, and (4+3)/2 = 3.5 ≠ 2. No element equals the average of its neighbors.

Example 2 — Three Elements

$ Input: nums = [1,2,3]

› Output: [1,3,2]

💡 Note: Original [1,2,3] fails because (1+3)/2 = 2. Rearranged [1,3,2] works because (1+2)/2 = 1.5 ≠ 3.

Example 3 — Larger Array

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

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

💡 Note: Creates zigzag pattern where no middle element equals average of neighbors: 1<3>2<5>4

Constraints

3 ≤ nums.length ≤ 10⁵
-10⁵ ≤ nums[i] ≤ 10⁵
All the elements of nums are unique

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is creating a wiggle pattern where elements alternate between peaks and valleys. The optimal greedy approach runs in O(n) time by ensuring each position follows the alternating pattern rule. Time: O(n), Space: O(1)

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Brute Force Permutations

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

Generate every possible arrangement of the array and check if each arrangement satisfies the condition that no element equals the average of its neighbors. Return the first valid arrangement found.

Greedy Wiggle Sort

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

Use a greedy approach to ensure the array follows a wiggle pattern where nums[0] < nums[1] > nums[2] < nums[3]... This pattern guarantees no element equals the average of its neighbors.

Sort and Zigzag Pattern

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

Sort the array first, then create a zigzag pattern by alternating between small and large values. This ensures no element can be the average of its neighbors since we maintain strict ordering differences.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.3K Views

Medium Frequency

~15 min Avg. Time

456 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