algorithme comparant des séquences

Version imprimable

Voici mes données :
Code:

1 2 3 $TEM_ref = 'TCTGTGCCGCCGTCATTACCATGAGCGATAACAGCGCCGCCAATCTGCTGCTGGCCACCG’; $contig = 'TCTGTGCCGCCGCCATTACCATGAGCGATAACATCGCCGCCAATCTGCTGCTGGCCACCG’; $consensus = 'TCTGTGCCGCCGYCATTACCATGAGCGATAACAKCGCCGCCAATCTGCTGCTGGCCACCG’;
car dans le code génétique (connu par le programme) : Y = T ou C et K = G ou T. On peut donc travailler sur $consensus directement ($consensus est le consensus de $TEM_ref et $ contig) et ainsi connaitre les différences entre $TEM_ref et $contig.

Je dois comparer $contig à $TEM_ref et vérifier que l'AGC de $TEM_ref est bien présent dans $contig (ce qui n'est pas le cas ici, car $contig contient ATG donc dans $consensus, c'est un K car T ou G).
$contig est variable et peut être différent de $TEM_ref à d'autres positions que AGC, par exemple dans ce cas, il y a un C au lieu d'un T mais cela n'est pas important car seul l'AGC compte.

Est-ce clair? Comment procéderiez-vous?

Merci pour votre aide.

Nb : je dois utiliser une boucle car il y a plusieurs triplets à vérifier et pas seulement AGC, je compte faire un tableau comptenant les différents triplets à vérifier et leur position dans la TEM_ref mais peut-être y a-t-il plus simple.

peut-être quelque chose du genre :
Code:

1 2 $consensus = 'TCTGTGCCGCCGYCATTACCATGAGCGATAACAKCGCCGCCAATCTGCTGCTGGCCACCG...’; my ($mut1, $mut2 ...) = $consensus =~ m/[a-z]{32}([a-z]{3})[a-z]{22}([a-z]{3}).../i;
avec $mut1 qui vaut 'AKC' et $mut2 vaut 'CCG' .... $mut3

