This method should be a bit more efficient that either substr in a loop or using the regex engine.

#! perl -slw
use strict;

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';

my $n = int( ( length( $dna ) - ( 10 - 3 ) ) / 3 );

print for unpack "(A10 X7)$n", $dna;

__END__
C:\Perl\test>test
accatgagct
atgagctgta
agctgtacgt
tgtacgtagc
acgtagcatc
tagcatctga
catctgagcg
ctgagcgcgc
agcgcgcatg
gcgcatgact
catgactgtg
gactgtgact
tgtgactgac
gactgacgta
tgacgtaggc
cgtaggcagc
[download]

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';

my $increment = 3;
my @windows;
for ( my $loc=0; $loc <= (length($dna)-10); $loc+=$increment ){
    push @windows, substr($dna, $loc, 10);
}

print "$_\n" for @windows;
[download]

If you have multiple $dna sequences you'll probably want an outer loop to iterate over an array holding them. Otherwise, this code ought to do what you're looking for.

It's one of the few instances where I would actually use a C-style 'for' loop.

You could also do it with a regexp.

Update: Replaced (length($dna)-$increment) with (length($dna)-10) per duff's comment. Good catch!

Surely that should be

for ( my $loc = 0; $loc <= length($dna) - 10; $loc += $increment ) {
[download]

Otherwise his last few strings won't be 10 characters long. Even though I have done this exact thing (sliding window with overlaps) in the past using a C-style for loop, I think I'd probably write it like this these days:

my $end = int((length($dna) - 10)/3);
for my $i (0..$end) {
   push @windows, substr($dna,$i*3,10);
}
[download]

or more likely

my @windows = map { substr($dna,$_*3,10) } 0..int((length($dna)-10)/3)
+;
[download]

duff

You could also do it with a regexp.

Which would look something like:

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';
my $increment = 3;
my $substr = 10;
my @windows = $dna=~/(?=(.{$substr})).{$increment}/gs;
print "$_\n" for @windows;
[download]

## capture 10 chars (with advancing), then move back 7:

while ( $dna =~ /(.{10})/g ) {
    print "current window = $1\n";
    pos $dna -= 7;
}
[download]

## capture next 10 chars without advancing, then advance by 3:

while ( $dna =~ /(?= (.{10}) ) .{3}/gx ) {
    print "current window: $1\n";
}
[download]

use strict;
use Bio::Seq;

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';
my $seq = Bio::Seq->new( -seq => $dna);
my $end =  $seq->length -10;

my @windows;
for(my $i= 1; $i < $end; $i+=2) #increase by one codon each time.
  {
    push @windows, $seq->subseq($i, $i+9);
  }
print join "\n", @windows;
[download]

Also, the third argument to substr is the number of characters you want; using 0 will always return an empty string. And in your loop, you're starting at 10 and stopping when the position is greater than the number of elements in @dna, but there's only one element in that list, so the loop never executes.

I think something closer to what you mean is:

use constant MOVEMENT => 3;
use constant WINDOWSIZE => 10;

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';
my @windows=();
for (my $pos = 0; $pos <= (length($dna) - WINDOWSIZE); $pos += MOVEMEN
+T)  {
     push(@windows,substr($dna,$pos,WINDOWSIZE));
}
                                                                      
print "@windows\n";
[download]

Here's a little different way to do it.

With PerlIO, Perl 5.8+,

my $dna = q(accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca);
my $skip = 10;
{
    local ($/, $\) = (\10, "\n");
    open my $chain, '<', \substr($dna, $skip) or die $!;
    print while <$chain>;
    close $chain or die $!;
}
[download]

Update: Oops, I also misread. Not a solution to what was asked.

Just another way to do it:

my $dna = 'accatgagctgtacgtagcatctgagcgcgcatgactgtgactgacgtaggcagca';
my @windows = unpack 'A3' x length $dna, $dna;
print "@windows";
[download]

Update:Sorry, ignore the above, I read the question too quickly.

dave

That doesn't actualy produce the output the OP was asking for. It produces groups of 3 which is a nice trick.


___________
Eric Hodges