Python находит дубликаты, которые встречаются более 3 раз

Question

Я пытаюсь найти эффективный способ поиска трех или более последовательных дубликатов и замены их только на один в списке Python.

list_before = [1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 8, 8]

# expected
list_after = [1, 2, 3, 4, 5, 6, 6, 7, 8]

def replace(list_to_replace):
    for idx, val in enumerate(list_to_replace):
        if idx + 3 < len(list_to_replace):
            if val == list_to_replace[idx+1] == list_to_replace[idx+2]:
                del list_to_replace[idx+1]
                del list_to_replace[idx+2]
    return list_to_replace

>>> replace(list_before)
[1, 1, 3, 4, 5, 5, 6, 7, 7, 8, 8, 8]

В чем проблемаВот?Есть ли более эффективный способ?

Answer 1

>>> from itertools import groupby
>>> nums = [1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 8, 8]
>>> [k for k, g in groupby(nums) for i in range(1 + (len(list(g)) == 2))] 
[1, 2, 3, 4, 5, 6, 6, 7, 8]

Answer 2

Попробуйте таким образом, определив пользовательский метод для нарезки массива на основе условия:

def take_max_three(iterable):
  iterable = sorted(iterable) # It requires the iterable to be sorted, remove if already sorted
  i, x, size = 0, 0, len(iterable)
  while i < size-1:
    if iterable[i] < iterable[i+1]:
      ready = iterable[x:i+1]
      if len(ready) <= 3:
        yield ready
      else:
        yield ready[0:3]
      x = i + 1
    i += 1
  yield iterable[x:x+3]

Затем просто вызовите метод в массиве, это слегка модифицированный массив:

array = [1, 1, 2, 3, 4, 5, 5, 1, 5, 6, 6, 6, 7, 3, 7, 7, 8, 8, 8, 8, 8, 9]
take_max_three(array)
# => [[1, 1, 1], [2], [3, 3], [4], [5, 5, 5], [6, 6, 6], [7, 7, 7], [8, 8, 8], [9]]

Вы можете дополнительно настроить метод, передавая количество элементов, которые нужно взять.

Answer 3

Как указал Крис в своем ответе, однострочник возможен, но совсем не симпатичен.

In [88]: list(chain.from_iterable([(x,) if len(y) >= 3 else y for x, y in [(k, tuple(g)) for k, g in groupby(list_before)]]))
Out[88]: [1, 2, 3, 4, 5, 6, 6, 7, 8]

Я думаю, что должен быть лучший способ, но chain достаточно хакерский, чтобы иметь дело с не-итерируемыми.

Answer 4

Просто чтобы добавить объектно-ориентированный подход, который я использовал в потоках:

class StreamCount:
    def __init__(self, input_values):
        self.input_values = input_values
        self.output = []
        self.current_value = next(iter(input_values), None) # first element if there is any
        self.current_count = 0

    def process_new(self, value):
        if value == self.current_value:
            self.current_count += 1

        else:
            self.update_output()
            self.current_count = 1
            self.current_value = value

    def process_all(self):
        for v in self.input_values:
            self.process_new(v)

        # handle last values suite
        self.update_output()

        return self.output

    def update_output(self):
        if self.current_count > 2:
            self.output.append(self.current_value)
        else:
            self.output += [self.current_value for _ in range(self.current_count)]

Тесты

input_values = [1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 8, 8]
StreamCount(input_values).process_all()

Ouput: [1, 2, 3, 4, 5, 6, 6, 7, 8]

input_values = []

Ouput: []

input_values = [None]

Ouput: [Ни]

Answer 5

Это мое решение:

list_before = [1, 5, 7, 8, 6, 1, 4, 5, 6, 7, 1, 8, 8, 5, 2, 3, 7, 8, 8]

list_after = []
for item in list_before:
    if not item in list_after:
        list_after.append(item)

Answer 6

У меня хороший вариант использования для itertools.groupby:

>>> from itertools import groupby
>>> list_before = [1, 1, 1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 7, 7, 8, 8, 8, 8, 8]
>>> list_after = []
>>> for k, group in groupby(list_before):
...     lst = list(group)
...     if len(lst) >= 3:
...         list_after.append(k)
...     else:
...         list_after.extend(lst)
>>> list_after
[1, 2, 3, 4, 5, 6, 6, 7, 8]

Можно было бы сделать однострочную с itertools.chain, но цикл for почти наверняка более читабелен и аналогично производим.