découper une séquence en tronçons

Version imprimable

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#!/usr/local/bin/perl
 
 
use strict;
use warnings;
 
=h
       on va couper la séquence par tronçons de $window nucléotides (sans point)
	On doit garder les index de ces nucléotides
 
 
=cut
 
# clé : id     valeurs : array contenant la séquence
my %h_seq;
# position dans l'alignement du 1ier nucléotide de la séquence
my %h_start;		
# position dans l'alignement du dernier nucléotide de la séquence
my %h_end;
 
my $k = 'Escherichia_coli';
my $s = '---CTG-GG--GTGAAGTCGTAACAA-GGTAGCCGTAGGGGAACCTGCGGCTGGATCACCTCCTTA--ACGAAAGATT---GACGATTGGTAAGAATCCACAACAAGTTGTTC-----TTCA-------';
$s =~ s/[-~]/\./g;
if($s =~ /^\.*([a-z])[.a-z]+?([a-z])\.*$/i){
	# position dans l'alignement du 1ier nucléotide de la séquence
	$h_start{$k} = $-[1]; 		# = 3  (C)
	# position dans l'alignement du dernier nucléotide de la séquence
	$h_end{$k} = $-[2];  		 # = 18  (A)
} 
 
# clé : id     valeurs : array contenant la séquence
@{$h_seq{$k}} = split(//, $s);
 
 
# taille de la fenêtre du criblage
my $window = 5;
 
# position dans la séquence 
my $index = $h_start{$k};
# motif de $window nucléotide
my $pattern= '';
# index de départ de ce motif dans la séquence alignée
my $pattern_start;
# index de fin de ce motif dans la séquence alignée
my $pattern_end;
 
# on doit s'arrêter $window nucléotides (sans point) avant la fin de la séquence  
# dans cet exemple ci  au C de :     C-----TTCA-------
while ($index < ($h_end{$k} - ?)){
	while(length($pattern)<$window){
		if(!$pattern){
			$pattern_start = $index;
		}
		if($h_seq{$k}[$index] !~ /\./){
			$pattern .= $h_seq{$k}[$index];
		}
		if(length($pattern)==5){
			$pattern_end = $index;
			$pattern = '';
		}
		$index++;
	}
}
 
 
print $pattern."\t".$pattern_start."\t".$pattern_end."\n";
# premier pentanucléotide : 	CTGGG		3	8
# second pentanucléotide : 		TGGGG		4	11
# 3ième pentanucléotide : 		GGGGT		5	12

J'ai une séquence que j'aimerais découper en tronçons de 5 nucléotides + x points (compris entre ces 5 nucléotides).

ex de séquence : ---CTG-GG--GTGAAGTCGTAACAA-GGTAGCCGTAGGGGAAC

Code:

1
2
3
4
#					pentanuc        départ		fin		séquence réelle
# premier pentanucléotide : 	        CTGGG		3		8		CTG-GG
# second pentanucléotide : 		TGGGG		4		11		TG-GG--G
# 3ième pentanucléotide : 		GGGGT		5		12		G-GG--GT

Ce que je dois récupérer, c'est l'index de départ et de fin du motif dans la séquence

Je bloque dans le premier while

Code:

1
2
3
# on doit s'arrêter $window nucléotides (sans point) avant la fin de la séquence  
# dans cet exemple ci  au C de :     C-----TTCA-------
while ($index < ($h_end{$k} - ?))

je ne sais pas comment calculer la position de C qui est le 5ième nucléotide à partir de la fin.

Merci pour votre aide.

J'ai trouvé la façon d'avoir une borne au premier while

Code:

1
2
3
4
5
6
7
8
9
10
11
my $expreg = '[atcg]\.*' x $window;
 
if($s =~ /^\.*([a-z])[.a-z]+?($expreg)\.*$/i){
	# position dans l'alignement du 1ier nucléotide de la séquence
	$h_start{$k} = $-[1]; 		# = 3  (C)
	# position dans l'alignement du dernier nucléotide de la séquence
	$h_end{$k} = $-[2];  		 # = 18  (A)
...
while ($index < $h_end{$k}) {
 
}

Mais cela ne fonctionne toujours pas :(

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#!/usr/local/bin/perl
 
 
use strict;
use warnings;
 
=h
       on va couper la séquence par tronçons de $window nucléotides (sans point)
	On doit garder les index de ces nucléotides
 
 
=cut
 
# clé : id     valeurs : array contenant la séquence
my %h_seq;
# position dans l'alignement du 1ier nucléotide de la séquence
my %h_start;		
# position dans l'alignement du dernier nucléotide de la séquence
my %h_end;
 
my $k = 'Escherichia_coli';
my $s = '---CTG-GG--GTGAAGTCGTAACAA-GGTAGCCGTAGGGGAACCTGCGGCTGGATCACCTCCTTA--ACGAAAGATT---GACGATTGGTAAGAATCCACAACAAGTTGTTC-----TTCA-------';
 
$s =~ s/[-~]/\./g;
 
# taille de la fenêtre du criblage
my $window = 5;
 
if($s =~ /^\.*([a-z])[.a-z]+?([atcg])\.*$/i){
	# position dans l'alignement du 1ier nucléotide de la séquence
	$h_start{$k} = $-[1]; 		# = 3  (C)
	# position dans l'alignement du dernier nucléotide de la séquence
	$h_end{$k} = $-[2];  		 # = 112  (C-----TTCA-------)
} 
 
# clé : id     valeurs : array contenant la séquence
@{$h_seq{$k}} = split(//, $s);
 
 
 
 
# position dans la séquence 
my $index = $h_start{$k};
# motif de $window nucléotide
my $pattern= '';
# index de départ de ce motif dans la séquence alignée
my $pattern_start;
# index de fin de ce motif dans la séquence alignée
my $pattern_end;
 
# on doit s'arrêter $window nucléotides (sans point) avant la fin de la séquence  
# dans cet exemple ci  au C de :     C-----TTCA-------
 
while (  $index < $h_end{$k}+1) {   # < 112
	if(!$pattern){
		$pattern_start = $index;
	}
	if((length($pattern) < $window) && ($h_seq{$k}[$index] !~ /\./)){
		$pattern .= $h_seq{$k}[$index];
	}
	if(length($pattern)==$window){
		$pattern_end = $index;
		print $pattern."\t".$pattern_start."\t".$pattern_end."\n";
		$pattern = '';
		# on recule l'index 
		$index = $pattern_start;
	}
	$index++;
}
 
 
 
#					pentanuc	     	départ		fin		séquence réelle
# premier pentanucléotide : 	CTGGG		3		8		CTG-GG
# second pentanucléotide : 		TGGGG		4		11		TG-GG--G
# 3ième pentanucléotide : 		GGGGT		5		12		 G-GG--GT

Voila, j'ai réussi :yaisse2:

27/11/2008, 12h42
Jedai

Pourquoi ne pas directement découper la chaîne avec une regexp :

Code:

m/((?:[ACTG]\.*){4}[ACTG]|(?:[ACTG]\.*?)+)/g

En contexte de liste, tu auras directement tous tes tronçons dans un tableau, mais si tu tiens à avoir les indices, tu peux simplement utiliser cette regexp dans une boucle.

--
Jedaï
27/11/2008, 13h00
Jasmine80
En fait, j'ai une série de séquences alignées contenues dans %h_seq.
Code:

1 2 # clé : id valeurs : array contenant la séquence @{$h_seq{$k}} = split(//, $s);
Je veux comparer une d'entre elle (Escherichia coli) par rapport à toutes les autres.

Je dois donc découper E. coli en tronçons de 5 nucléotides et ensuite comparer ceux-ci aux tronçons équivalents (alignés) des autres séquences de %h_seq, d'où l'utilité des index qui sont les mêmes pour chaque array de séquences et qui me permettront donc de récupérer les tronçons équivalents des autres séquences.

Je vais regarder comment faire avec une expression régulière, merci pour ton conseil.

Ce que j'ai mal expliqué c'est que je dois à chaque fois décaler la fenêtre de découpe de 1 et les tronçons se chevauchent. Je pense que le while est dans ce cas-ci plus simple qu'une expression régulière.

L'ennui de mon script est que je fais plusieurs boucles inutilement mais sans cela, je dois tout imbriquer et cela devient très confus et perd de sa clarté dans les étapes de l'analyse. Peut-être devrais-je créer des sous-programme.

Qu'en pensez-vous?

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#!/usr/local/bin/perl
 
 
use strict;
use warnings;
 
use FileHandle;
use Bio::SeqIO;
 
 
# clé : id     valeurs : array contenant la séquence
my %h_seq;
# position dans l'alignement du 1ier nucléotide de la séquence
my %h_start;
# position dans l'alignement du dernier nucléotide de la séquence
my %h_end;
# liste des organismes à analyser
my %h_orga = (
			'Escherichia_coli_16_23S_consensus' => 1,
);
 
 
#------------------------------------------------#
#   récupération des sequences alignées       #
#------------------------------------------------#
my $file_in = 'P:/Theorie/PCR_Bact_Hybridation/sequences/Test.fsa';
my $in = Bio::SeqIO->new(-file => => $file_in , -format => 'fasta');
while ( my $seq = $in->next_seq() ) { 
	my $s = $seq->seq;
	$s =~ s/[-~]/\./g;
	if($s =~ /^\.*([a-z])[.a-z]+?([a-z])\.*$/i){
		# position dans l'alignement du 1ier nucléotide de la séquence
		$h_start{$seq->primary_id} = $-[1];
		# position dans l'alignement du dernier nucléotide de la séquence
		$h_end{$seq->primary_id} = $-[2];
	} 
	# clé : id     valeurs : array contenant la séquence
	@{$h_seq{$seq->primary_id}} = split(//, $s);
}
 
my $window = 5;
 
 
#------------------------------------------------#
#   récupération des motifs par séquence              #
#------------------------------------------------#
 
# clé : organisme   valeurs array contenant les index de fin et de début des motifs de $window nucléotides de cette séquence
my %h_pattern;
foreach my $k (keys %h_seq){ 
	if($h_orga{$k}){
 
		# $h_start{$k} = position du premier nucléotide dans la séquence alignée
		# $h_end{$k} = position du dernier nucléotide dans la séquence alignée
 
		# position dans la séquence 
		my $index = $h_start{$k};
		# motif de $window nucléotide
		my $pattern= '';
		# index de départ de ce motif dans la séquence alignée
		my $pattern_start;
		# index de fin de ce motif dans la séquence alignée
		my $pattern_end;
 
		# découpe en tronçons de $window nucléotides
		while (  $index < $h_end{$k}+1) {   
			if(!$pattern){
				$pattern_start = $index;
			}
			if((length($pattern) < $window) && ($h_seq{$k}[$index] !~ /\./)){
				$pattern .= $h_seq{$k}[$index];
			}
			if(length($pattern)==$window){
				$pattern_end = $index;
				push(@{$h_pattern{$k}}, $pattern_start."_".$pattern."_".$pattern_end);
				$pattern = '';
				# on recule l'index 
				$index = $pattern_start;
			}
			$index++;
		}
	}
}
 
 
#------------------------------------------------#
#      analyse des motifs par séquences         #
#------------------------------------------------#
 
 
foreach my $k ( keys %h_pattern){ 
	foreach my $p (sort {$a<=>$b} @{$h_pattern{$k}}){
		my ($pattern_start,$pattern,$pattern_end) = split(/_/, $p);
	}
}

Merci pour votre aide.

Voila, le script est terminé. Le seul ennui est qu'il est mille fois plus lent que ce qu'il pourrait être ... mais bon au moins il fonctionne et sur un petit fichier, il ne faut pas attendre trop longtemps.

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
#!/usr/local/bin/perl
 
 
use strict;
use warnings;
 
use FileHandle;
use Bio::SeqIO;
 
 
# clé : id     valeurs : array contenant la séquence
my %h_seq;
# position dans l'alignement du 1ier nucléotide de la séquence
my %h_start;
# position dans l'alignement du dernier nucléotide de la séquence
my %h_end;
# liste des organismes à analyser
my %h_orga = (
			'Escherichia_coli' => 1,
);
 
 
#------------------------------------------------#
#   récupération des sequences alignées       #
#------------------------------------------------#
my $file_in = 'P:/Theorie/PCR_Bact_Hybridation/sequences/Test.fsa';
my $in = Bio::SeqIO->new(-file => => $file_in , -format => 'fasta');
while ( my $seq = $in->next_seq() ) { 
	my $s = $seq->seq;
	$s =~ s/[-~]/\./g;
	if($s =~ /^\.*([a-z])[.a-z]+?([a-z])\.*$/i){
		# position dans l'alignement du 1ier nucléotide de la séquence
		$h_start{$seq->primary_id} = $-[1];
		# position dans l'alignement du dernier nucléotide de la séquence
		$h_end{$seq->primary_id} = $-[2];
	} 
	# clé : id     valeurs : array contenant la séquence
	@{$h_seq{$seq->primary_id}} = split(//, $s);
}
 
my $window = 5;
 
 
#------------------------------------------------#
#   récupération des motifs par séquences     #
#------------------------------------------------#
 
# clé : organisme   valeurs array contenant les index de fin et de début des motifs de $window nucléotides de cette séquence
my %h_pattern;
foreach my $k (keys %h_seq){ 
	if($h_orga{$k}){
 
		# $h_start{$k} = position du premier nucléotide dans la séquence alignée
		# $h_end{$k} = position du dernier nucléotide dans la séquence alignée
 
		# position dans la séquence 
		my $index = $h_start{$k};
		# motif de $window nucléotide
		my $pattern= '';
		# index de départ de ce motif dans la séquence alignée
		my $pattern_start;
		# index de fin de ce motif dans la séquence alignée
		my $pattern_end;
 
		# découpe en tronçons de $window nucléotides
		while (  $index < $h_end{$k}+1) {   
			if(!$pattern){
				$pattern_start = $index;
			}
			if((length($pattern) < $window) && ($h_seq{$k}[$index] !~ /\./)){
				$pattern .= $h_seq{$k}[$index];
			}
			if(length($pattern)==$window){
				$pattern_end = $index;
				my $score_rel = &pattern_analyze (\%h_seq, $k, $pattern, $pattern_start, $pattern_end);
				print "$pattern, $pattern_start, $pattern_end, $score_rel\n";
				$pattern = '';
				# on recule l'index 
				$index = $pattern_start;
			}
			$index++;
		}
	}
}
 
 
#------------------------------------------------#
#      analyse des motifs par séquences         #
#------------------------------------------------#
 
 
 
# sub pattern_analyze
#----------------------------
# Entrée :      - une référence vers un hash contenant les séquences
# -------        - l'organisme de référence de ce hash (à comparer aux autres organismes de ce hash)
#              	- le motif à comparer
#                 - son index de départ et de fin dans l'alignement
# Retour :      - le pourcentage de nucléotide différent de la séquence de référence par rapport aux autres
 
sub pattern_analyze{
	my ($ref_seq, $orga_ref, $pattern, $pattern_start, $pattern_end) = @_;
 
	my $seq_ref;
	my @a_seq_compare;
	my $ref_seq_compare = \@a_seq_compare;
	foreach my $id (keys %{$ref_seq}){
		if($id =~ $orga_ref){
			$seq_ref = '';
			for(my $l = $pattern_start; $l<$pattern_end; $l++){
				$seq_ref .= $h_seq{$orga_ref}[$l];
			}
		}
		else{
			my $seq = '';
			for(my $l = $pattern_start; $l<=$pattern_end; $l++){
				$seq .= $h_seq{$id}[$l];
			}
			push(@a_seq_compare, $seq);
		}
	}
	my $score_rel = &CompareSequencesScore($seq_ref , $ref_seq_compare);
 
}
 
 
 
 
 
 
 
 
 
 
 
# sub CompareSequencesScore
#----------------------------
# Entrée :      - une séquence de référence
# -------       - une référence vers une liste de séquence à comparer
#               => toutes ces séquences doivent provenir d'un même alignement
#                 et donc avoir la même longueur
# Retour :      - le pourcentage de nucléotide différent de la séquence de référence par rapport aux autres
 
 
sub CompareSequencesScore
{
        my $Seq_Ref = $_[0];
        my $Ref_A_SeqCompare = $_[1];
 
        # Test que toutes les séquences de l'alignement ait la même longueur
        $Seq_Ref = uc($Seq_Ref);
        foreach (@{$Ref_A_SeqCompare}){$_=uc($_);}
 
        # Toutes les séquences mises en majuscules
        my @A_Long;
        my %H_Long;
        map{push(@A_Long, length($_))}@{$Ref_A_SeqCompare};
        map{$H_Long{$_}=1;}@A_Long;
        my $NBrDiffTaille = keys(%H_Long);
        if($NBrDiffTaille!=1){print "ERREUR LES SEQUENCES DE L'ALIGNEMENT N'ONT PAS TOUTES LA MEME TAILLE!!!!!\n\n";}
 
        # création du tableau des séquences à comparer
        my @A_Tableau;
        for (my $a=0; $a<@{$Ref_A_SeqCompare}; $a++)
        {
                my @Array = split('', ${$Ref_A_SeqCompare}[$a]);
                for ($b=0; $b<@Array; $b++)
                {
                        $A_Tableau[$b][$a]=$Array[$b];
                }
        }
 
        my @A_Seq_Ref = split('', $Seq_Ref);
        my @PositionsCles;
        my $score = 0;
        my $NbrNucTot = 0;
        map {$NbrNucTot+= length($_);} @{$Ref_A_SeqCompare};
        # print "Nombre de nucléotides comparés : ".$NbrNucTot."\n";
 
        for (my $b =0; $b<@A_Seq_Ref; $b++)
        {
                foreach my $a (@{$A_Tableau[$b]}){if($A_Seq_Ref[$b] ne $a){$score++;}}
        }
        # print "Score absolu : $score\n";
        my $ScoreRel = sprintf( "%.3f" ,$score/$NbrNucTot);
        return($ScoreRel);
}

Si quelqu'un à des conseils afin de l'optimiser, ils sont les très bien venus.

Le script principal appelle un sous programme qui lui même en appelle un autre qui renvoie une réponse, je ne sais pas si cela est une bonne façon de procéder ou non.

Merci pour votre aide.

27/11/2008, 15h18
Jedai
Citation:

Envoyé par Jasmine80

Ce que j'ai mal expliqué c'est que je dois à chaque fois décaler la fenêtre de découpe de 1 et les tronçons se chevauchent. Je pense que le while est dans ce cas-ci plus simple qu'une expression régulière.

Pas tellement, avec ma regexp par exemple c'est l'affaire d'une ligne :
Code:

1 2 3 4 5 6 while( $seq =~ m/((?:[ACTG]\.*){4}[ACTG]|(?:[ACTG]\.*?)+)/g ) { # work with $-[1] and $+[1] # start the next match a character after the beginning of this one : pos($seq) = $-[1] + 1; }
Je suis un peu fatigué donc je n'ai pas le courage de comprendre le reste de ton script, mais j'espère que ceci améliorera la vitesse, travailler caractère par caractère en Perl est rarement une bonne idée.

--
Jedaï
27/11/2008, 15h46
Jasmine80
Citation:

Je suis un peu fatigué donc je n'ai pas le courage de comprendre le reste de ton script, mais j'espère que ceci améliorera la vitesse, travailler caractère par caractère en Perl est rarement une bonne idée.

... oui moi aussi, j'ai la tête comme un seau à réfléchir à ce programme depuis plusieurs heures, ça me paraîtra plus clair quand je m'y remettrai lundi.
Code:

1 2 3 4 5 6 while( $seq =~ m/((?:[ACTG]\.*){4}[ACTG]|(?:[ACTG]\.*?)+)/g ) { # work with $-[1] and $+[1] # start the next match a character after the beginning of this one : pos($seq) = $-[1] + 1; }
A oui, c'est très astucieux, je n'aurais pas penser à une regexp dans un while
je connais le $-[1] mais pas le $+[1] ... je vais essayer de comprendre et d'appliquer cela.

L'ennui est que je veux rechercher dans ma séquence, les pentanucléotides les plus différents par rapport aux autres séquences alignées. Excepté par le décalage d'une fenêtre nucléotide par nucléotide, je ne vois pas par quelle autre procédé y arriver. L'ennui est que je refais ce criblage pour chaque séquence que je dois analyser par rapport aux reste du groupe (11 séquences sur les 36 de l'alignement). Ce qui me fais 11 fois la première boucle et puis 36 fois la seconde ... enfin, ce n'est pas encore énorme pour un programme, ça prends moins d'une minutes, c'est juste que ça m'énerve, j'ai l'impression d'avoir des programmes grossiers et un mauvais style. Ca ira mieux quand je recevrai les 2 livres que j'ai commandés (Higher-Order Perl: Transforming Programs with Programs et PERL BEST PRACTICES).
27/11/2008, 15h47
Jasmine80
Citation:

Je suis un peu fatigué donc je n'ai pas le courage de comprendre le reste de ton script, mais j'espère que ceci améliorera la vitesse, travailler caractère par caractère en Perl est rarement une bonne idée.

... oui moi aussi, j'ai la tête comme un seau à réfléchir à ce programme depuis plusieurs heures, ça me paraîtra plus clair quand je m'y remettrai lundi.
Code:

1 2 3 4 5 6 while( $seq =~ m/((?:[ACTG]\.*){4}[ACTG]|(?:[ACTG]\.*?)+)/g ) { # work with $-[1] and $+[1] # start the next match a character after the beginning of this one : pos($seq) = $-[1] + 1; }
A oui, c'est très astucieux, je n'aurais pas penser à une regexp dans un while
je connais le $-[1] mais pas le $+[1] ... je vais essayer de comprendre et d'appliquer cela.

L'ennui est que je veux rechercher dans ma séquence, les pentanucléotides les plus différents par rapport aux autres séquences alignées. Excepté par le décalage d'une fenêtre nucléotide par nucléotide, je ne vois pas par quel autre procédé y arriver. L'ennui est que je refais ce criblage pour chaque séquence que je dois analyser par rapport aux reste du groupe (11 séquences sur les 36 de l'alignement). Ce qui me fais 11 fois la première boucle et puis 36 fois la seconde ... enfin, ce n'est pas encore énorme pour un programme, ça prends moins d'une minute, c'est juste que ça m'énerve, j'ai l'impression d'avoir des programmes grossiers et un mauvais style. Ca ira mieux quand je recevrai les 2 livres que j'ai commandés (Higher-Order Perl: Transforming Programs with Programs et PERL BEST PRACTICES).

Et voila :

J'ai transformé

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
while ( $index < $h_end{$k} + 1 ) {    # < 112
    if ( !$pattern ) {
        $pattern_start = $index;
    }
    if ( ( length($pattern) < $window ) && ( $h_seq{$k}[$index] !~ /\./ ) ) {
        $pattern .= $h_seq{$k}[$index];
    }
    if ( length($pattern) == $window ) {
        $pattern_end = $index;
        print $pattern. "\t" . $pattern_start . "\t" . $pattern_end . "\n";
        $pattern = '';
 
        # on recule l'index
        $index = $pattern_start;
    }
    $index++;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
while ( $s =~ m/((?:[ACTG]\.*){$window}[ACTG])/g ) {
 
    # start the next match a character after the beginning of this one :
    pos($s) = $-[1] + 1;
 
    # work with $-[1] and $+[1]
    # $-[1] start of match   and $+[1] end of match
    my $pattern   = $1;
    my $pattern_start = $-[1];
    my $pattern_end   = $+[1];
    $pattern =~ s/\.//g;
 
    print "$pattern\t$pattern_start\t$pattern_end\n";
}

Merci beaucoup pour ton aide, c'est bien mieux de cette façon.

On parle de pos() dans perlretut.pod. Par contre, où décrit-on $-[1] et $+[1]? Où aurais-je pu trouver l'information seule? J'ai seulement trouvé ces variables citées dans perlvar. Existe-t'il des tutoriaux pour les expressions régulières avancées? Quels documents de perltoc est-il intéressant de lire? Merci.