Decrease Elements To Make Array Zigzag - Practice Coding Problems

Decrease Elements To Make Array Zigzag - Problem

Array Greedy Medium

Transform an array into a zigzag pattern using the minimum number of moves! 🎯

Given an array nums of integers, you can perform moves where each move consists of decreasing any element by 1. Your goal is to create a zigzag array with the fewest possible moves.

A zigzag array follows one of these patterns:

Pattern 1: Even indices are peaks → A[0] > A[1] < A[2] > A[3] < A[4] > ...
Pattern 2: Odd indices are peaks → A[0] < A[1] > A[2] < A[3] > A[4] < ...

Example: [1,17,5,10,13,15,10,5,16,8] can become zigzag by making strategic decreases!

Return the minimum number of moves needed to transform the array into either zigzag pattern.

Input & Output

example_1.py — Basic Zigzag

$ Input: [1,17,5,10,13,15,10,5,16,8]

› Output: 4

💡 Note: We can make this zigzag by adjusting valley positions. For even-indexed valleys: decrease index 2 (5→4), index 4 (13→9), index 6 (10→5), index 8 (16→5). Total moves: 1+4+5+11 = 21. For odd-indexed valleys: decrease index 1 (17→0), index 3 (10→4), index 5 (15→9), etc. We choose the minimum between both patterns.

example_2.py — Small Array

$ Input: [2,7,10,9,8,9]

› Output: 4

💡 Note: Pattern 1 (even valleys): [1,7,1,9,1,9] needs 1+9+7=17 moves. Pattern 2 (odd valleys): [2,6,10,8,8,9] needs 1+0+1+0=2 moves. But after checking constraints: [2,1,10,1,8,9] needs 6+8=14 moves for pattern 2. The minimum is 4 moves.

example_3.py — Already Zigzag

$ Input: [9,6,1,6,2]

› Output: 0

💡 Note: This array is already in zigzag pattern (9>6<1>6>2), following the odd-peaks pattern. No moves needed.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Only decreasing moves allowed - you cannot increase any element
Two valid zigzag patterns exist - choose the one requiring fewer moves

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Two possible zigzag patterns: even-peaks or odd-peaks

Calculate Pattern 1

Make even indices valleys, count required moves

Calculate Pattern 2

Make odd indices valleys, count required moves

Choose Optimal

Select the pattern requiring minimum earth removal

Key Takeaway

🎯 Key Insight: Only valley positions need adjustment! Peaks can remain unchanged, making this a simple O(n) greedy solution.

Asked in

f Facebook 15 a Amazon 8 G Google 5 ⊞ Microsoft 3

The optimal solution uses a greedy approach that tries both possible zigzag patterns and chooses the one requiring fewer moves. Key insight: we only need to adjust elements at valley positions by decreasing them to be smaller than their neighbors. This achieves O(n) time complexity with minimal space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^(sum of all elements))	O(n)	Try all possible ways to decrease elements and check zigzag validity
Greedy Approach (Optimal)	O(n)	O(1)	Try both zigzag patterns and choose the one requiring fewer moves

Brute Force (Try All Combinations) — Algorithm Steps

For each element, try decreasing it by 0, 1, 2, ..., up to its value
Generate all combinations of these decreases
For each combination, check if the resulting array is zigzag
Track the minimum moves among valid zigzag arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to decrease each element

Check Validity

Test if each combination forms a valid zigzag

Track Minimum

Keep track of the minimum moves found

Code -

solution.c — C

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

int min(int a, int b) {
    return a < b ? a : b;
}

int makeZigzag(int* nums, int numsSize, int start) {
    int* arr = (int*)malloc(numsSize * sizeof(int));
    memcpy(arr, nums, numsSize * sizeof(int));
    int moves = 0;
    
    for (int i = start; i < numsSize; i += 2) {
        int left = (i > 0) ? arr[i-1] : INT_MAX;
        int right = (i < numsSize-1) ? arr[i+1] : INT_MAX;
        int minNeighbor = min(left, right);
        
        if (arr[i] >= minNeighbor) {
            moves += arr[i] - minNeighbor + 1;
            arr[i] = minNeighbor - 1;
        }
    }
    
    free(arr);
    return moves;
}

int movesToMakeZigzag(int* nums, int numsSize) {
    if (numsSize <= 2) return 0;
    
    return min(makeZigzag(nums, numsSize, 0), makeZigzag(nums, numsSize, 1));
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(sum of all elements))

Each element can be decreased by 0 to its value, creating exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Space for storing current combination and checking zigzag validity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler