Rust:

https://pastebin.com/Za12mzeE

C: gcc -O2 easy.c

In case formatting is messed up

#include 
#include 

void bail(char const *msg)
{
	fputs(msg, stderr);
	exit(EXIT_FAILURE);
}

int main(int argc, char **argv)
{
	int count = 0;
	char *p, c = 0;

	if (argc != 2) {
		bail("Improper invocation.\n");
	}

	for (c = *(p = argv[1]); *p; p++) {
		if (c == *p) {
			count++;
		} else {
			printf("%c%d", c, count);
			c = *p;
			count = 1;
		}
	}

	if (count) {
		printf("%c%d", c, count);
	}

	putchar('\n');

	return 0;
}

JavaScript (DenoBun): bun easy.js aaabbhhhh33aaa

Golf attempt using RegExp to match homogenous substrings.

console.log(Deno.args[0].replace(/(.)\1*/g,a=>a[0]+(a.length+'')))

Slightly optimised by removing the frivolous conversion to string. I also made a somewhat silly opitmisation of using Bun.argv instead of Deno.args to save a character.

console.log(Bun.argv[2].replace(/(.)\1*/g,a=>a[0]+a.length))

Ruby, just because I wanted a bit more practice. Again, I went to lowering character count, so it is ugly. I’m just using a anchor-runner pointer strategy to do the work. I tried to think of a regex to do the work for me, but couldn’t think of one that would work.

i=ARGV[0]
o=''
a=r=0
l=i.length
while l>a
  r+=1
  if r>l||i[a]!=i[r] then
    o+=i[a]+(r-a).to_s
    a=r
  end
end
puts o

My broken brain just goes “but how would a decompressor know if ‘3101’ was originally ‘30’ or 101 '3’s in a row?”

Python:

import sys

input_string = sys.argv[1]

compressed_string = ''
last_letter = ''
letter_count = 0

for letter in input_string:
    if letter != last_letter:
        if last_letter != '':
            compressed_string += last_letter + str(letter_count)
            letter_count = 0
        last_letter = letter
    letter_count += 1
compressed_string += last_letter + str(letter_count)

print(compressed_string)

Factor:

USING: kernel strings command-line namespaces math.parser sequences io ;
IN: l

: c ( s -- C )
  "" swap
  [ dup empty? not ] [
    dup dup dup first '[ _ = not ] find drop
    dup not [ drop length ] [ nip ] if
    2dup tail
    [ number>string [ first 1string ] dip append append ] dip
  ] while drop
;

MAIN: [ command-line get first c print ]

Benchmark using compiled binary:

$ hyperfine "./compress/compress aaabbhhhh33aaa"

Benchmark 1: ./compress/compress aaabbhhhh33aaa
  Time (mean ± σ):       3.6 ms ±   0.4 ms    [User: 1.4 ms, System: 2.2 ms]
  Range (min … max):     3.0 ms …   6.0 ms    575 runs

Bun, technically prints it to the console: throw[...Bun.argv[2].matchAll(/(.)+?(?!\1)/g)].map(([a,c])=>c+a.length).join("")

Breaks if there are more than 9 repeats or if you don’t supply an argument.

Factor:

(command-line) last [ ] group-by [ length 48 + swap ] assoc-map “” concat-as print

My solution (runs in O(n) time, but so do all the other solutions so far as far as I can tell):

from itertools import pairwise

def main(s: str) -> str:
    characters = [None] + list(s) + [None]
    transitions = []
    for (_, left), (right_idx, right) in pairwise(enumerate(characters)):
        if left != right:
            transitions.append((right_idx, right))
    repeats = [(stop - start, char) for (start, char), (stop, _) in pairwise(transitions)]
    return ''.join(f'{char}{length}' for length, char in repeats)

if __name__ == '__main__':
    from argparse import ArgumentParser
    parser = ArgumentParser()
    parser.add_argument('s')
    print(main(parser.parse_args().s))

Runthrough:
'aaabb' -> [None, 'a', 'a', 'a', 'b', 'b', None] -> [(1, 'a'), (4, 'b'), (6, None)] -> [(4 - 1, 'a'), (6 - 4, 'b')]

Golfed (just for fun, not a submission):

import sys
from itertools import pairwise as p
print(''.join(c+str(b-a)for(a,c),(b,_)in p([(i,r)for i,(l,r)in enumerate(p([None,*sys.argv[1],None]))if l!=r])))

deleted by creator

Ruby port of @brie’s solution:

puts ARGV[0].gsub(/(.)\1*/)m|m[0]+m.size.to_s