Как найти повторы в списке?

Question

Я хочу найти повторяющиеся символы в списке, но они должны быть из стороны в сторону.

Например:

lst = ["A", "B", "B", "A"]

Я хочу обнаружить "B" с, но не "A" с.Если рядом нет повторяющихся символов, моя программа напечатает сообщение и закончит игру.Как я могу это сделать?

РЕДАКТИРОВАТЬ: Спасибо за все комментарии, все они были правдой.Мне просто нужно было найти, если «-X-» дублируется, и я сделал это с преобразованием списка в строку.Еще раз спасибо всем!

Answer 1

Мы можем выполнить цикл и проверить, будет ли последнее значение таким же, как текущее значение, или нет

lst = ["A", "B", "B", "A"]
tmp = ""
dup = ""
for x in lst:
    if x == tmp:
        print("Side by side value detected" + x)
    else:
        for s in dup.split(","):
            if s == x:
                print("Duplicate but not side by side "+ x)
        dup = dup + "," + x
    tmp = x

Вы можете написать еще один случай, если хотите печатать не похожие значения рядом

Answer 2

Использование пакета pandas может быть очень полезным для простого решения этой проблемы.

Сначала вы определяете Series из своего списка, а затем создаете сдвиг и сравниваете его с оригиналом.,Наконец, вы можете получить результат, если вы получите любой последующий дубликат или нет и даже получите дублирующиеся строки.

import pandas as pd
lst = ["A", "B", "B", "A"]
df = pd.Series(lst)
check = df.eq(df.shift())

Тогда вы можете получить логическое указание, если у вас есть последующие дубликаты или нет:

>> check.any()
True

И вы даже можете узнать, какие значения являются последующими дубликатами, таким образом:

>> df[check]
2    B

Answer 3

Если вы хотите знать только, равны ли два элемента рядом друг с другом, это будет делать:

def any_side_by_side(l):
    return any(first == second for first, second in zip(l, l[1:]))


print(any_side_by_side(['A', 'B', 'B', 'A']))
print(any_side_by_side(['B', 'A', 'B', 'A']))

Выход

True
False

Answer 4

Используя numpy, вы можете сравнить элементы списка со следующим элементом для каждого элемента списка.

import numpy as np

any(np.where(np.asarray(lst[1:]) == np.asarray(lst[:-1])))

lst[1:] представляет следующий элемент в списке.В вашем примере lst[1:] будет ["B", "B", "A"].Поскольку последний элемент не имеет соседа, lst[:-1] получает все элементы, кроме последнего, который будет ["A", "B", "B"].Код выше сравнивает эти два массива в поисках совпадений.Если найдено какое-либо совпадение, код оценит True, указывая, что есть хотя бы одна пара повторяющихся значений, в противном случае он оценит False.

Answer 5

Вы можете использовать itertools.groupby:

from itertools import groupby 

def any_side_by_side(iterable): 
     for k, group in groupby(iterable): 
         next(group) # discard first group element
         try: 
             next(group) # is there a second element?
             return True 
         except StopIteration: 
             pass 
     return False

Более короткий, но менее эффективный способ памяти будет

any(len(list(group)) > 1 for k, group in groupby(iterable))

Демонстрация:

>>> any_side_by_side(['A', 'B', 'B', 'A'])                                                                             
True
>>> any_side_by_side(['B', 'A', 'B', 'A'])                                                                             
False

Приведенная выше функция вернет True, если в вашем списке есть последовательность повторяющихся элементов, False в противном случае.

Другой вариант - рецепт pairwise изitertools документы.Вы можете скопировать или вставить его или импортировать из more_itertools.

>>> from more_itertools import pairwise                                                                                
>>>                                                                                                                    
>>> any(x == y for x,y in pairwise(['A', 'B', 'B', 'A']))                                                              
True
>>> any(x == y for x,y in pairwise(['B', 'A', 'B', 'A']))                                                              
False

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