Getting indices of matching parentheses - arrays

Question

Hi I am trying to print indices of the following pattern of brackets:
((((((...)))(((...))))))
as follows:
0 23
1 22
2 21
3 11
4 10
5 9
12 20
13 19
14 18
I tried to achieve this using this perl code as given below:
#!/usr/bin/perl
use strict;
use warnings;
my $string = '((((((...)))(((...))))))';
my #myarray = split('', $string);
my #stack;
my #stack1;
while (my ($index, $element) = each(#myarray))
{
if ($element eq '(')
{
push(#stack, $index);
}
if ($element eq ')')
{
push(#stack1, $index);
}
}
print "$stack[$_]-$stack1[$_]\n" for (0 .. $#stack);
But the above code is giving me following output which is not the required output:
0-9
1-10
2-11
3-18
4-19
5-20
12-21
13-22
14-23
Is there any way I can achieve this?

Answer 1

Push to the stack on the left hand side parenthesis, pop on the right hand side.
#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };
my $string = '((((((...)))(((...))))))';
my #output;
my #stack;
my $pos = 0;
for my $char (split //, $string) {
if ($char eq '(') {
push #stack, $pos;
} elsif ($char eq ')') {
push #output, [ pop #stack, $pos ];
}
++$pos;
}
say "#$_" for sort { $a->[0] <=> $b->[0] } #output;

Answer 2

Fun question! The accepted answer is fine, but here's another way to do it, because it's always educational to see another solution.
#!/usr/bin/perl
use strict;
use warnings;
my $string = '((((((...)))(((...))))))';
my (#out, #match);
while ($string =~ m/([()])/g) {
my $p = pos($string) - 1;
if ($1 eq '(') {
push #out, [$p];
push #match, $#out;
}
else {
die "mismatched paren at char $p\n"
unless #match;
$out[pop #match][1] = $p;
}
}
for (#out) { print "#$_\n" }
exit(0);
Output is exactly as per your desired output. Dies on mismatched parentheses (which choroba's code could also do with an appropriate test in the elsif block). Unmatched parentheses result in lines with no second number, and they will also be residual in #match after the while loop.
I've opted to use Perl's pattern matching a little instead of breaking the string into individual characters and iterating over them all. Instead, I match on each open or close parenthesis in turn, using the "g" modifier. Thus, the loop only iterates over characters of interest. The pos() function on $string returns the point after the last match, so I need to subtract one to get zero-based output.
The other key difference is that I accumulate in #out, and track the corresponding close by noting the last index of #out, pushing it on #match. I then pop off #match as I find closing parentheses, and add the second element to the sub-array in #out at that position. This eliminates the need for sorting the final result, as #out is already in order of opening parentheses.