Python：运行长度编码？

Question

I am trying to understand run length encoding and I understand the idea but I'm not sure how to write it so that the output is as follows:

Input:

data = [5, 5, 5, 10, 10]

Output:

[(5, 3), (10, 2)]

Question: A list is run-length encoded by representing it as a list of pairs (2-tuples), where each pair is a number and the length of the "run" of that number, where the length is 1 if a number occurs once, 2 if it occurs twice in a row, etc. Write a function run_length_encode(nums) that returns the run-length encoded representation of the list of integers, nums.

Can someone explain to me how to do this and explain what each step is doing? Unfortunately I'm struggling to grasp some things in Python but I'm slowly getting it.

Thank you!

Answer 1

The following code will do the trick, although it's not necessarily the most "Pythonic" way to do it:

def rle_encode(in_list):
    # Handle empty list first.

    if not in_list:
        return []

    # Init output list so that first element reflect first input item.

    out_list = [(in_list[0], 1)]

    # Then process all other items in sequence.

    for item in in_list[1:]:
        # If same as last, up count, otherwise new element with count 1.

        if item == out_list[-1][0]:
            out_list[-1] = (item, out_list[-1][1] + 1)
        else:
            out_list.append((item, 1))

    return out_list

print(rle_encode([5, 5, 5, 10, 10]))
print(rle_encode([5, 5, 5, 10, 10, 7, 7, 7, 5, 10, 7]))
print(rle_encode([]))

As expected, the output is:

[(5, 3), (10, 2)]
[(5, 3), (10, 2), (7, 3), (5, 1), (10, 1), (7, 1)]
[]

---

In a bit more detail, it sets up an output list containing a tuple representing the first input item. So, for 5 , it makes a list [(5, 1)] (value 5 with count 1 ).

Then it processes every other input item. If the item has the same value as the last one processed, it simply increases the count.

If it's a different value to the last one processed, it creates a new output value in the output list with the new value and count of one, similar to what was done for the initial input value.

So, as you run through the items for your example, you'll see how the list changes:

Input     Output              Description
-----     ------              -----------
  5       [(5, 1)]            First value, init with count 1.
  5       [(5, 2)]            Same as last, increase count.
  5       [(5, 3)]            Same as last, increase count.
 10       [(5, 3), (10, 1)]   New value, append with count 1.
 10       [(5, 3), (10, 2)]   Same as last, increase count.

The only other bit is detecting an empty input list before starting that process, so that you don't try to use a non-existent first value.