use Data::Dumper;
print Dumper [evalexp('21, 35, 42-45, 19')];

sub evalexp {
   my $str = shift;
   $str =~ s/\s//g;
   $str =~ s/-/../g;
   return eval $str;
}
[download]

push @expanded, $piece;
[download]

push @expanded, int $piece;
[download]

Happy coding. :)

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Thanks, I didn't even think of doing it that way! :-) I would change

$str =~ s/\s//g;
[download]

to

$str =~ s/[^\d-,]//g;
[download]

though when handling untrusted data.

As they say, TMTOWTDI.

Very interesting, and potentially very, very useful. It might also be useful to have the reverse function, compacting a list of numbers into a list containing ranges.

The code below seems to do this, with the caveats that:

1. if numbers appear twice in the list, only one instance is returned,
2. the original ordering is lost, as the values in this code are sorted to ease processing, and
3. the code is a sample, and someone more skilled would probably be able to do the same better or more efficiently

With that in mind, here is my contribution:

sub compactRanges {

    #
    # @pieces contains the list of numbers
    # %parts will contain a compact form, such that $start..$end
    #   is represented as $parts{$start} = $end
    # $seperator contains the character(s) placed between the
    #   values
    # %wrap_negatives contains a flag indicated if negative
    #   values should be wrapped in some way, and the leading
    #   and trailing values if so
    #
    my (@pieces) = @_;
    my $seperator      = '..';
    my %wrap_negatives =
      ( 'flag' => 1, 'leading' => '[', 'trailing' => ']' );
    my (%parts);

    @pieces = sort { $a <=> $b } @pieces;

    {
        my ($i);
        my ($recent);
        $recent = $parts{$i} = $i = shift (@pieces);
        while (@pieces) {
            $i = shift (@pieces);
            $recent = $i if ( $i - 1 > $parts{$recent} );
            $parts{$recent} = $i;
        }
    }

    foreach my $k ( sort { $a <=> $b } keys(%parts) ) {
        my $str =
          (     ( $wrap_negatives{'flag'} )
            and ( $k < 0 ) ? $wrap_negatives{'leading'} : '' )
          . $k
          . (   ( $wrap_negatives{'flag'} )
            and ( $k < 0 ) ? $wrap_negatives{'trailing'} : '' );
        $str .= $seperator
          . (
                ( $wrap_negatives{'flag'} )
            and ( $parts{$k} < 0 ) ? $wrap_negatives{'leading'}
            : ''
          )
          . $parts{$k}
          . (
                ( $wrap_negatives{'flag'} )
            and ( $parts{$k} < 0 ) ? $wrap_negatives{'trailing'}
            : ''
          )
          if ( $parts{$k} != $k );
        push ( @pieces, $str );
    }
    return (@pieces);
}
[download]

Nice, I like it! You may also be interested in List-to-Range generation, List-to-Range (Advanced), and Yet Another List to Range function.

This problem was the sixth sixth Perl Quiz of the Week by Dominus.

Ciao, Valerio

Thanks! I didn't know Dominus did a Perl QOTW. I guess I'll have to subscribe...  ; )

$tmp[0] > $tmp[1]
   ? push @expanded, reverse ($tmp[1]..$tmp[0])
   : push @expanded, ($tmp[0]..$tmp[1]);
[download]

push @expanded, $tmp[0] > $tmp[1]
   ? reverse ($tmp[1]..$tmp[0])
   : ($tmp[0]..$tmp[1])
;
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

(
    $tmp[0] > $tmp[1]
        ? sub { push @expanded, reverse ($tmp[1]..$tmp[0]) }
        : sub { push @expanded, ($tmp[0]..$tmp[1]) }
)->();
[download]

:->

Makeshifts last the longest.

bad style because the ternery operator is being used in void context.

I know, I'm guilty. I have a tendency to use the ternary operator like that quite often and I've been trying to kick the habit, but the habit keeps kicking back (so to speak). Anyway, I'll change it in the code.

Sometimes I wish one line blocks for if-else statements didn't require brackets, like C's. Oh well.

I like the changes, by the way. Now we have a fully flogged dead horse. :D

Thanks, I like the funky reverse abbreviated ranges. I always liked beating things that couldn't fight back... ; )

"Sometimes I wish one line blocks for if-else statements didn't require brackets..."

I use to say the same thing until i realized they don't:

print "that's the answer" if $answer == 42;

die "that's not your file!" unless -o $file;
[download]

A caveat i teach my C++ lab students (i am a graduate teaching assistant at MTSU) is that even though braces are optional for one line blocks, they should get in the habit of using them always. Why? Because 9 times outta 10 you will want to add a second line in the near future. Murphy's law or something ... ;)

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Well, I'd prefer to leave the array in the order given (just in case the user wants it that way), but if you wanted it sorted you could do one of two things:
1. Replace the line return @expanded; with return sort @expanded;
2. When calling it, just sort the results. Ex/ my @results = sort expandRange($string);

#!/usr/bin/perl
use warnings;

my $ranges = '1,3-7,9-22';
print "$ranges\n";
$ranges =~ s/-/../g;
my @array = map {$_} eval $ranges;
print "@array\n";
[download]

--
I'm not belgian but I play one on TV.