Given a compressed string, give the number of ways it can be decompressed.

  • A compressed string is a string where substrings of repeated characters are changed to a format similar to aaa -> a3
  • For example for the string aaabbhhhh33aaa the compressed string would be a3b2h432a3

As an example of counting decompressing options. Say you have the input a333b2. This can be read as a333 b2 or a3 33 b2 so you would need to return the value 2 as there are 2 options.


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


Checking through the solutions of last weeks problems should be happening this weekend monday + tuesday. Been getting too much work and theres a game jam thats been going on but should be able to go through them all then. I may do the easy one last since it cant be checked using the solutions tester so that one will take a bit longer.

Will also try to go through and give solutions to these ones as well on the weekend and will try to do solutions as soon as possible from now on so you can see if you failed the test cases. For the ones done last week, after I go through them all ill give 1 extra day from then on for any resubmissions

  • shape-warrior-t@kbin.social
    link
    fedilink
    arrow-up
    2
    ·
    1 year ago

    Given an input c, outputs the number of distinct lists of strings lst such that:

    1. ''.join(lst) == c
    2. for every string s in lst, s consists of an arbitrary character followed by one or more characters from ‘0123456789’

    Sure hope I didn’t mess this up, because I think the fundamental idea is quite elegant! Should run successfully for all “reasonable” inputs (as in, the numeric output fits in a uint64 and the input isn’t ridiculously long). Fundamental algorithm is O(n) if you assume all arithmetic is O(1). (If not, then I don’t know what the time complexity is, and I don’t feel like working it out.)

    from functools import cache
    from itertools import pairwise
    from math import prod
    
    @cache
    def fibonacci(n: int) -> int:
        if n == 0:
            return 0
        if n == 1:
            return 1
        return fibonacci(n - 1) + fibonacci(n - 2)
    
    def main(compressed: str) -> int:
        is_fragment_start = [i == 0 or c not in '0123456789' for i, c in enumerate(compressed)]
        fragment_start_positions = [i for i, s in enumerate(is_fragment_start) if s]
        fragment_lengths = [stop - start for start, stop in pairwise(fragment_start_positions + [len(compressed)])]
        return prod(fibonacci(fragment_length - 1) for fragment_length in fragment_lengths)
    
    if __name__ == '__main__':
        from argparse import ArgumentParser
        parser = ArgumentParser()
        parser.add_argument('compressed')
        print(main(parser.parse_args().compressed))
    
    

    Idea: a00010 -> [a000, 10] -> [length 4, length 2] -> F(4) * F(2)
    01a102b0305 -> [01, a102, b0305] -> [length 2, length 4, length 5] -> F(2) * F(4) * F(5)
    where F(n) = fibonacci(n - 1) is the number of ways to partition a string of length n into a list of strings of length ≥2.

    F(2) = 1 = fibonacci(1), F(3) = 1 = fibonacci(2), and F(n) = F(n - 2) + F(n - 1), so F is indeed just an offset version of the Fibonacci sequence.
    To see why F(n) = F(n - 2) + F(n - 1), here are the ways to split up ‘abcde’: [‘ab’] + (split up ‘cde’), [‘abc’] + (split up ‘de’), and [‘abcde’], corresponding to F(5) = F(3) + F(2) + 1.
    And the ways to split up ‘abcdef’: [‘ab’] + (split up ‘cdef’), [‘abc’] + (split up ‘def’), [‘abcd’] + (split up ‘ef’), and [‘abcdef’], corresponding to F(6) = F(4) + F(3) + F(2) + 1 = F(4) + F(5) = F(6 - 2) + F(6 - 1).
    The same logic generalizes to all n >= 4.

    • Quasari@programming.dev
      link
      fedilink
      English
      arrow-up
      3
      ·
      1 year ago

      Without memoization, I believe the Fibonacci sequence is O(2^N). It’s dependent on how long a sequence of digits is in the input, so your worst case is like O(2^N) if the string is mostly digits and best case being O(N) if there are only 1 or 2 digit sequences.

      Someone can correct me if I’m wrong.

      • shape-warrior-t@kbin.social
        link
        fedilink
        arrow-up
        1
        ·
        1 year ago

        My implementation is memoized by functools.cache, but that is a concern when it comes to recursive Fibonacci. That, and stack overflows, which are also a problem for my code (but, again, not for “reasonable” inputs – fibonacci(94) already exceeds 2^64).

        Time complexity-wise, I was more thinking about the case where the numbers get so big that addition, multiplication, etc. can no longer be modelled as taking constant time. Especially if math.prod and enumerate are implemented in ways that are less efficient for huge integers (I haven’t thoroughly checked, and I’m not planning to).

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

          functools.cache

          That’s pretty cool. I haven’t dived too deep into python, so I should of looked up the library when you attached the @cache decorator. I learned something.