Codestin Search App

Wiggle Subsequence - Problem

Imagine you're tracking a roller coaster's ups and downs - that's exactly what a wiggle sequence is! A wiggle sequence alternates between going up and down, where the differences between consecutive numbers strictly alternate between positive and negative.

🎢 What makes a sequence "wiggle"?

The differences between successive numbers must strictly alternate between positive and negative
The first difference can be either positive or negative
Single elements and two non-equal elements are trivially wiggle sequences

Examples:

[1, 7, 4, 9, 2, 5] ✅ Wiggle! Differences: (6, -3, 5, -7, 3) - alternates perfectly

[1, 4, 7, 2, 5] ❌ Not wiggle! First two differences (3, 3) are both positive

[1, 7, 4, 5, 5] ❌ Not wiggle! Last difference is zero

Your Mission: Given an integer array nums, find the length of the longest wiggle subsequence. Remember, a subsequence maintains the original order but can skip elements.

Input & Output

example_1.py — Basic Wiggle Sequence

$ Input: [1,7,4,9,2,5]

› Output: 6

💡 Note: The entire array forms a wiggle sequence with differences [6,-3,5,-7,3] that alternate perfectly between positive and negative. All 6 elements can be included.

example_2.py — Non-Wiggle Sequence

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

› Output: 4

💡 Note: The differences are [3,3,-5,3]. The first two differences are both positive, so we need to skip one element. Optimal subsequence: [1,7,2,5] with differences [6,-5,3].

example_3.py — Edge Case

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

› Output: 2

💡 Note: This is a strictly increasing sequence. The longest wiggle subsequence we can form has length 2, like [1,5] or [1,2]. Any two non-equal elements form a valid wiggle sequence.

Constraints

1 ≤ nums.length ≤ 1000
0 ≤ nums[i] ≤ 1000
Follow up: Could you solve this in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Survey the Terrain

Look at the height differences between consecutive points [1,7,4,9,2,5] → [+6,-3,+5,-7,+3]

Track Two Possibilities

At each point, maintain the longest track ending upward and ending downward

Make Optimal Choices

When going up, extend the best downward track. When going down, extend the best upward track

Build the Track

The final answer is the longer of the two possible tracks we've been building

Key Takeaway

🎯 Key Insight: We don't need to store actual sequences - just track the lengths of the best sequences ending in each direction. This reduces space complexity from O(n) to O(1) while maintaining optimal O(n) time!

Asked in

⊞ Microsoft 15 a Amazon 12 G Google 8 f Meta 6

The optimal solution uses Dynamic Programming to track two states: the longest wiggle sequence ending with an increase and ending with a decrease. At each element, we can extend the appropriate sequence based on the current trend, achieving O(n) time and O(1) space complexity. Alternative greedy approach counts direction changes for the same optimal performance.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track longest wiggle sequences ending with increase/decrease in one pass
Greedy Approach (Alternative Optimal)	O(n)	O(1)	Greedily select peaks and valleys to form the longest wiggle sequence

Dynamic Programming (Optimal) — Algorithm Steps

Initialize two variables: 'up' and 'down' both starting at 1
Iterate through the array from the second element
If current element > previous: up = down + 1 (extend decreasing sequence)
If current element < previous: down = up + 1 (extend increasing sequence)
If elements are equal: no change to either sequence
Return the maximum of up and down

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize States

Start with up=1, down=1 (any single element forms a valid sequence)

Process Each Element

Compare with previous element and update appropriate state

Update States

Extend the opposite trend sequence when we find a different direction

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int wiggleMaxLength(int* nums, int numsSize) {
    if (numsSize < 2) return numsSize;
    
    // up: length of longest wiggle subsequence ending with an increase
    // down: length of longest wiggle subsequence ending with a decrease
    int up = 1, down = 1;
    
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > nums[i-1]) {
            // Current element is greater, extend decreasing sequence
            up = down + 1;
        } else if (nums[i] < nums[i-1]) {
            // Current element is smaller, extend increasing sequence
            down = up + 1;
        }
        // If nums[i] == nums[i-1], no change needed
    }
    
    return max(up, down);
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    int inNumber = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = 1;
        } else if (c == '-' && !inNumber) {
            sign = -1;
        } else if (inNumber) {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
            inNumber = 0;
        }
    }
    if (inNumber) {
        nums[size++] = num * sign;
    }
    
    printf("%d\n", wiggleMaxLength(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only two variables needed to track the DP states

✓ Linear Space

67.9K Views

Medium Frequency

~15 min Avg. Time

2.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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler