如何在保留 Python 中元素的原始顺序的同时返回字符串中的项目列表

Question

I am stuck on this coding challenge from Codewars:

"Implement the function unique_in_order which takes as argument a sequence and returns a list of items without any elements with the same value next to each other and preserving the original order of elements."

"For example:

unique_in_order('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']
unique_in_order('ABBCcAD')         == ['A', 'B', 'C', 'c', 'A', 'D']
unique_in_order([1,2,2,3,3])       == [1,2,3]

"

This is how far I was able to come so far:

def unique_in_order(iterable):
    iterable= list(set(iterable))

    return sorted(iterable)

Which gets me an output of:

['A', 'B', 'C', 'D']

For the following input:

['AAAABBBCCDAABBB'] 

instead of the desired output of:

['A', 'B', 'C', 'D', 'A', 'B'] 

I appreciate your help.

Answer 1

set creates an object with each element in the list occuring only once. Instead of a built in function you're going to have to write something yourself. How to do this?

First, create the input and a list that willstore your result:

input_word = 'aabbbaaa'
output_list = []

Now, what we will do is loop over the word, and every new letter we append. So we need to track what the "current" letter is:

current_letter = None

At first we set it to None because we have no current letter yet. Now we loop over the word:

for letter in input_word:
    if letter != current_letter:
        output_list.append(letter)
        current_letter = letter
print(output_list)
>>> ['a', 'b', 'a']

Answer 2

The easiest way would be to do this:

>>> string = "AAAABBBCCDAABBB"
>>> new_list = []
>>> for i in string:
...     if not new_list:
...             new_list.append(i)
...     elif new_list[-1] != i:
...             new_list.append(i)
...
>>> new_list
['A', 'B', 'C', 'D', 'A', 'B']

You can wrap this into a function if need be.

Answer 3

You can do this easily with a list comprehension using zip and some nifty slicing. It's basically the pairwise recipe without using itertools. If you want you can look that recipe up if you need it too.

[it[0]] + [nc for c, nc in zip(it, it[1:]) if c != nc]

For clarity c is the current character nc is the next character in the pair.

---

>>> it = 'AAAABBBCCDAABBB'
>>> [it[0]] + [nc for c, nc in zip(it, it[1:]) if c != nc]
['A', 'B', 'C', 'D', 'A', 'B']

---

This can be shown as a standard for loop as well for more clarity:

result = [it[0]]
for c, nc in zip(iterable, iterable[1:]):
    if c != nc:
        result.append(nc)

Answer 4

You can try this.

Iterate through the string. Whenever ith element and ith+1 don't match add the ith element to list `res.

def unique_order(_iter):
    if not _iter:
        return []
    res=[]
    for i in range(0,len(_iter)-1):
        if _iter[i]!=_iter[i+1]:
            res.append(_iter[i])
    res.append(_iter[-1])
    return res

unique_order('AAAABBBCCDAABBB') #output is ['A', 'B', 'C', 'D', 'A', 'B']

---

itertools.groupby() can be used here.

from itertools import groupby
def unique_order(_iter):
    return [k for k, g in groupby(_iter)] #'AAAABBBCCDAABBB'--> ['A', 'B', 'C', 'D', 'A', 'B']

Answer 5

You should use itertools.groupby . The behaviour you want is the same as the uniq command. As the doc says, groupby has a similar beahviour.

>>> import itertools
>>> [k for k, _ in itertools.groupby('AAAABBBCCDAABBB')]
['A', 'B', 'C', 'D', 'A', 'B']
>>> 

This question describes a similar behaviour to yours.

Answer 6

def unique_in_order(iterable):
    output = []
    letter = None
    for current in iterable:
        if current != letter:
            output.append(current)
            letter = current

    return output