my $line ='atgcatccctttaat';
my @trips = unpack('a3X2' x (length($line)-2), $line);
print join "\n", @trips;
[download]

atg
tgc
gca
cat
atc
tcc
ccc
cct
ctt
ttt
tta
taa
aat
[download]

This uses the same technique to extract three frame sequences into separate arrays:

my $line ='atgcatccctttaat';
my @trips;
my $frame;
for (unpack('a3X2' x (length($line)-2), $line)) {
  push @{$trips[$frame++]}, $_;
  $frame %= 3;
}
use Data::Dumper;
print Dumper \@trips;
[download]

output:

$VAR1 = [
          [
            'atg',
            'cat',
            'ccc',
            'ttt',
            'aat'
          ],
          [
            'tgc',
            'atc',
            'cct',
            'tta'
          ],
          [
            'gca',
            'tcc',
            'ctt',
            'taa'
          ]
        ];
[download]

---

Caution: Contents may have been coded under pressure.

my $line      = 'atccatccctttaat';
my @triplets  = unpack( "a3" x int( length($line) / 3 ), $line );
my @triplets2 = unpack( 'x' . "a3" x int( ( length($line) - 1 ) / 3 ),
+ $line );
my @triplets3 = unpack( 'xx' . "a3" x int( ( length($line) - 2 ) / 3 )
+, $line );
[download]

A variation that doesn't use unpack:

@triplets0 = $line            =~ /(...)/g;
@triplets1 = substr($line, 1) =~ /(...)/g;
@triplets2 = substr($line, 2) =~ /(...)/g;
[download]

or even

push(@triplets, [ substr($line, $_) =~ /(...)/g ]) for 0..2;
[download]

Finally, a solution for arbitrary group sizes:

$group_size = 3;
push(@groups, [ substr($line, $_-1) =~ /(.{$group_size})/g ])
   for 1..$group_size;
[download]

If you don't care to group them, remove the square brackets.

Test:

$line = 'atccatccctttaat';

push(@triplets, [ substr($line, $_) =~ /(.{$_})/g ]) for 0..2;

require Data::Dumper;
print(Data::Dumper::Dumper(\@triplets));

__END__
output
======
$VAR1 = [
          [
            'atc',
            'cat',
            'ccc',
            'ttt',
            'aat'
          ],
          [
            'tcc',
            'atc',
            'cct',
            'tta'
          ],
          [
            'cca',
            'tcc',
            'ctt',
            'taa'
          ]
        ];
[download]

@triplets = unpack ('(a3)*', $line);
[download]

# throw away trailing crud
pop @triplets if $triplets[-1] !~ /.../;
[download]

my $line      = 'atccatccctttaat';
my @triplets  = unpack( '(a3)*', $line);
my @triplets2 = unpack( 'x(a3)*', $line);
my @triplets3 = unpack( 'xx(a3)*', $line);
# throw away trailing crud
pop @triplets  if $triplets[-1]  !~ /.../;
pop @triplets2 if $triplets2[-1] !~ /.../;
pop @triplets3 if $triplets3[-1] !~ /.../;
[download]

my @triplets = unpack("x${skip}(a3)*", $line);
pop @triplets if $triplets[-1]  !~ /.../;
[download]

--
@/=map{[/./g]}qw/.h_nJ Xapou cets krht ele_ r_ra/;
map{y/X_/\n /;print}map{pop@$_}@/for@/
[download]

Since you had repeating code, my preference is to put it in a loop. I'd also use length instead of /.../, it's computationally less expensive which I assume is important if you're parsing lots of sequences.

my $line = 'atccatccctttaat';
my %triplets;
for (0 .. 2) {
    @{$triplets{$_}} = unpack(('x' x $_).'(a3)*',$line);
    pop @{$triplets{$_}} if length($triplets{$_}->[-1]) != 3;
    print "Offset $_: @{$triplets{$_}}\n";
}
[download]

Yeah, I thought about a loop, but I was afraid it would obscure what the code is doing - I'd certainly switch to a loop if doing more than 3 or four repetitions, and if I were doing more than two statements per offset, but at less than that the loop syntax just clutters things up. (I realize that this is a matter of personal taste, and I might change my answer depending on my mood).

Good point about using length - again, I think my way is clearer, but I'm not sure whether that's the use of length or the ->. (which you could drop)

By the way, I would have written the first line of your loop as:

    $triplets{$_} = [unpack("x$_ (a3)*", $line)];
[download]

But that's only because I don't like using @{$unusedvarref} to auto-vivify.

--
@/=map{[/./g]}qw/.h_nJ Xapou cets krht ele_ r_ra/;
map{y/X_/\n /;print}map{pop@$_}@/for@/
[download]

1. I thank the monks for the wisdom and enlightenment. 2. For those in doubt, its not the same question: u'd know if u looked closely. 3. I am indeed Rashmun. (I am using a different computer, and was in a hurry, so didn't login.)

use strict ;
use warnings ;
##updated according to suggestions
my $string="atccatccctttaat" ;
my $left_out=2 ;
my $template = "x$left_out" ;
$template .= "a3" x ((length($string)-$left_out)/3) ;
my @array=unpack($template, $string) ;
local $"="\n" ;
print "@array" ;
[download]

Why these two lines:

my $template = "a" x $left_out ;


shift @array while($left_out--);
[download]

When you could easily use this one line instead: (and earlier responses had used the "x" template character, and you'd clearly read those earlier responses)

my $template = "x$left_out" ;
[download]

This also has the advantage that you don't trash $left_out, in case you need it later. Of course, if you're using a perl 5.8 or higher, I'd really recommend my solution instead.

--
@/=map{[/./g]}qw/.h_nJ Xapou cets krht ele_ r_ra/;
map{y/X_/\n /;print}map{pop@$_}@/for@/
[download]

You are right on about the use of 'x'. btw, I didnt read the earlier comments as they were not there when I answered.

Manav