Ma fonction était censée recevoir une grande chaîne, la parcourir et trouver le nombre maximum de répétitions consécutives du motif "AGATC". Indépendamment de ce que j'alimente cette fonction, mon retour est toujours de 1.

def agatc(s):
    maxrep = 0
    temp = 0
    for i in range(len(s) - 4):
        if s[i] == "A" and s[i + 1] == "G" and s[i + 2] == "A" and s[i + 3] == "T" and s[i + 4] == "C":
            temp += 1
            print(i)
            i += 3
        else:
            if temp > maxrep:
                maxrep = temp
            temp = 0
    return maxrep

Également essayé d'initialiser la boucle for avec (0, len(s) - 4, 1), j'ai obtenu le même retour.

Je pensais que le problème pouvait être d'ajouter 3 à la variable i (apparemment ce n'était pas le cas), j'ai donc ajouté print(i) pour voir ce qui se passait. J'ai obtenu ce qui suit:

45
1938
2049
2195
2952
2957
2962
2967
2972
2977
2982
2987
2992
2997
3002
3007
3012
3017
3022
3689
4754
1
Henrique Baesa 14 juin 2020 à 15:53

4 réponses

Meilleure réponse

De cette façon, vous pouvez trouver le nombre de correspondances qui se chevauchent:

def agatc(s):
    temp = 0
    for i in range(len(s) - len("AGATC") + 1):
        if s[i:i+len("AGATC")] == "AGATC":
            temp += 1
    return temp

Si vous souhaitez rechercher des correspondances sans chevauchement:

def agatc(s):
    temp = 0
    i = 0
    while i < len(s) - len("AGATC") + 1:
        if s[i:i+len("AGATC")] == "AGATC":
            temp += 1
            i += len("AGATC")
        else:
            i += 1
    return temp
3
Riccardo Bucco 15 juin 2020 à 09:18

Personnellement, j'utiliserais des expressions régulières. Mais si vous ne le souhaitez pas, vous pouvez utiliser la méthode str.find (). Voici ma solution:

def agatc(s):
    cnt = 0
    findstr='aga'                             # pattern you are looking for
    for i in range(len(s)):
        index = s.find(findstr)
        if index != -1:
            cnt+=1
            s = s[index+1:]                   # overlapping matches
            # s = s[index+len(findstr):]      # non-overlapping matches only
            print(index, s)                   # just to see what happens
    return cnt
0
Ronald 14 juin 2020 à 13:10

Cette fonction compte le plus grand nombre de 'AGATC' consécutifs dans une chaîne et renvoie le montant:

def agatc(s):
    w = "AGATC"
    maxrep = [m.start() for m in re.finditer(w,s)] # The beginning index fror each AGATC
    c = ''
    for i,v in enumerate(maxrep):
        if i < len(maxrep)-1:
            if v+5 == maxrep[i+1]:
                c+='y'
            else:
                c+='n'

    return len(max(c.split('n')))+1

print(agatc("oooooooooAGATCooooAGATCAGATCAGATCAGATCooooooAGATCAGATC"))

Production:

4
0
Ann Zen 14 juin 2020 à 13:28

Une solution simple avec le module re

import re

s = 'FGHAGATCATCFJSFAGATCAGATCFHGH'
match = re.finditer('(?P<name>AGATC)+', s)
max_len = 0
result = tuple()
for m in match:
    l = m.end() - m.start()
    if l > max_len:
        max_len = l
        result = (m.start(), m.end())

print(result)
0
Sơn Ninh 14 juin 2020 à 13:22