Re: Yet Another Rosetta Code Problem (Perl, Ruby, Python, Haskell, ...)

[Limbic~Region]

eyepopslikeamosquito,
BTW, does anyone know of a CPAN module that can solve this problem directly?

It is hard to imagine why this specific problem would have its own solution.

The problem can be generalized into something worth solving. Assume we want to divide a list on break points. I will present an iterator solution.

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

sub gen_divider {
    my %opt = @_;
    my $is_break = $opt{detect_break};

    my ($curr, @list);

    return sub {
        for (@_) {
            if (! defined $curr || $is_break->($_, $curr)) {
                push @list, [$_];
                $curr = $_;
            }
            else {
                push @{$list[-1]}, $_;
            }
        }
        return \@list;
    };
}

my $break_point = sub {
    my ($item_to_test, $prev_break_point) = @_;
    return $item_to_test ne $prev_break_point;
};

my $divide = gen_divider(detect_break => $break_point);

for (split //, "ZBBBCZZ") {
    $divide->($_);
}

my $list = $divide->();
print Dumper($list);

This leaves a lot to be desired but the idea jumped into my head and so I thought I would share.

[Anonymous Monk]

Ruby solution

x = []
"ZBBBCZZ".scan(/((.)\2*)/){ x << [$~[0]]; x.flatten!}

.flatten is needed else you get

# => [["Z"], ["BBB"], ["C"], ["ZZ"]]

as result.

But this is quite an ugly solution anyway... in fact, perl looks almost as readable in this example ;)

not sure how to solve this any easier though, hmm i wonder if .each could be used and then another grouping way... I really dont like the regex magic of the ruby solution, cant you guys think of another solution :-)

[eyepopslikeamosquito]

I really dont like the regex magic of the ruby solution, cant you guys think of another solution :-)

How about some inject magic?

x = s.split(//).inject([]) {|a,e| (a.last && a.last[e] ? a.last : a) <
+< e; a}