Given a string, compress substrings of repeated characters in to a format similar to aaa -> a3

For example for the string aaabbhhhh33aaa the expected output would be a3b2h432a3


You must accept the input as a command line argument (entered when your app is ran) and print out the result

(It will be called like node main.js aaaaa or however else to run apps in your language)

You can use the solution tester in this post to test you followed the correct format https://programming.dev/post/1805174

Any programming language may be used. 1 point will be given if you pass all the test cases with 1 bonus point going to whoevers performs the quickest and 1 for whoever can get the least amount of characters

To submit put the code and the language you used below


People who have completed the challenge:

  • gifti@programming.dev
    link
    fedilink
    arrow-up
    2
    ·
    edit-2
    1 year ago

    Factor:

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

  • PoolloverNathan@programming.dev
    link
    fedilink
    English
    arrow-up
    2
    ·
    edit-2
    1 year ago

    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.

    • Ategon@programming.devOPM
      link
      fedilink
      arrow-up
      2
      ·
      edit-2
      1 year ago
      • 8/8 test cases passed
      • no runtime stats since I couldnt use the solution checker to check it (had to do manually)
      • Characters: 84
  • shape-warrior-t@kbin.social
    link
    fedilink
    arrow-up
    1
    ·
    1 year ago

    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])))
    
    
  • brie@beehaw.org
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    1 year ago

    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;
    }
    
  • nieceandtows@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    1 year ago

    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)
    
    
  • brie@beehaw.org
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    1 year ago

    JavaScript (DenoBun): bun easy.js aaabbhhhh33aaa

    Golf attempt using RegExp to match homogenous substrings.

    Original version
    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))
    
  • graphicsguy@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    1 year ago

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

  • Andy@programming.dev
    link
    fedilink
    arrow-up
    1
    ·
    edit-2
    1 year ago

    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