Удалить элемент из списка на основе следующего элемента в том же списке

Здесь вы можете использовать groupby() и max():

from itertools import groupby

with open('toy.txt') as f_input:
    for key, group in groupby(f_input, lambda x: x[:2]):
        print(max(group, key=lambda x: len(x)).strip())

Это будет отображать:

ABCDEFGHIJKLMNO
CEST
DBTSFDEO
EOEUDNBNUW
EAEUDNBNUW
FGH

groupby() работает, возвращая список совпадающих элементов на основе функции, в данном случае последовательные строки с одинаковыми первыми двумя символами. Затем функция max() берет этот список и возвращает элемент списка с самой длинной длиной.

with open('demo.txt') as f:
    lines = f.readlines()

l_lines = len(lines)

n_lst = []

for i, line in enumerate(lines):
    line = line.strip()
    if i == l_lines - 1:
        if lines[-2] not in line:
            n_lst.append(line)
        break
    if line not in lines[i + 1]:
        n_lst.append(line)

print(n_lst)

Выход

['ABCDEFGHIJKLMNO', 'CEST', 'DBTSFDEO', 'EOEUDNBNUW', 'EAEUDNBNUW', 'FGH']

# assuming list is sorted:
pattern = ["ABCDE",
"ABCDEFG",
"ABCDEFGH",
"ABCDEFGHIJKLMNO",
"CEST",
"DBTSFDE",
"DBTSFDEO",
"EOEUDNBNUW",
"EAEUDNBNUW",
"FG",
"FGH"]

pattern = list(reversed(pattern))

def iterate_patterns():
    while pattern:
        i = pattern.pop()
        throw_it_away = False
        for p in pattern:
            if p.startswith(i):
                throw_it_away = True
                break
        if throw_it_away == False:
            yield i

print(list(iterate_patterns()))

Выход:

['ABCDEFGHIJKLMNO', 'CEST', 'DBTSFDEO', 'EOEUDNBNUW', 'EAEUDNBNUW', 'FGH']

Вы можете использовать двоичное дерево, процесс вставки которого пытается найти узлы, предшествующие значению:

class Tree:
  def __init__(self, val=None):
    self.left, self.value, self.right = None, val, None
  def insert_val(self, _val):
    if self.value is None or _val.startswith(self.value):
       self.value = _val
    else:
       if _val < self.value:
          getattr(self.left, 'insert_val', lambda x:setattr(self, 'left', Tree(x)))(_val)
       else:
          getattr(self.right, 'insert_val', lambda x:setattr(self, 'right', Tree(x)))(_val)
  def flatten(self):
     return [*getattr(self.left, 'flatten', lambda :[])(), self.value, *getattr(self.right, 'flatten', lambda :[])()]

t = Tree()
for i in open('filename.txt'):
  t.insert_val(i.strip('\n'))
print(t.flatten())

Выход:

['ABCDEFGHIJKLMNO', 'CEST', 'DBTSFDEO', 'EAEUDNBNUW', 'EOEUDNBNUW', 'FGH']

Есть и другие рабочие ответы, но ни один из них не объясняет вашу настоящую проблему. вы действительно были близки к действительному решению, и это, на мой взгляд, наиболее читаемый ответ.

Ошибка возникла из-за того, что вы были изменение того же списка при проверке индекса с помощью range().

Таким образом, увеличивая переменную i, вы удаляли элемент из списка, который в какой-то момент неизбежно вызывает index error.

Поэтому вот рабочая версия вашего исходного кода с некоторыми изменениями,

pattern = ["ABCDE","ABCDEFG","ABCDEFGH","ABCDEFGHIJKLMNO","CEST","DBTSFDE","DBTSFDEO","EOEUDNBNUW","EAEUDNBNUW","FG","FGH"]
output_pattern = []


for i in range(0, (len(pattern)-1)):
    if not pattern[i] in pattern[i+1]:
        output_pattern.append(pattern[i]) 

# Adding the last item
output_pattern.append(pattern[-1])   
print (output_pattern)

>>>> ['ABCDEFGHIJKLMNO', 'CEST', 'DBTSFDEO', 'EOEUDNBNUW', 'EAEUDNBNUW', 'FGH']    

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

Что делает этот код?

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

Что мне делать с последним предметом?

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

output_pattern.append(pattern[-1])

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

Важная заметка

Этот ответ был написан в ответ на первоначальный вопрос OP, где он хотел сохранить более длительное перекрытие, и я цитирую на основе следующего элемента в том же списке. Как заявил @Chris_Rands, если ваши проблемы связаны с биологической задачей и вам нужно найти перекрытие любой, это решение не подходит для ваших нужд.

Пример, когда этот код не смог бы распознать потенциальное перекрытие,

pattern = ["ACD", "AD", "BACD"]

где он будет выдавать тот же результат без удаления возможного перекрытия "ACD". Теперь, просто в качестве пояснения, мы с это означало бы гораздо более сложный алгоритм изначально думали, что это выходит за рамки требований вопроса. Если это когда-либо будет вашим случаем, я могу ошибаться здесь, но я действительно думаю, что реализация на C++ кажется более подходящей. взгляните на алгоритм CD-Hit, предложенный @Chris_Rands в разделе комментариев.

