Skip to content
Programming101
Programming101

Learn everything about programming

  • Home
  • CS Subjects
    • IoT – Internet of Things
    • Digital Communication
    • Human Values
  • Programming Tutorials
    • C Programming
    • Data structures and Algorithms
    • 100+ Java Programs
    • 100+ C Programs
  • HackerRank Solutions
    • HackerRank Algorithms Solutions
    • HackerRank C problems solutions
    • HackerRank C++ problems solutions
    • HackerRank Java problems solutions
    • HackerRank Python problems solutions
Programming101
Programming101

Learn everything about programming

Leetcode Wiggle Subsequence problem solution

YASH PAL, 31 July 2024

In this Leetcode Wiggle Subsequence problem solution, A wiggle sequence is a sequence where the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with one element and a sequence with two non-equal elements are trivially wiggle sequences.

For example, [1, 7, 4, 9, 2, 5] is a wiggle sequence because the differences (6, -3, 5, -7, 3) alternate between positive and negative.

In contrast, [1, 4, 7, 2, 5] and [1, 7, 4, 5, 5] are not wiggle sequences. The first is not because its first two differences are positive, and the second is not because its last difference is zero.

A subsequence is obtained by deleting some elements (possibly zero) from the original sequence, leaving the remaining elements in their original order.

we have given an integer array nums, return the length of the longest wiggle subsequence of nums.

Leetcode Wiggle Subsequence problem solution

Problem solution in Python.

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums) <= 1: return len(nums)
        prev_difference = nums[1] - nums[0]
        count = 2 if prev_difference != 0 else 1 
        for i in range(2, len(nums)):
            current_difference = nums[i] - nums[i-1]
            if (current_difference > 0 and prev_difference <=0 ) or (current_difference < 0 and prev_difference>=  0):
                count += 1
                prev_difference = current_difference
        return count

Problem solution in Java.

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int up = 1;
        int down = 1;
        for (int i=1; i<nums.length; i++) {
            if (nums[i] > nums[i - 1]) {
                up = down + 1;
            }
            else if (nums[i] < nums[i - 1]) {
                down = up + 1;
            }
        }
        return Math.max(down, up);
    }
}

Problem solution in C++.

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums)
    {
        vector<pair<int, int>> vp;
        if (nums.size() < 2) return 1;
        vp.push_back({nums[0], 1});
        vp.push_back({-nums[0], 1});
        int maxv = 1;
        for (int i = 1; i < nums.size(); i++)
        {
            int dif = nums[i] - nums[i - 1];
            bool inserted = false;

            for (auto& el : vp)
            {
                if ((dif > 0 && el.first < 0) || (dif < 0 && el.first > 0))
                {
                    el.first = dif;
                    el.second++;
                    if (el.second > maxv) maxv = el.second;
                    inserted = true;
                    break;
                }                
                else if (dif == 0) break;
            }
            if (inserted)
            {
               sort(vp.begin(), vp.end(), [](const pair<int,int>& p1, const pair<int,int>& p2) {return p1.second > p2.second;});
            }
            else if (!inserted && dif != 0)
            {
                vp.push_back({nums[0], 1});
            }
        }


        return maxv;      
    }
};

Problem solution in C.

int wiggleMaxLength(int* nums, int numsSize) {
    int i = 0;
    int diff = 0;
    int p_diff = 0;
    int n_diff = 0;
    int no_diff = 0;
    int count = 0;
    if(numsSize == 1)
        return 1;
    if(numsSize == 0)
        return 0;    
    while(i < numsSize - 1)
    {
        diff = nums[i+1] - nums[i];
        
        if(diff > 0)
        {
            n_diff = 0;
            if(p_diff == 0) count++;
            p_diff++;
            i++;
        }
        else if(diff < 0)
        {
            p_diff = 0;
            if(n_diff == 0) count++;
            i++;
            n_diff++;
        }
        else 
        {
            i++;
            no_diff++;
        }
    }
    return count+1;
}

coding problems

Post navigation

Previous post
Next post
  • HackerRank Separate the Numbers solution
  • How AI Is Revolutionizing Personalized Learning in Schools
  • GTA 5 is the Game of the Year for 2024 and 2025
  • Hackerrank Day 5 loops 30 days of code solution
  • Hackerrank Day 6 Lets Review 30 days of code solution
How to download udemy paid courses for free

Pages

  • About US
  • Contact US
  • Privacy Policy

Programing Practice

  • C Programs
  • java Programs

HackerRank Solutions

  • C
  • C++
  • Java
  • Python
  • Algorithm

Other

  • Leetcode Solutions
  • Interview Preparation

Programming Tutorials

  • DSA
  • C

CS Subjects

  • Digital Communication
  • Human Values
  • Internet Of Things
©2025 Programming101 | WordPress Theme by SuperbThemes