Programming Challenges

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

Factor:

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

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.

Rust:

https://pastebin.com/Za12mzeE

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

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])))

Ruby port of @brie's solution:

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