Кодирование повторов

public class Solution
{
    public static List<char> Compress(List<char> chars)
    {
        int l = 0, r = 0;
        List<char> result = new List<char>();

        while (l < chars.Count)
        {
            // Бежим правым указателем, пока в интервале [l, r]
            // находятся все одинаковые символы
            while (r + 1 < chars.Count && chars[r] == chars[r + 1])
            {
                r++;
            }

            // Обновляем ответ
            int windowSize = r - l + 1;
            result.Add(chars[r]);
            if (windowSize > 1)
            {
                foreach (char c in windowSize.ToString())
                {
                    result.Add(c);
                }
            }

            // Интервалы не пересекаются, поэтому сдвигаем
            // на r + 1 — именно отсюда будет начинаться
            // следующий интервал
            l = r + 1;
            r = r + 1;
        }
        return result;
    }
}

#include <vector>
#include <string>

using namespace std;

vector<char> compress(const vector<char>& chars) {
    int l = 0, r = 0;
    vector<char> result;
    
    while (l < chars.size()) {
        // Бежим правым указателем, пока в интервале [l, r]
        // находятся все одинаковые символы
        while (r + 1 < chars.size() && chars[r] == chars[r + 1]) {
            r++;
        }

        // Обновляем ответ
        int windowSize = r - l + 1;
        result.push_back(chars[r]);
        if (windowSize > 1) {
            for (char c : to_string(windowSize)) {
                result.push_back(c);
            }
        }

        // Интервалы не пересекаются, поэтому сдвигаем
        // на r + 1 — именно отсюда будет начинаться
        // следующий интервал
        l = r + 1;
        r = r + 1;
    }
    return result;
}

package main

import (
    "strconv"
)

func compress(chars []rune) []rune {
    l, r := 0, 0
    result := []rune{}

    for l < len(chars) {
        // Бежим правым указателем, пока в интервале [l, r]
        // находятся все одинаковые символы
        for r+1 < len(chars) && chars[r] == chars[r+1] {
            r++
        }

        // Обновляем ответ
        windowSize := r - l + 1
        result = append(result, chars[r])
        if windowSize > 1 {
            result = append(result, []rune(strconv.Itoa(windowSize))...)
        }

        // Интервалы не пересекаются, поэтому сдвигаем
        // на r + 1 — именно отсюда будет начинаться
        // следующий интервал
        l = r + 1
        r = r + 1
    }
    return result
}

import java.util.*;

public class Solution {

    public List<Character> compress(List<Character> chars) {
        int l = 0, r = 0;
        List<Character> result = new ArrayList<>();

        while (l < chars.size()) {
            // Бежим правым указателем, пока в интервале [l, r]
            // находятся все одинаковые символы
            while (r + 1 < chars.size() && chars.get(r).equals(chars.get(r + 1))) {
                r++;
            }

            // Обновляем ответ
            int windowSize = r - l + 1;
            result.add(chars.get(r));
            if (windowSize > 1) {
                for (char c : String.valueOf(windowSize).toCharArray()) {
                    result.add(c);
                }
            }

            // Интервалы не пересекаются, поэтому сдвигаем
            // на r + 1 — именно отсюда будет начинаться
            // следующий интервал
            l = r + 1;
            r = r + 1;
        }

        return result;
    }
}

from typing import *

def compress(chars: List[str]) -> List[str]:
    l = 0
    r = 0
    result = []
    while l < len(chars):
        # бежим правым указателем, пока в интервале [l, r]
        # находятся все одинаковые символы
        while r + 1 < len(chars) and chars[r] == chars[r + 1]:
            r += 1

        # обновляем ответ
        windowSize = r - l + 1
        if windowSize == 1:
            result.append(chars[r])
        else:
            result.append(chars[r])
            result += list(str(windowSize))

        # интервалы не пересекаются, поэтому сдвигаем
        # на r + 1 - именно отсюда будет начинаться
        # следующий интервал
        l = r + 1
        r = r + 1
    return result

export function compress(chars) {
    let l = 0, r = 0;
    let result = [];

    while (l < chars.length) {
        // Бежим правым указателем, пока в интервале [l, r]
        // находятся все одинаковые символы
        while (r + 1 < chars.length && chars[r] === chars[r + 1]) {
            r++;
        }

        // Обновляем ответ
        let windowSize = r - l + 1;
        result.push(chars[r]);
        if (windowSize > 1) {
            for (let c of windowSize.toString()) {
                result.push(c);
            }
        }

        // Интервалы не пересекаются, поэтому сдвигаем
        // на r + 1 — именно отсюда будет начинаться
        // следующий интервал
        l = r + 1;
        r = r + 1;
    }
    return result;
}