Array Wave Arranger - Problem

Given an array of integers, rearrange the array elements to form a wave pattern where:

arr[0] >= arr[1] <= arr[2] >= arr[3] <= arr[4] >= arr[5]...

The pattern alternates between greater-than-or-equal and less-than-or-equal comparisons. Your solution should work for both sorted and unsorted input arrays.

Note: Multiple valid wave arrangements may exist for the same input - return any valid arrangement.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: The wave pattern 2 ≥ 1 ≤ 4 ≥ 3 is achieved. At even indices we have peaks (2, 4) and at odd indices we have valleys (1, 3).

Example 2 — Already Sorted

$ Input: arr = [10, 90, 49, 2, 1, 5, 23]

› Output: [90,10,49,1,5,2,23]

💡 Note: After wave arrangement: 90 ≥ 10 ≤ 49 ≥ 1 ≤ 5 ≥ 2 ≤ 23. The pattern alternates correctly between peaks and valleys.

Example 3 — Two Elements

$ Input: arr = [5, 1]

› Output: [5,1]

💡 Note: With only two elements, 5 ≥ 1 already forms a valid wave pattern (peak followed by valley).

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 35 M Microsoft 28 G Google 22 A Adobe 18

The key insight is that we don't need perfect sorting to create a wave pattern - just ensure each position satisfies its local wave condition. The optimal approach uses a single pass with strategic swaps: for even indices (peaks), ensure element ≥ neighbor; for odd indices (valleys), ensure element ≤ neighbor. Time: O(n), Space: O(1).

Common Approaches

✓ Single Pass Wave Formation

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

Traverse the array once and ensure wave property at each position by swapping with neighbors when needed. For even indices (peaks), ensure element is >= neighbors. For odd indices (valleys), ensure element is <= neighbors.

Sort Then Alternate Selection

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

First sort the entire array, then create wave by alternately selecting elements from the largest and smallest available values. Place large values at even indices (peaks) and small values at odd indices (valleys).

Single Pass Wave Formation — Algorithm Steps

Iterate through array from index 1
At each position, check if wave property is violated
If violated, swap current element with previous element
Continue until end of array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position

At each index, determine if it should be peak or valley

Fix Violation

If wave property violated, swap with previous element

Continue

Move to next position until array end

Code -

solution.c — C

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

int* solution(int* arr, int n, int* returnSize) {
    *returnSize = n;
    
    for (int i = 1; i < n; i++) {
        int shouldBeGreater = (i % 2 == 0);
        
        if ((shouldBeGreater && arr[i] < arr[i-1]) ||
            (!shouldBeGreater && arr[i] > arr[i-1])) {
            int temp = arr[i];
            arr[i] = arr[i-1];
            arr[i-1] = temp;
        }
    }
    
    return arr;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int arr[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9' || token[0] == '-') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int returnSize;
    int* result = solution(arr, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant time swaps

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for temporary variables

✓ Linear Space

23.4K Views

Medium Frequency

~15 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

Array Wave Arranger - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Single Pass Wave Formation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler