use strict;
use warnings;
use Data::Dumper;

my @genes;
my $screen = "ATCGATCGXXXXXATCGATXXXACTGCTACGGTACXXXAATTATXGCGCGXXT";

my @genes;
while ( $screen =~ /([^X]+)/g ) {
  my $start = pos($screen) - length($1);
  push @genes, [$start, $1];
}

print Dumper \@genes;
[download]

-enlil

That's written simpler as:

while ($screen =~ /([^X]+)/g) {
   push @genes, [ $-[0], $1 ];
}
[download]

duff

use strict;

my @genes;
while ($screen =~ /([^X]+)/g)
{
    push @genes, $1;
    print "$1 occurred at ", pos($screen) - length $1, $/;
}
[download]

The trick is that pos() returns the position that the matcher is currently at, after the current match occurred. So, if you want to find out where the match started, you subtract the length of the match from the place the match ended.

#! /usr/bin/perl -w
use strict;

my (@genes, @positions);
my $screen = "ATCGATCGXXXXXATCGATXXXACTGCTACGGTACXXXAATTATXGCGCGXXT";

if ($screen =~ /X/) {
   my @parts = split /(X+)/, $screen;
   my $pos = 0;
   foreach my $part (@parts) {
      if ($part !~ /X/) {
         push @genes, $part;
         push @positions, $pos;
         print "Gene $part is at position $pos\n";
      }
      $pos += length $part;
   }
   my $genecounter = @genes;
   print "Number of components  = $genecounter\n\n";
}
[download]

One way to do this is to capture the junk along with the substrings

This is a fine use for the special treatment of capturing parentheses in the first (regex) argument to split:

  my @chunks;
  my @start_pos;
  my $pos = 0;
  foreach my $chunk ( split /(X+)/, $string )
  {
      unless ( $chunk =~ /^X/ )
      {
          push @start_pos, $pos;
          push @chunks, $chunk;
      }
      $pos += length $chunk;
  }
[download]

use strict;

my @genes;
my $screen = "ATCGATCGXXXXXATCGATXXXACTGCTACGGTACXXXAATTATXGCGCGXXT";

while ($screen =~ /(^|(?<=X))([^X]+)/g) {
    print "Gene $2 found at position ", length($`), "\n";
}
[download]

Update: added $2 gene string.

• 1) at the start of the array, and therefore a starting point, or
• 2) just after an X character, and therefore a starting point.

#! /usr/bin/perl -w
use strict;

my $screen = "ATCGATCGXXXXXATCGATXXXACTGCTACGGTACXXXAATTATXGCGCGXXT";
my @chars = split //, $screen;
my @starts;

foreach ( 0 .. scalar @chars - 1 ) {
    push @starts, $_
        if $chars[$_] ne 'X' &&  ( 0 == $_ || $chars[$_-1] eq 'X' );
}

print "$screen\n@starts\n";
[download]

Try checking out the bioperl modules, at http://search.cpan.org/dist/bioperl/, also. I'm not familiar with them, but they have a prepackaged routine for this.

You might find Bio::Restriction::Analysis useful.

Essentially what I wish to obtain is the starting position for each member of the @genes array within the original $screen variable.

I gave a solution using split in an earlier reply. I think I would prefer to solve this with a simple iterative regex, taking advantage of the @- array, which tracks the starting index of each sub-match:

  my @genes;
  my @gene_pos;
  while ( $screen =~ m/([^X]+)/g )
  {
      push @genes, $1;
      push @gene_pos, $-[1];
  }
[download]

Update: Ignore this! It is much slower.

This might work out a little faster if performance is a issue--which it usually is with genome related stuff.

#! perl -slw
use strict;

my $re = '([^X]+)X*' . '(?:([^X]+)X*)?' x 100;
$re = qr[$re];

my $screen = "ATCGATCGXXXXXATCGATXXXACTGCTACGGTACXXXAATTATXGCGCGXXT";

$screen =~ $re;

print for @-[ 1 .. $#- ];

__END__
P:\test>test2
0
13
22
38
45
52
[download]

It is much slower.

Surely it must be so; look at the size of your RE! :-)

duff

Agreed. Though I had thought that by grabbing the matches using a standard m[([^X]+)]g first, I would know how big to make the big re. Then a second pass would populate @-.

As it turn out,

push @posns, pos($screen) - length $1  while $screen =~ /([^X]+)/g;
[download]

is substantially faster than

push @posns, $-[ 0 ] while $screen =~ m[([^X]+)]g;
[download]

which surprised me. I'm not sure why that would be?

My best guess is that @- uses tie-style magic, and isn't populated unless it is accessed rather than when the regex runs? Perhaps the captures are made in the form of LVALUE refs and @- and @+ are derived from those if and when they are called for?

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail