The longest alternating subsequence

def wiggle_max_length(nums):
    up = down = 1                        # longest wiggle so far ending with a rise / with a fall
    for prev, x in zip(nums, nums[1:]):
        if x > prev:
            up = down + 1                # a rise extends a wiggle that last fell
        elif x < prev:
            down = up + 1
    return max(up, down)

#include <algorithm>
#include <vector>

int solve(const std::vector<int>& nums) {
    int up = 1, down = 1;
    for (size_t i = 1; i < nums.size(); ++i) {
        if (nums[i] > nums[i - 1]) up = down + 1;        // a rise after a fall
        else if (nums[i] < nums[i - 1]) down = up + 1;   // a fall after a rise
    }
    return std::max(up, down);
}

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

function wiggleMaxLength(nums) {
  let up = 1, down = 1;
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] > nums[i - 1]) up = down + 1;        // a rise after a fall
    else if (nums[i] < nums[i - 1]) down = up + 1;   // a fall after a rise
  }
  return Math.max(up, down);
}

fn solve(nums: &[i64]) -> i64 {
    let (mut up, mut down) = (1i64, 1i64);
    for w in nums.windows(2) {
        if w[1] > w[0] {
            up = down + 1;                                   // a rise after a fall
        } else if w[1] < w[0] {
            down = up + 1;                                   // a fall after a rise
        }
    }
    up.max(down)
}

solve :: [Int] -> Int
solve nums = uncurry max (foldl step (1, 1) (zip nums (drop 1 nums)))
  where
    -- (longest ending with a rise, longest ending with a fall)
    step (up, down) (prev, x)
      | x > prev = (down + 1, down)
      | x < prev = (up, up + 1)
      | otherwise = (up, down)