You can do it with the .. operator:

@a = (41888, 41889, 41890, 41892, 41895);
@m = map $a[$_-1]+1..$a[$_]-1, 1..@a-1;
print join(" ", @m), $/;
[download]

It isn't the easiest to understand, but that's very nice outside the box thinking!

Update: minor niggles: use $#a since that's what you mean — and please, please, use better variable names.

my @list = ( 41888, 41889, 41890, 41892, 41895 );
my @missing = map { ( $list[ $_ - 1 ] + 1 ) .. ( $list[ $_ ] - 1 ) } 1
+ .. $#list;
[download]

Makeshifts last the longest.

(Twelve years later - directed here by a post on Stack Overflow.)

I'm not convinced that @list is much of an improvement over @a as a name for an array :-)

--


See the Copyright notice on my home node.

Perl training courses

use List::Util qw[ reduce ];
my @in = ( 41888, 41889, 41890, 41892, 41895 );
my @missing;
reduce{ push @missing, $a+1 .. $b-1; $b } @in;
print @missing;

41891 41893 41894
[download]

If your list is large, then this will be more (memory) efficient:

my @in = ( 41888, 41889, 41890, 41892, 41895 );
my @missing;
push @missing, $in[ $_ ] +1 .. $in[ $_+1 ] -1 for 0 .. $#in-1;
print @missing;

41891 41893 41894
[download]

Wow! Reduce with side effects, I've never seen that idiom. Smart.

Well, I'd probably use my mapn utility func for this, but reduce is available pretty much everywhere and lent itself to avoiding the discussion about implementation details.

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
"Memory, processor, disk in that order on the hardware side. Algorithm, algorithm, algorithm on the code side." - tachyon

I'll assume the list is sorted. If not, either sort it or use List::Util's min/max functions to set up the min( @list ) .. max( @list ) range.

my @list = ( 41888, 41889, 41890, 41892, 41895 );

my @missing = do {
    my %missing;
    undef @missing{ $list[ 0 ] .. $list[ -1 ] };
    delete @missing{ @list };
    keys %missing;
};
[download]

That's the simplest way; it takes some memory and I'm not sure about its efficiency, so use with very large lists is not necessarily advised.

Update: another option, assuming that the list really is sorted (can't rely on min/max here):

my @missing;
{
    my $i = 0;
    for ( $list[ 0 ] .. $list[ -1 ] ) {
        ++$i, next if $_ == $list[ $i ];
        push @missing, $_;
    }
}
[download]

Update: and just because I had to, the same thing in functional lingo:

my @missing = do {
    my $i = 0;
    grep { $_ == $list[ $i ] ? ++$i && 0 : 1 } $list[ 0 ] .. $list[ -1
+ ];
};
[download]

use Set::IntSpan;

my $set = Set::IntSpan->new("41888, 41889, 41890, 41892, 41895");
$set = $set->complement()->intersect(
    Set::IntSpan->new($set->min . "-" . $set->max));
print $set->run_list(), "\n";
[download]

41891,41893-41894
[download]

my @list = (41888, 41889, 41890, 41892, 41895);
my $lo = $list[0];
my $hi = $list[$#list];
my $idx = 0;
for ($cnt=$lo;$cnt<=$hi;$cnt++) {
  if ($cnt == $list[$idx]) {
    $idx++;
  } else {
    print "Missing: $cnt\n";
  }
}
[download]

my @list = ( 41888, 41889, 41890, 41892, 41895 );

my @missing = grep { my $x=$_; not grep $x==$_, @list } $list[0]..$lis
+t[$#list];

print "@missing\n";
[download]

Two later SOPWs with a problem similar to this are Find out missing floating value in an array and one-line split file sequence checker.