Сжатие пробелов

public class Solution {
    public static List<char> CompressSpaces(List<char> chars) {
        int slow = 0;
        int fast = 0;
        int spaces = 0;

        while (fast < chars.Count) {
            char c = chars[fast];
            spaces = c == ' ' ? spaces + 1 : 0;

            if (spaces <= 1) {
                // Меняем элементы местами
                char temp = chars[slow];
                chars[slow] = chars[fast];
                chars[fast] = temp;
                slow++;
            }
            fast++;
        }
        chars.RemoveRange(slow, chars.Count - slow);
        return chars;
    }
}

#include <vector>

using namespace std;

vector<char> compressSpaces(vector<char> &chars) {
    int slow = 0;
    int fast = 0;
    int spaces = 0;

    while (fast < chars.size()) {
        char c = chars[fast];
        spaces = c == ' ' ? spaces + 1 : 0;

        if (spaces <= 1) {
            // меняем элементы местами
            swap(chars[slow], chars[fast]);
            slow++;
        }
        fast++;
    }
    chars.resize(slow);
    return chars;
}

package main

func compressSpaces(chars []rune) []rune {
    slow := 0
    fast := 0
    spaces := 0

    for fast < len(chars) {
        c := chars[fast]
        if c == ' ' {
            spaces++
        } else {
            spaces = 0
        }

        if spaces <= 1 {
            // меняем элементы местами
            chars[slow], chars[fast] = chars[fast], chars[slow]
            slow++
        }
        fast++
    }
    return chars[:slow]
}

import java.util.*;

public class Solution {
    public List<Character> compressSpaces(List<Character> chars) {
        int slow = 0;
        int fast = 0;
        int spaces = 0;

        while (fast < chars.size()) {
            char c = chars.get(fast);
            spaces = c == ' ' ? spaces + 1 : 0;

            if (spaces <= 1) {
                // меняем элементы местами
                Collections.swap(chars, slow, fast);
                slow++;
            }
            fast++;
        }
        return chars.subList(0, slow);
    }
}

from typing import *

def compress_spaces(chars: List[str]) -> List[str]:
    slow: int = 0
    fast: int = 0
    spaces: int = 0

    while fast < len(chars):
        c = chars[fast]
        spaces = spaces + 1 if c == ' ' else 0

        if spaces <= 1:
            # меняем элементы местами
            chars[slow], chars[fast] = chars[fast], chars[slow]
            slow += 1
        fast += 1

    del chars[slow:]
    return chars

/**
 * @param {Array.<string>} chars
 * @returns {Array.<string>}
 */
export function compressSpaces(chars) {
  let slow = 0;
  let fast = 0;
  let spaces = 0;

  while (fast < chars.length) {
    const c = chars[fast];
    spaces = c === ' ' ? spaces + 1 : 0;

    if (spaces <= 1) {
      // меняем элементы местами
      [chars[slow], chars[fast]] = [chars[fast], chars[slow]];
      slow++;
    }
    fast++;
  }
  chars.splice(slow);
  return chars;
}