Keep each value at most twice

def keep_at_most_twice(nums):
    w = 0                              # nums[:w] is the kept prefix
    for r in range(len(nums)):
        if w < 2 or nums[r] != nums[w - 2]:
            nums[w] = nums[r]
            w += 1
    return nums[:w]

#include <vector>

std::vector<int> solve(std::vector<int> nums) {
    size_t w = 0;                          // nums[0..w) is the kept prefix
    for (size_t r = 0; r < nums.size(); ++r)
        if (w < 2 || nums[r] != nums[w - 2]) nums[w++] = nums[r];
    nums.resize(w);
    return nums;
}

class Solution {
    public int[] keepAtMostTwice(int[] nums) {
        int w = 0;                             // nums[0..w) is the kept prefix
        for (int r = 0; r < nums.length; r++) {
            if (w < 2 || nums[r] != nums[w - 2]) nums[w++] = nums[r];
        }
        return java.util.Arrays.copyOf(nums, w);
    }
}

function keepAtMostTwice(nums) {
  let w = 0;                             // nums[0..w) is the kept prefix
  for (let r = 0; r < nums.length; r++) {
    if (w < 2 || nums[r] !== nums[w - 2]) nums[w++] = nums[r];
  }
  return nums.slice(0, w);
}

fn solve(nums: &[i64]) -> Vec<i64> {
    let mut v = nums.to_vec();
    let mut w = 0;                         // v[..w] is the kept prefix
    for r in 0..v.len() {
        if w < 2 || v[r] != v[w - 2] { v[w] = v[r]; w += 1; }
    }
    v.truncate(w);
    v
}

-- Build the kept list back to front: a value is dropped when the
-- second most recent kept value already equals it.
solve :: [Int] -> [Int]
solve = reverse . foldl step []
  where
    step kept@(_ : prev : _) x | x == prev = kept
    step kept x = x : kept