Anchor to the right with the $ metacharacter. By anchoring to the right, and using a negative character class, you minimize the amount of work needed to find the last occurrence even if it's not the last thing in the string.

Update:
And the following should yield better performance by using a positive lookahead assertion (eliminating the need for capturing parens), and still anchoring to the right.

s/b(?=[^b]*$)/x/
[download]

I was curious about whether the anchoring really reduced the work, so I ran a benchmark of the various suggested methods. I found some of the results surprising -- like the fact that xeger was not a lot slower than the anchored match. And anchoring the 2-step solution slowed it down.

@strings = ( 'There was a bright man from Nantucket'
        ,'Abba babbles about bubble blowers'
        ,'Enough with the excess bs already'
        ,'None at all in this one');
my @c;

use Benchmark 'cmpthese';

%methods = (
  'anch'  => sub { s/b(?=[^b]*$)/x/ for @c=@strings},
  'xeger' => sub { $_ = reverse, s/b/x/, $_ = reverse for @c=@strings 
+},
  'plain' => sub { s/(.*)b/$1x/ for @c=@strings},
  '2part' => sub { /.*(?=b)/g and s/\Gb/x/ for @c=@strings },
  '2part-A' => sub { /b(?=[^b]*$)/g and s/\Gb/x/ for @c=@strings },
  'substr' => sub { substr($_, rindex($_, 'b'), 1) = 'x' for @c=@strin
+gs},
  'neglook' => sub { s/b(?!.*b)/x/ for @c=@strings }
);

cmpthese(-3, \%methods );
[download]

Results:

          Rate   plain 2part-A   2part neglook   xeger    anch  substr
plain   3208/s      --    -31%    -35%    -44%    -47%    -51%    -64%
2part-A 4630/s     44%      --     -6%    -20%    -23%    -29%    -48%
2part   4948/s     54%      7%      --    -14%    -18%    -24%    -45%
neglook 5767/s     80%     25%     17%      --     -4%    -12%    -36%
xeger   6029/s     88%     30%     22%      5%      --     -8%    -33%
anch    6536/s    104%     41%     32%     13%      8%      --    -27%
substr  8985/s    180%     94%     82%     56%     49%     37%      --
[download]

---

Caution: Contents may have been coded under pressure.

$string =~ s/(.*)b/\1x/;
[download]

I don't know if that would be faster or slower than reversing it first.

reverse() your string, then run the regex as if you want the first match, then reverse() again

$string = reverse $string;
$string =~ s/b/x/;
$string = reverse $string;
[download]

$string =~ s/(.*)b/$1x/;
[download]

$string =~ m/.*(?=b)/g and $string =~ s/\Gb/x/;
[download]

substr($string, rindex($string, 'b'), 1) = 'x';
[download]

my $string = "abababa";
$string = reverse $string;
$string =~ s/b/x/;
$string = reverse $string;
print $string,$/;
[download]

my $string = "abababa";
my $ri  = rindex( $string, 'b' );
substr( $string, $ri, 1) =  'x';
print $string,$/;
[download]

update: and here is my benchmark. sexeger comes out on top in two different versions of perl

UPDATE: And of course, I hadn't taken my own advice. Here is the updated benchmark:

neganch => sub {
    my $string = "abababa";
    $string =~ s/(b)(?!.*b)$/x/;
    return;
}
[download]

That neganch test will fail if 'b' isn't the last character in the string, which it isn't.




Dave

I wonder if it might be even faster without _capturing_ parentheses?

Changing 
    $string =~ s/(b)(?!.*b)$/x/;
to this 
    $string =~ s/b(?!.*b)$/x/;
[download]

Both of those regexps fail when 'b' isn't the last character in the string, because the negative lookahead assertion is zero-width, and yet you're anchoring to the RHS of the string.

Look at the following code and you'll see:

use strict;
use warnings;

my $orig_string = 'abababa';

my @tests = ( qr/(b)(?!.*b)$/ , 
              qr/b(?!.*b)$/   ,
              qr/b(?!.*b.*$)/ ,
              qr/b(?=[^b]*$)/   );

foreach my $test_re ( @tests ) {
    my $scratch = $orig_string;
    print "$test_re\tdid",
          $scratch =~s/$test_re/x/ ? '    ' : "n't " ,
          "match '$orig_string', yielding '$scratch'\n";
}
[download]

The problem with your regexps is that they require 'b' to be the last thing in the string. This is because the lookahead assertion, positive or negative, is zero-width. If you move the anchor inside the assertion, it would improve, but it becomes kludgy, and IMO, not as clearly defined if you insist on using negative lookahead (see the third test regexp). In the fourth regexp, you can see the use of a positive lookahead and a negated character class, which, to me, is clearer, harder to break, etc.




Dave

When having a look at the benchmarks above, I notice that perl 5.6 is faster than perl 5.8 for that kind of operation. I remember having heard something about it by the way.

Is it more general ? Is perl 5.6 faster than perl 5.8 ? Do some of you hesitate to use perl 5.8 in real life when high performance is needed ?

Just curious.



--
zejames

$_ = reverse $string;
s/b/x/;
$string = reverse $_;
[download]

my $string = "abababa";
my $from = 'b'; my $to = 'x';
print "was [$string]\n";
substr($string, rindex($string, $from), length($from)) = $to;
print "now [$string]\n";
[download]