Nsryjdtyk

I'm trying to write a simple python algorithm to solve this problem. Can you please help me figure out why my code is not working:

Problem:

If any character is repeated more than 4 times, the entire set of
repeated characters should be replaced with a slash '/', followed by a
2-digit number which is the length of this run of repeated characters,
and the character. For example, "aaaaa" would be encoded as "/05a".
Runs of 4 or less characters should not be replaced since performing
the encoding would not decrease the length of the string.

My Code:

def runLengthEncode (plainText):

    res=''

    a=''

    for i in plainText:

        if a.count(i)>0:

            a+=i

        else:

            if len(a)>4:

                res+="/" + str(len(a)) + a[0][:1]

            else:

                res+=a

                a=i

    return(res)

Aside for setting a=i after encoding a sequence and setting a width for your int when printed into the string. You could also do the following which takes advantage of pythons groupby. Its also a good idea to use format when constructing strings.

from itertools import groupby



def runLengthEncode (plainText):

    res = 



    for k,i in groupby(plainText):

        run = list(i)

        if(len(run) > 4):

            res.append("/{:02}{}".format(len(run), k))

        else:

            res.extend(run)



    return "".join(res)

Just observe the behaviour:

>>> runLengthEncode("abcd")

'abc'

Last character is ignored. You have to append what you've collected.

>>> runLengthEncode("abbbbbcd")

'a/5b/5b'

Oops, problem after encoding. You should set a=i even if you found a long enough sequence.

Rosetta Code has a lot of implementations, that should easily be adaptable to your usecase.

Here is Python code with regular expressions:

from re import sub



def encode(text):

    '''

    Doctest:

        >>> encode('WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW')

        '12W1B12W3B24W1B14W'    

    '''

    return sub(r'(.)1*', lambda m: str(len(m.group(0))) + m.group(1),

               text)



def decode(text):

    '''

    Doctest:

        >>> decode('12W1B12W3B24W1B14W')

        'WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW'

    '''

    return sub(r'(d+)(D)', lambda m: m.group(2) * int(m.group(1)),

               text)



textin = "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWBWWWWWWWWWWWWWW"

assert decode(encode(textin)) == textin

You can use the groupby() function combined with a list/generator comprehension:

from itertools import groupby, imap



''.join(x if reps <= 4 else "/%02d%s" % (reps, x) for x, reps in imap(lambda x: (x[0], len(list(x[1]))), groupby(s)))

I know this is not the most efficient solution, but we haven't studied functions like groupby() yet so here's what I did:

def runLengthEncode (plainText):

    res=''

    a=''

    count = 0

    for i in plainText:

        count+=1

        if a.count(i)>0:

            a+=i

        else:

            if len(a)>4:

                if len(a)<10:

                    res+="/0"+str(len(a))+a[0][:1]

                else:

                    res+="/" + str(len(a)) + a[0][:1]

                a=i

            else:

                res+=a

                a=i

        if count == len(plainText):

            if len(a)>4:

                if len(a)<10:

                    res+="/0"+str(len(a))+a[0][:1]

                else:

                    res+="/" + str(len(a)) + a[0][:1]

            else:

                res+=a

    return(res)

An easy solution to run-length encoding which I can think of:

For encoding a string like "a4b5c6d7...":

def encode(s):

    counts = {}

    for c in s:

        if counts.get(c) is None:

            counts[c] = s.count(c)

    return "".join(k+str(v) for k,v in counts.items())

For decoding a string like "aaaaaabbbdddddccccc....":

def decode(s):

    return "".join((map(lambda tup:  tup[0] * int(tup[1]), zip(s[0:len(s):2], s[1:len(s):2]))))

Fairly easy to read and simple.