Dans ton exemple, peut-on imaginer qu'il puisse exister plusieurs AGC dans $TEM_ref ?
S'il ne peut y en avoir qu'un (ou si l'on ne veut traiter que le premier), voici un exemple qui utiliserais index et substr.
Code:

1 2 3 4 5 6 7 8 my @triplet = qw(AGC); foreach my $triplet (@triplet) { my $pos_in_TEM = index($TEM_ref, $triplet); push @mut, substr($contig, $pos_in_TEM, length($triplet)); } # Le tableau @mut contient pour chaque triplet, la valeur du triplet à la même position dans $contig
Je ne suis pas sûr d'avoir compris ta demande...

Voici ce que j'ai fait :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
			my ($mut1, $mut2, $mut3 ) = $consensus=~ m/[a-z\.]{41}([a-z\.]{3})[a-z]{117}([a-z]{3})[a-z]{219}([a-z]{3})[a-z]{54}/i;
 
			if ($mut1 ne 'AGC'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('AGC');
 
				if ($mut1 eq 'AGC'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'AGC > '.$mut1." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut2 ne 'CGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('CGT');
 
				if ($mut2 eq 'CGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'CGT > '.$mut2." ($mut_aa > $ref_aa)\t";
				}
			}
			if ($mut3 ne 'GGT'){
 
				my $mut_aa = $myCodonTable->translate($mut1);
				my $ref_aa = $myCodonTable->translate('GGT');
 
				if ($mut3 eq 'GGT'){
					print $bact."\tpas de mutation\t";
				}
				else {
					print $bact."\t".'GGT > '.$mut3." ($mut_aa > $ref_aa)\t";
				}
			}

car on doit analyser l'AGC puis le CGT et enfin le GGT et donc, pour répondre à ta question, il peut y avoir plusieur AGC dans la séquence mais ce qu'on doit analyser, c'est AGC en position 42, puis le CGT en position 162 (41 + 3 + 117 = 1611) et ensuite le GGT à la position 340 (117 + 3 + 219 = 339). Est-ce plus clair?

Non, ce n'est pas plus clair, mais si tu veux dire qu'il faut analyser à chaque fois la première séquence de chacun des 3 triplets AGC, CGT et GGT, mon exemple ci-dessus devrait fonctionner en modifiant la définition de @triplet en :

Code:

my @triplet = qw(AGC CGT GGT);

Si en revanche, il ne faut rechercher CGT qu'après la première occurrence de AGC, et GGT qu'après la première occurrence de CGT faisant suite à AGC, il faut légèrement modifier mon exemple :
Code:

1 2 3 4 5 6 7 my $start_pos = 0; foreach my $triplet (@triplet) { my $pos_in_TEM = index($TEM_ref, $triplet, $start_pos); push @mut, substr($contig, $pos_in_TEM, length($triplet)); $start_pos = $pos_in_TEM+length($triplet); }

Citation:

Envoyé par Philou67430

Non, ce n'est pas plus clair, mais si tu veux dire qu'il faut analyser à chaque fois la première séquence de chacun des 3 triplets AGC, CGT et GGT, mon exemple ci-dessus devrait fonctionner

Désolée, mais ce n'est pas facile à expliquer mais merci pour ton aide :

Il ne faut pas analyser la première occurrence des 3 triplets mais vérifier qu'on trouve bien AGC en position 42, le CGT en position 162 et le GGT à la position 340. Je récupère donc les valeurs des positions
- 42-43-44 et je vérifie que c'est bien AGC ($mut1)
- 162-163-164 et je vérifie que c'est bien CGT ($mut2)
- 340-341-342 et je vérifie que c'est bien GGT ($mut3)

J'utilise donc :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 my ($mut1, $mut2, $mut3 ) = $consensus=~ m/[a-z\.]{41}([a-z\.]{3})[a-z]{117}([a-z]{3})[a-z]{219}([a-z]{3})[a-z]{54}/i; if ($mut1 ne 'AGC'){ my $mut_aa = $myCodonTable->translate($mut1); my $ref_aa = $myCodonTable->translate('AGC'); if ($mut1 eq 'AGC'){ print $bact."\tpas de mutation\t"; } else { print $bact."\t".'AGC > '.$mut1." ($mut_aa > $ref_aa)\t"; } } if ($mut2 ne 'CGT'){ my $mut_aa = $myCodonTable->translate($mut1); my $ref_aa = $myCodonTable->translate('CGT'); if ($mut2 eq 'CGT'){ print $bact."\tpas de mutation\t"; } else { print $bact."\t".'CGT > '.$mut2." ($mut_aa > $ref_aa)\t"; } } if ($mut3 ne 'GGT'){ my $mut_aa = $myCodonTable->translate($mut1); my $ref_aa = $myCodonTable->translate('GGT'); if ($mut3 eq 'GGT'){ print $bact."\tpas de mutation\t"; } else { print $bact."\t".'GGT > '.$mut3." ($mut_aa > $ref_aa)\t"; } }
mon code fonctionne

Tu veux dire que les positions pour chaque triplets sont imposées ?
Dans ce cas, pourquoi ne pas utiliser une table de hashage :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
my %triplet = (AGC => 42, CGT => 162, GGT => 340);
 
foreach my $triplet (keys %triplet) {
  my $pos_in_TEM = $triplet{$triplet};
  $mut = substr($consensus, $pos_in_TEM, length($triplet));
 
  # $mut contient le triplet de $consensus correspondant à la position du triplet en cours de traitement dans TEM.
  if ($mut != $triplet) {
     #
  }
  else {
     #
  }
}

15/04/2011, 09h24
Jasmine80

Citation:

Envoyé par Philou67430

Tu veux dire que les positions pour chaque triplets sont imposées ?
Dans ce cas, pourquoi ne pas utiliser une table de hashage :

C'est vrai que c'est une autre solution. Est-ce mieux que la regexp que j'utilise? Normalement, les séquences doivent toujours avoir ce format mais il vaut peut-être mieux que je vérifie qu'elles ont la bonne longueur et que les positions ne sont pas décalées.
15/04/2011, 10h01
Philou67430

L'usage de regexp, dans ce contexte où les positions sont bien déterminées, me semble une solution inadaptée, essentiellement pour des raison de lisibilité et de maintenance.
15/04/2011, 10h26
Jasmine80

Citation:

Envoyé par Philou67430

L'usage de regexp, dans ce contexte où les positions sont bien déterminées, me semble une solution inadaptée, essentiellement pour des raison de lisibilité et de maintenance.

Ok et merci