This one's a freebie, thanks to Regexp::Common. You can read about using this module to match balanced parens by seeing the docs for Regexp::Common::balanced.

use strict;
use warnings;
use Regexp::Common qw/balanced/;

my $string = '111(22(33)44)55';

$string =~ s/$RE{balanced}{-parens=>'()'}//g;

print $string, "\n";
[download]

You can thank TheDamian and Abigail-II for all the hard work that went into this module.

Note: A regexp solution to matching balanced parens is probably less robust than a proper balanced text parser. For that, you could have a look at Text::Balanced.

If you're unconcerned with their balancing except for the outer ones,

$_ = '111(22(33)44)55';
my $re = qr/
    (.*?)  # minimal grab up to the first...
    \(     # literal left paren
    .*     # greedy skip everything up through...
    \)     # the last literal right paren
    (.*)$  # then grab everything remaining
    /x;
s/$re/$1$2/;
print;
[download]

Update: Typo repaired, thanks, Hofmator.

That's needlessly complicated, simply replace the stuff you don't want with nothing (as Anonymous Monk already said): s/\(.*\)//.

The balancing caveat still applies, of course.

Update: thospel is completely correct, my solution above (and Zaxo's) doesn't work for multiple parenthesis in the same string. To fix this (and actually make it recognise balanced parens):

$_ = "111(22(33)44)55";
1 while s/ \( [^()]* \) //gx;
if (/[()]/) {
  print "unbalanced!!";
} else {
  print;
}
[download]

BTW, I just noticed a small typo in Zaxo's code, it doesn't work as it stands. It should be my $re = qr/.../;.

-- Hofmator

Fails on the perfectly balanced "12(34)56(78)9"

Assuming it's about removing balanced parenthesis, I'd go for:

my $balance;
# Notice declaring $balance beforehand is important, 
# otherwise you pick up the global inside (??{})
$balance=qr/(?:[^()]|\((??{$balance})\))*/;
$string =~ s/\($balance\)//g;
[download]

$_ = '1()()()2923()())))((';
s/[()]+//g;
print;
[download]

Update: Misread the question and you want to remove using balanced parens: use Regexp::Common::balanced

update2 And there is the solution based on the balanced parens re in perlre i.e.

$string='111(22(33))44554'; 
$re = qr/\((?:(?>[^()+])|(??{$re}))*\)/; 
$string =~ s/$re//; 
print $string
[download]

-enlil

my $c=0;
s/ \(      (?{++$c})
 | \)      (?{--$c})
 | ([^()]+)
 /$1 if ($c==0)/gex;
[download]

There is an "if", but it can be replaced by an "x" operator, if you're a stickler. Or you could rewrite the replacement as $c==0 and $1.

Another little variation that doesn't rely on the (?{}) construct:

s{([()]*)([^()]+)}
 {$c += $1=~y/(// - $1=~y/)//;
  $2 x !$c
 }ge;
[download]

If you don't expect to be dealing with particularly long and complex strings, it should be sufficient to loop deleting contents from the inner parens outwards:

  1 while $string =~ s/\([^(]*?\)//gs;
[download]

(Note that the simpler pattern s/\(.*\)// will not do the right thing on a string like "a(b)c(d)e", since it will remove the "c" as well. And you can't fix that by making the .* a minimal .*?, since that fails on nested parens.)

With long strings this approach will start to suffer from the need to repeatedly scan from the beginning of the string for each level of nesting, and then you may be better of with a solution that does a single pass over the string with Regexp::Common::balanced. However the additional complexity of the balanced paren matcher makes it a lot slower, so it won't be a win unless the string is really long or has parens nested quite deeply.

Hugo

s/\(.*\)//;
[download]