Это приведет вас туда, куда вы хотите:

with open('toy.txt' ,'r') as f:
    lines = f.readlines()
    data = set(lines)
    print(sorted([i for i in lines if len([j for j in data if j.startswith(i)])==1]))

#['ABCDEFGHIJKLMNO', 'CEST', 'DBTSFDEO', 'EAEUDNBNUW', 'EOEUDNBNUW', 'FGH']

Я добавил set на тот случай, если один и тот же текст встречается несколько раз.

Простой способ - обрабатывать входной файл по одной строке за раз, сравнивать каждую строку с предыдущей и сохранять единицу предыдущий, если она не содержится в текущей.

Код может быть таким простым, как:

with open('toy.txt' ,'r') as f:
    old = next(f).strip()               # keep first line after stripping EOL 

    for pattern in f:
        pattern = pattern.strip()       # strip end of line...
        if old not in pattern:
            print old                   # keep old if it is not contained in current line
        old = pattern                   # and store current line for next iteration
    print old                           # do not forget last line

Как указано в других ответах, ваша ошибка возникает из-за вычисления длины вашего ввода в начале, а затем его не обновления при сокращении списка.

Вот еще один вариант рабочего решения:

with open('toy.txt', 'r') as infile:
    input_lines = reversed(map(lambda s: s.strip(), infile.readlines()))

output = []
for pattern in input_lines:
    if len(output) == 0 or not output[-1].startswith(pattern):        
        output.append(pattern)

print('\n'.join(reversed(output)))

Не совсем соответствует вашим ожиданиям, но, учитывая, что вы заявляете, что он отсортирован (а это не так, рядом с EOEUDNBNUWD EAEUDNBNUW) и что я не знаю, почему вам не хватает EOEUDNBNUWD, я не уверен, правильно ли сформулированы ваши ожидания или я неправильно прочитал ваш вопрос.

(ах, да, я вижу, что понятие перекрывать бросает вызов подходам sort и startswith).

Было бы неплохо, если бы OP повторил этот конкретный аспект, я прочитал комментарий @DSM, не особо понимая его озабоченность. Теперь я знаю.

li = sorted([i.strip() for i in """
ABCDE
ABCDEFG
ABCDEFGH
ABCDEFGHIJKLMNO
CEST
DBTSFDE
DBTSFDEO
EOEUDNBNUW
EOEUDNBNUWD
EAEUDNBNUW
FEOEUDNBNUW
FG
FGH""".splitlines() if i.strip()])

def get_iter(li):
    prev = ""
    for i in li:
        if not i.startswith(prev):
            yield(prev)
        prev = i
    yield prev

for v in get_iter(li):
    print(v)

выход:

ABCDEFGHIJKLMNO
CEST
DBTSFDEO
EAEUDNBNUW
EOEUDNBNUWD
FEOEUDNBNUW
FGH

Код

import collections as ct


def read_file(filepath):
    """Yield a generator of lines from a file."""
    with open(filepath, "r") as f:
        for line in f:
            yield line.strip()


def find_longest_sequences(seqs):
    """Return a dict of the long common sequences."""
    seqs = tuple(seqs) 
    dd = ct.defaultdict(list)
    [dd[k].append(seq) for seq in seqs for k in seqs if k in seq]
    return {max(v, key=len) for v in dd.values()}


data = read_file("test.txt")
find_longest_sequences(data)

Выход

{'ABCDEFGHIJKLMNO',
 'CEST',
 'DBTSFDEO',
 'EAEUDNBNUW',
 'EOEUDNBNUWD',
 'FEOEUDNBNUW'}

Подробности

Мы используем read_file для получения каждой строки файла.

find_longest_sequences строит defaultdict, который группирует похожие последовательности вместе. Он выполняет итерацию данных с двумя циклами:

1. Первый цикл строит словарь пустых списков с уникальными последовательностями в качестве ключей.
2. Второй цикл добавляет в качестве значений любые строки, похожие на ключ.

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

Обратите внимание на некоторые расхождения с ожидаемым результатом:

1. FGH перекрывается с ABCDEFGHIJKLMNO и поэтому не является допустимым выходом.
2. FEOEUDNBNUWD не является исходной последовательностью. Постобработка необходима для перекрывающихся последовательностей.

Кенни, Вы почти получили это, но есть две проблемы, на которые указал @scharette:

1. Цикл for и удаление элемента из списка не должны идти вместе. Исправление заключается в использовании цикла while и явном увеличении индекса. Цикл while менее эффективен, потому что он вызывает len() несколько раз, а не один раз, но это то, что нужно для получения правильного результата.
2. IndexError. Это происходит только в самой последней строке. Мой способ справиться с этой проблемой - игнорировать ошибку.

При этом я изменил ваш код на:

with open('toy.txt' ,'r') as f:
    pattern = f.read().splitlines()
    print pattern

    try:
        i = 0
        while i < len(pattern):
            if pattern[i] in pattern[i+1]:
                pattern.remove(pattern[i])
            print pattern
            i += 1
    except IndexError:
        pass