Use two pointers moving in the same direction: read scans the original array, and write builds the compressed result in place. The key idea is to process one run of equal characters at a time. While read stays on the same character, we increase a count. When the run ends (or we reach the end of the array), we write that character at chars[write], then move write forward.

If count == 1, we stop there. If count > 1, we convert the count to a string (for example, 12 -> "12") and write each digit into chars, advancing write after each digit. Then we start counting the next run.

Because each character is read once and written at most once (plus count digits), this is linear time. We only use a few variables besides the input array, so extra space is constant.

Implementation

def compress(self, chars: List[str]) -> int:
    def compress_char(write, curr, counter):
        chars[write] = curr
        write += 1
        if counter == 1:      # does not append length
            return write
        length = str(counter) # convert length to string
        for c in length:
            chars[write] = c
            write += 1
        return write
    write, counter, curr = 0, 1, chars[0]
    for read in range(1, len(chars)):
        if chars[read] == curr:
            counter += 1
        else:
            write = compress_char(write, curr, counter)
            counter = 1
        curr = chars[read]
    write = compress_char(write, curr, counter)
    return write