Python 在两个基因组序列中找到最长的子串

我有两个序列aaaaaagaaagaag，AAAGAAG。 正确答案是AAGAAG

但我的代码给出了AA

有时两个字符串的顺序也会是AAAGAAG，aaaaaaaaaagaag

这是我的密码

`def longestSubstringFinder(string1, string2):
    string1=string1.strip()
    string2=string2.strip()
    answer = ""
    len1=len(string1)
    len2=len(string2)
    if int(len1)>1 and int(len2)>1:
        for i in range(1,len1,1):
            match = ""
            for j in range(len2):
                if len1>len2:
                    if i+j<len1 and (string1[i+j]==string2[i+j]):
                        match=str(match)+str(string2[i+j])
                        print(match)
                    else:
                        if len(match)>len(answer):
                            answer=match
                            match=""
                elif len2>len1:
                    if i+j<len2 and (string1[i+j]==string2[i+j]):
                        match=str(match)+str(string2[i+j])
                        print(match)
                    else:
                        if len(match)>len(answer):
                            answer=match
                            match=""
    return(answer)`

`def longestSubstringFinder（string1、string2）：
string1=string1.strip（）
string2=string2.strip（）
答案=”“
len1=len（string1）
len2=len（string2）
如果int（len1）>1且int（len2）>1：
对于范围（1，len1,1）中的i：
match=“”
对于范围内的j（len2）：
如果len1>len2：
如果i+jlen（回答）：
答案=匹配
match=“”
elif len2>len1：
如果i+jlen（回答）：
答案=匹配
match=“”
返回（答复）`

获取两个字符串的所有子字符串，找到两组子字符串的交集，然后找到交集中最大的字符串

def get_all_substrings(input_string):
  length = len(input_string)
  return [input_string[i:j+1] for i in range(length) for j in range(i,length)]

strA = 'AAAAAAAAAGAAAAGAAGAAG'
strB = 'AAAGAAG'

intersection = set(get_all_substrings(strA)).intersection(set(get_all_substrings(strB)))
print(max(intersection, key=len))
>> 'AAAGAAG'

---

获取两个字符串的所有子字符串，找到两组子字符串的交集，然后找到交集中最大的字符串

def get_all_substrings(input_string):
  length = len(input_string)
  return [input_string[i:j+1] for i in range(length) for j in range(i,length)]

strA = 'AAAAAAAAAGAAAAGAAGAAG'
strB = 'AAAGAAG'

intersection = set(get_all_substrings(strA)).intersection(set(get_all_substrings(strB)))
print(max(intersection, key=len))
>> 'AAAGAAG'

---

几周前，我偶然发现了Python中的

difflib

包，它非常适合这种工作

以下是您的问题的解决方案：

import difflib
matcher = difflib.SequenceMatcher()

str1 = 'AGAGGAG'
str2 = 'AAAAAAAAAGAAAAGAAGAAG'
matcher.set_seq2(str2)
matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of AAAGAAG found in AAAAAAAAAGAAAAGAAGAAG: AAAGAAG
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# AAAAAAAAAGA|AAAGAAG|AAG

str1 = 'AGAG'

matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of AGAG found in AAAAAAAAAGAAAAGAAGAAG: AGA
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# AAAAAAAA|AGA|AAAGAAGAAG

str1 = 'XXX'

matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of XXX found in AAAAAAAAAGAAAAGAAGAAG: 
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# ||AAAAAAAAAGAAAAGAAGAAG

文件：

SequenceMatcher计算并缓存有关 第二个序列，所以如果你想比较一个序列和多个序列 序列，使用set_seq2（）一次性设置常用的序列 重复调用set_seq1（），对其他每个序列调用一次

而且速度也很快

我计时很好，它计时

10000个循环，每个循环的最佳时间为3:85.2µs

---

我的解决方案计时了10000个循环，每个循环的最佳时间为3:31.6µs

几周前，我偶然发现了Python中的

difflib

包，它非常适合这种工作

以下是您的问题的解决方案：

import difflib
matcher = difflib.SequenceMatcher()

str1 = 'AGAGGAG'
str2 = 'AAAAAAAAAGAAAAGAAGAAG'
matcher.set_seq2(str2)
matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of AAAGAAG found in AAAAAAAAAGAAAAGAAGAAG: AAAGAAG
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# AAAAAAAAAGA|AAAGAAG|AAG

str1 = 'AGAG'

matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of AGAG found in AAAAAAAAAGAAAAGAAGAAG: AGA
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# AAAAAAAA|AGA|AAAGAAGAAG

str1 = 'XXX'

matcher.set_seq1(str1)

m = matcher.find_longest_match(0, len(str1), 0, len(str2))
print("Longest sequence of {} found in {}: {}".format(str1, str2, str1[m.a: m.a+m.size]))
# Longest sequence of XXX found in AAAAAAAAAGAAAAGAAGAAG: 
print(str2[:m.b]+'|'+str2[m.b:m.b+m.size]+'|'+str2[m.b+m.size:])
# ||AAAAAAAAAGAAAAGAAGAAG

文件：

SequenceMatcher计算并缓存有关 第二个序列，所以如果你想比较一个序列和多个序列 序列，使用set_seq2（）一次性设置常用的序列 重复调用set_seq1（），对其他每个序列调用一次

而且速度也很快

我计时很好，它计时

10000个循环，每个循环的最佳时间为3:85.2µs

---

我的解决方案计时

10000个循环，每个循环的最佳时间为3:31.6µs

请提供一个工作示例，人们可以将其复制到编辑器中。您的第二个字符串实际上是第一个字符串的一部分。。它从@Chris_Rands的第一个字符串结尾处结束3个字符。可能重复的@Chris_Rands仍然返回相同的字符串error@AK47，是的，循环在到达末尾之前被绊倒。请提供一个工作示例，人们可以将其复制到编辑器中。您的第二个字符串实际上是第一个字符串的一部分。。它从@Chris_Rands的第一个字符串结尾处结束3个字符。可能重复的@Chris_Rands仍然返回相同的字符串error@AK47，是的，循环在到达终点之前就被绊倒了这很短，很聪明：）这是set方法的一个很好的用法。为了降低计算复杂度，特别是考虑到其中一个字符串可能相当长，可以将其转换为一个字符串比较函数，使用

maxlength=max（len（input_string1），len（input_string2））

限制最大子字符串？这很短，很聪明：）这是set方法的一个很好的用法。为了降低计算复杂度，特别是考虑到其中一个字符串可能相当长，可以将其转换为一个字符串比较函数，使用

maxlength=max（len（input_string1），len（input_string2））

限制最大子字符串？