How do I get the lowest matched captureno? - perl

Question

How do I get the lowest matched group no in a regular expression?
Suppose there is a regular expression
/(a(b))|(b(1))|(c(4))/...
e.g input string is "b1" , the lowest matched group no 2. ($2)
e.g input string is "c4" , the lowest matched group no 5. ($5)
e.g input string is "ab" , the lowest matched group no 1. ($1)
I have one solution but it is not very efficient.
Thakns all for trying.
The real problem is efficiency. Many have provided similar solutions I found.
The problem is linear time searching for the lowest group. O(N) where n is number of capture groups.
I wondered if there is a faster way. O(1) That was the aim of this question.
I expected the Perl has a hidden feature to get that value. I guess there is not.
Meanwhile I found the solution myself, here it is..
/(a(b)(??{ $first=1;"" }))|(b(1)(??{ $first=2;"" }))|(c(4)(??{ $first=5;"" }))/
The time to find out $first is O(1).
if (#matches = $conv::content =~/$conv::trtree{convertsourceregqr}[$conversionno]/)
{
my $firstno;
my $c = 0;
for my $m (#matches)
{
if (defined $m)
{
$firstno=$c;
last;
}
$c++;
}**strong text****strong text**

Answer 1

This doesn't specifically match your question, but it might address your actual problem (or else a future reader's).
Edit (12/10/12):
One more option, the special construct (?|) will reorganize the numbering in alternations, so that the numbers will be consistent. This won't help identify which group matched, but will assure you that the matches are in $1 and $2. If you need to know which matched, named captures (below) are the way to go.
#!/usr/bin/env perl
use strict;
use warnings;
foreach my $v ('ab', 'b1', 'c4') {
print "Input: $v\n";
next unless $v =~ /(?|(a(b))|(b(1))|(c(4)))/;
print "$1 => $2\n";
}
Original
Perhaps you want to use named captures to ease the burden of understanding what matched. The named capture results are placed in the %+ hash and are thus much easier to introspect.
#!/usr/bin/env perl
use strict;
use warnings;
foreach my $v ('ab', 'b1', 'c4') {
print "Input: $v\n";
next unless $v =~ /(?<a>a(?<ab>b))|(?<b>b(?<b1>1))|(?<c>c(?<c4>4))/;
foreach my $key (sort keys %+) {
next unless defined $+{$key};
print "\t$key => $+{$key}\n";
}
}
prints
Input: ab
a => ab
ab => b
Input: b1
b => b1
b1 => 1
Input: c4
c => c4
c4 => 4
EDIT
In fact, for alternations like this, perhaps you want to simply use recurring names!
#!/usr/bin/env perl
use strict;
use warnings;
foreach my $v ('ab', 'b1', 'c4') {
print "Input: $v\n";
next unless $v =~ /(?<outer>a(?<inner>b))|(?<outer>b(?<inner>1))|(?<outer>c(?<inner>4))/;
print "\touter => $+{outer}\n";
print "\tinner => $+{inner}\n";
}
prints
Input: ab
outer => ab
inner => b
Input: b1
outer => b1
inner => 1
Input: c4
outer => c4
inner => 4

Answer 2

Store the matches in an array, and find the index of the first defined value:
my $str = 'c4';
my #matches = ( $str =~ m/(a(b))|(b(1))|(c(4))/ );
for my $i ( 0..$#matches ) {
if ( defined $matches[$i] ) {
printf "First matching group: %d\n", $i+1;
last;
}
}
# output: 5
Note that this will never output 2, 4 or 6 since groups 1, 3 or 5 must match for one of them to match.
If you only want the content of the first matching group:
use List::Util 'first';
my $str = 'c4';
print first { defined } $str =~ m/(a(b))|(b(1))|(c(4))/;

Answer 3

The special variables #- and #+ hold the starting and ending positions of successful matches. The practical application to your question is that if $<n> holds some value (for $<n> in $1, $2, etc.), then $+[<n>] will be larger than $-[<n>].
for ('b1', 'c4', 'ab') {
/(a(b))|(b(1))|(c(4))/;
my #i = grep { $+[$_] > $-[$_] } 1..$#+;
# #i contains list of successful matches,
# i.e., if #i == (3,4), then $3 and $4 contain values
if (#i > 0) {
print "Earliest match for '$_' is: \$$i[0]\n";
} else {
print "No match for '$_'\n";
}
}

Answer 4

First off, using parentheses that way is confusing. The simplest solution to this particular problem is to just use one:
/(ab|b1|c4)/
Since the other parentheses do not serve a purpose in this particular case, this will work.
However, there may be times when grouping is needed, in which case you can use non-capturing parentheses and just use one to capture, (?: ... ). In your case it would look like this:
/((?:a(?:b))|(?:b(?:1))|(?:c(?:4)))/

Answer 5

The group numbering in a regular expression is the number of parens.
1 2 3 4 5 6
/(a(b))|(b(1))|(c(4))/
A quick script to demonstrate this:
#!/usr/bin/perl
foreach my $v ('ab', 'b1', 'c4') {
$v =~ /(a(b))|(b(1))|(c(4))/;
if(defined $1) { print "One!\n"; }
if(defined $3) { print "Three!\n"; }
if(defined $5) { print "Five!\n"; }
print << "--EOB--";
$v
1 $1
2 $2
3 $3
4 $4
5 $5
6 $6
--EOB--
}
Which produces the output:
One!
ab
1 ab
2 b
3
4
5
6
Three!
b1
1
2
3 b1
4 1
5
6
Five!
c4
1
2
3
4
5 c4
6 4
At this point, one should be able to easily modify the code to do whatever for whichever group is matched.