You're pretty close. I think the problem is that you're being 'greedy' in the regex. I've added a ? after the .* to make it non-greedy. The ?: tells the inner parens to not capture. The outer parens will do this for us.

This example captures everything including the delimiters:

m/(ATG.*?(?:TAG|TAA|TGA))/g
[download]

This one will capture only inside the delimiters:

m/ATG(.*?)(?:TAG|TAA|TGA)/g
[download]

this may be a stupid question, but what is the function of the :

As I said, the ?: makes it so the group within the () is not captured. Observe...

Without ?::

perl -E '"123" =~ /(2|3)/; say $1'
2
[download]

With ?::

perl -E '"123" =~ /(?:2|3)/; say $1'
[download]

Note how using the ?: doesn't put anything into the special numbered $1 variable. See perlretut's Non-Capturing Groupings

GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC
[download]

If I run stevieb's solution, I get

GTTTCTCCCATCTCTCCATCGGCA
ATC
[download]

my $seq = 'ATGATGTGATGA';
[download]

GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC
[download]

which, while it is not correct, is not unspecified.

Well, I understand your point, but is it really incorrect? After all this sequence is preceded by ATG and followed by TAA, so it is in a certain way correct. But it is clearly not the smallest sequence matching this criteria in the input string.

This to say that, while:

  DB<2> print "$1\n"  while ($seq =~ m/(ATG(?:.*?)(TAG|TAA|TGA))/g);
ATGGTTTCTCCCATCTCTCCATCGGCATAA
ATGATCTAA
[download]

seems to probably give a better answer, it is not completely clear whether the

(ATG)GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC(TAA)
[download]

is a valid sequence or not.

Also, I note a reference to codons, which implies that your tests should be considering a stride of 3 rather than an arbitrary position.

This is an excellent point. For the benefit of the OP, here is one way to ensure that only codon-sequences are captured:

#! perl
use strict;
use warnings;

my $seq = 'AATGGTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATCTAACGAA';

# Adapted from the regex by stevieb
my $re =
qr{
    (                           # capture each sequence:
        ATG                     # - which begins with the codon ATG
        (?: [ACGT]{3} )*?       # - followed by the smallest number of
+ codons
        (?: TAG | TAA | TGA )   # - and ending with the codon TAG, TAA
+, or TGA
    )
}x;

print "$1\n" while $seq =~ /$re/g;
[download]

(This assumes that only minimal sequences are wanted — an assumption which should be clarified, as Laurent_R has pointed out, above.)

Hope that helps,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

I would have organized the code slightly differently, factoring each of the pattern elements into a separate  qr// regex object and combining them together (inside a capture group) in the final  m// match:

c:\@Work\Perl\monks>perl -wMstrict -le
"my $codon = qr{ [ACGT]{3}       }xms;
 my $start = qr{ ATG             }xms;
 my $end   = qr{ TAG | TAA | TGA }xms;
 ;;
 my $seq = 'AATGGTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATCTAACGAA';
 ;;
 print qq{'$1'} while $seq =~ m{ ($start $codon*? $end) }xmsg;
"
'ATGGTTTCTCCCATCTCTCCATCGGCATAA'
'ATGATCTAA'
[download]

Separate  qr// definitions ease maintenance and, if variable names be wisely chosen, are self-commenting. If possible, I only use capture groups in the final  m// match due to the confusion that trying to count nested capture groups can produce.

---

Give a man a fish:  <%-{-{-{-<

Do you think this might be homework?

Compare: Print A Sequence with Start codon and different Stop Codon (another author with an almost identical problem -- or a SOPW posting under two handles?)

OP: when you post homework, mark it as such! You won't really learn much if some of our (less-than-discreet) Monks simply hands you an answer.