Re: Regular expressions

[kennethk]

First, I do not replicate your stated challenge. You say "that the $1 is unspecified", but when I get your posted code, I get:

GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC

which, while it is not correct, is not unspecified. Am I misunderstanding your statement, or are you seeing something different from your code? Make sure that your examples match up to the issues you are encountering.

If I run stevieb's solution, I get

GTTTCTCCCATCTCTCCATCGGCA
ATC

which would seem to meet your spec. The bigger question is what happens for nested cases? What is your expected output for

my $seq = 'ATGATGTGATGA';

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

[Laurent_R]

GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC

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

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

(ATG)GTTTCTCCCATCTCTCCATCGGCATAAAAATACAGAATGATC(TAA)

is a valid sequence or not.

[Athanasius]

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;

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

Hope that helps,

[AnomalousMonk]

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'

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.