When the flip-flop operator in scalar 'flips' (when the left hand side is true), it starts at 1 and counts up until it 'flops' (when the right hand side is true). So, skip to the next element when the return value equals 1.

Also, when the flip-flop operator 'flops', it appends 'E0' to the return value. For example, if it finds five matches in a row, it will return (1, 2, 3, 4, '5E0'). So, you should also skip to the next element when the return value contains an E.

Here's how this might be coded:

foreach (@data){
  next unless $check = /start/ .. /stop/;

  next if $check == '1' or $check =~ /E/;

  # do stuff
}
[download]

foreach (grep { not (/start/../stop/) =~ /^1?$|E/ } @data) {
 ..
}
[download]

-- Randal L. Schwartz, Perl hacker

Cool... And how about this one?

foreach (sub {pop;shift;@_}->(grep /start/../stop/, @data) ) {
    ...
}
[download]

Sorry, just kidding :-)

UPDATE: taking Abigail and John M. Dlugosz's remarks into account, the original post wanted to stop after the first occurence of 'stop'. I guess we should then be using ?? instead of // to prevent matching more than once.

foreach (sub {pop;shift;@_}->(grep ?start?..?stop?, @data) ) {
    ...
}
[download]

--bwana147

That code doesn't do the same.

    #!/opt/perl/bin/perl -wl

    use strict;

    my @data = qw /foo start bar baz stop qux
                   start quux stop fuzzle/;

    foreach (grep /start/ .. /stop/, @data) {
        next if /start/ || /stop/;
        print
    }

    print "----";

    foreach (sub {pop; shift; @_} ->
                 (grep /start/ .. /stop/, @data)) {
        print;
    }

    __END__
    bar
    baz
    quux
    ----
    bar
    baz
    stop
    start
    quux
[download]

You are losing the boundaries of the flip-flop operator, and use the boundaries of grep. But those boundary events are not necessarely the same.

-- Abigail

I love it! Using the sub{}->() idiom you can modify a list in-place without using a temporary. Your code does the same as:

my @temp= grep /start/../stop/, @data;
pop @temp;
shift @temp;
foreach (@temp) { ... }
[download]

right?

—John

.. not being able to do, reduced to nitpicking.
Sorry your answer was so beautiful I studied it but..
perl -e '@data=qw(1 2 3 4 5 6 7 8 9 10 11); 
 foreach (grep {not (/1/../3/) =~ /^1?$|E/ } @data) { 
   print "o> $_\n";
 }
'
[download]

prints
o> 2
o> 11

I hope I'm wrong..

Thats looks like the correct output to me. What were you expecting to see?

Update: Ok. Getting downvotes, so perhaps I'll be a little clearer.

Your array contains the numbers from 1 to 11. Your flip-flop condition is /1/ .. /3/. These are regular expressions and match if the values they are matched against contain this string in any position. Obviously it switches on when it gets to 1 and switches off when it gets to three. It then switches on again when it gets to 10. It would have switched off again had your array gone up to 13.

The problem is therefore not with merlyn's algorithm, but with your implementation of it :)

--
<http://www.dave.org.uk>

Perl Training in the UK <http://www.iterative-software.com>

mattr is right, merlyn's solution does not work.

But this modification does:

foreach ( grep { (/start/../stop/) !~ /^1?$|E/} @arry ){
#...
}
[download]

I looked a bit further, and what is coming out of the (/start/../stop/) is the sequence number...until you put the not in front of it. Then it just yields blank or 1!

Any ideas why? Is it being evaluated in list context? Why does the not have any influence on the context?

-- iakobski

Uh, it is working. The start match is /1/, which also triggers on "10". So the output is:

1 start - don't show
2 in - show
3 end - don't show
4 out
5 out
6 out
7 out
8 out
9 out
10 start - don't show
11 in - show
[download]

It's exactly right. My solution works fine, no need to modify it.

-- Randal L. Schwartz, Perl hacker

not puts things in a boolean context, either true or false. False is 0 and true is anything else (in numerical context at least), by convention we use 0 and 1 as false and true when we aren't concerned about data, just truthfulnes.

The 15 year old, freshman programmer,
Stephen Rawls

That's a good observation on what not does.

But, the binding operator =~ has a higher order of precidence, so the not applies to the result of the match, not to the left hand side being matched.

—John

To use the sequence counter, I guess you'd use something like this:

foreach ( @data ) {
    my $seq = /start/ .. /stop/;
    next unless $seq > 1 && substr($seq, -2) ne 'E0';
    # do_stuff
}
[download]

Not tested, but you get the idea...

--bwana147

#!/usr/bin/perl -w
use strict;
my @data=(<DATA>);

foreach (grep { my $sequence_number=/START/ .. /STOP/; $sequence_numbe
+r ne 1 and $sequence_number !~ /E0/ and $sequence_number;} @data ) {
  chomp;
  print "$_ Between START and STOP\n";
}

__END__
START
Sausage
Mash
Mushy Peas
STOP
Monkey Nuts
START
Bananas
Custard
STOP
Tarzan
[download]

I notice you already got answers on how to tell when it flips or filter out the first/last without retesting, but I wanted to make a note on this specific point of repreating the RE.

my $start= qr/start/;  # note the regex's once
my $stop= qr/stop/;
foreach (grep /$start/ .. /$stop/, @data) {
   next if /$start/;
   last if /$stop/;
   # ....
[download]

# variation with grep
@a=qw(abc def ghi jkl mno pqr stu vwxyz); 
@g = grep /i/../u/, @a; 
for (1..$#g-1) { 
  print "$g[$_]\n"; 
}

# with map
@a=qw(abc def ghi jkl mno pqr stu vwxyz); 
$flag=-1; 
sub go {
  print "$_\n" if ($flag>0); 
  if ($_ =~ /i|u/) {
    $flag = $flag * -1
  }
} 
@g = map{ &go($_) => $_ } @a;
[download]