## Algorithm

Problem Name: 376. Wiggle Subsequence

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.

Given an integer array `nums`, return the length of the longest wiggle subsequence of `nums`.

Example 1:

```Input: nums = [1,7,4,9,2,5]
Output: 6
Explanation: The entire sequence is a wiggle sequence with differences (6, -3, 5, -7, 3).
```

Example 2:

```Input: nums = [1,17,5,10,13,15,10,5,16,8]
Output: 7
Explanation: There are several subsequences that achieve this length.
One is [1, 17, 10, 13, 10, 16, 8] with differences (16, -7, 3, -3, 6, -8).
```

Example 3:

```Input: nums = [1,2,3,4,5,6,7,8,9]
Output: 2
```

Constraints:

• `1 <= nums.length <= 1000`
• `0 <= nums[i] <= 1000`

## Code Examples

### #1 Code Example with Java Programming

```Code - Java Programming```

``````
class Solution {
public int wiggleMaxLength(int[] nums) {
if (nums.length < 2) {
return nums.length;
}
int[] increasing = new int[nums.length];
int[] decreasing = new int[nums.length];
for (int i = 0; i  <  nums.length; i++) {
for (int j = 0; j  <  i; j++) {
if (nums[i] > nums[j]) {
increasing[i] = Math.max(increasing[i], decreasing[j] + 1);
} else if (nums[i]  <  nums[j]) {
decreasing[i] = Math.max(decreasing[i], increasing[j] + 1);
}
}
}
return 1 + Math.max(decreasing[nums.length - 1], increasing[nums.length - 1]);
}
}
``````
Copy The Code &

Input

cmd
nums = [1,7,4,9,2,5]

Output

cmd
6

### #2 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const wiggleMaxLength = function(nums) {
if (nums.length < 2) return nums.length
let prevdiff = nums[1] - nums[0]
let count = prevdiff !== 0 ? 2 : 1
for (let i = 2; i  <  nums.length; i++) {
let diff = nums[i] - nums[i - 1]
if ((diff > 0 && prevdiff <= 0) || (diff < 0 && prevdiff >= 0)) {
count++
prevdiff = diff
}
}
return count
}
``````
Copy The Code &

Input

cmd
nums = [1,7,4,9,2,5]

Output

cmd
6

### #3 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def wiggleMaxLength(self, nums):
if len(nums) <= 2: return 0 if not nums else 1 if nums[0] == nums[-1] else 2
inc = nums[0] < nums[1] if nums[0] != nums[1] else None
cnt = 2 if inc != None else 1
for i in range(2, len(nums)):
if nums[i - 1] != nums[i] and (inc == None or inc != (nums[i - 1] < nums[i])):
inc = nums[i - 1] < nums[i]
cnt += 1
return cnt
``````
Copy The Code &

Input

cmd
nums = [1,17,5,10,13,15,10,5,16,8]

Output

cmd
7