Hi pritesh_ugrankar.

A hash is usually the best-suited tool for finding out whether elements in one list are in another. Add a key to the hash for each element in the list you are checking, then see if a key exists for each element in the list to be matched.

use strict; use warnings; use feature 'say';

my @x = ( -2, 2, 3, 8, 10 );
my %y = map { $_ => 1 } @x;

say "missing: $_" for grep { not exists $y{ $_ } } ( -2 .. 10 );
[download]

perl 1186862.pl
missing: -1
missing: 0
missing: 1
missing: 4
missing: 5
missing: 6
missing: 7
missing: 9
[download]

Hope this helps!

Hey Nick,

I had only a few minutes to play with this when it first came up, but I couldn't accomplish what I wanted with the time I had. What I did have was very similar. That said, you've hard-coded your array when doing the grep(), which probably isn't realistic in production, and it's a bit outside of what OP was after. To do it out of order and without hardcoding, an extra sort needs to be put in place. It could be done inline, but this makes it a bit more clear I think:

use strict; 
use warnings; 
use feature 'say';

my @x = ( -2, 3, 2, 10, 15, 8 );
my %y = map { $_ => 1 } @x;

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

say "missing: $_" for grep { ! exists $y{$_} } $x[0] .. $x[-1];
[download]

Hi,

Wow. This is going to take some time to understand. But I'll take it one line at a time. :) Thank you very much for sharing your method.

Thinkpad T430 with Ubuntu 16.04.2 running perl 5.24.1 thanks to plenv!!

You are welcome. Hint: to understand a statement with map and/or grep, read it from right to left.



The way forward always starts with a minimal test.

#!/usr/bin/perl

# http://perlmonks.org/?node_id=1186862

use strict;
use warnings;

my @arr = (19,17,22,23,24,15,16,25..35);

my ($low, $high) = (sort {$a <=> $b} @arr)[0, -1];
my @missing = 0 .. $high;
@missing[@arr] = ('') x @arr;
print "missing numbers are @missing[$low .. $high]\n";
[download]

Bravo! :D //

This is ingenious in its simplicity :)

Not a better way perhaps, but a solution using Set::IntSpan.

#!/usr/bin/perl
use strict;
use warnings;
use Set::IntSpan;

my @arr = (19,17,22,23,24,15,16,25..35);
my $set = Set::IntSpan->new(\@arr);

print join ' ', $set->holes->elements;
[download]

Prints:

18 20 21

Hi,

Thanks for the update. I didn't know about that module.

Thinkpad T430 with Ubuntu 16.04.2 running perl 5.24.1 thanks to plenv!!

In the spirit of TIMTOWTDI :)

#!/usr/bin/perl

# http://perlmonks.org/?node_id=1186862

use strict;
use warnings;

my @arr = (19,17,22,23,24,15,16,25..35);

my @sorted = sort {$a <=> $b} @arr;
my @missing = map { $sorted[$_ - 1] + 1 .. $sorted[$_] - 1 } 1 .. $#so
+rted;

print "missing numbers are @missing\n";
[download]

eh! bravo as always tybalt89 but stop beating me on time (as well as in quality..)!

;=)

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

There hasn't been a regex solution yet, so here's one as a one-liner :)

perl -le '"@{[sort{$a<=>$b}19,17,22,23,24,15,16,25..35]}"=~/\b\d+ (?=(
+\d+))(?{push@a,$&+1..$1-1})(*F)/;print"@a"'
[download]

Numbers 1..n, one missing.

#! /usr/bin/perl -wl

use List::Util qw( sum );

my @arr = (1..3,5..7);

print +- sum -1-@arr .. -1,@arr;
[download]

That's a well oiled twist.

Everyone looking at arrays and comparisons when there was a mathematical solution hiding in plain sight.

... a mathematical solution hiding in plain sight.

Perhaps better to say "hiding in obscurity." From the OP (emphasis added):

... find a missing number if in a list of numbers. ...

...
my @arr = (19,17,22,23,24,15,16,25..35);
...

But the list in the code example clearly has more than one missing number. See also the (current) thread title. I think the goose chase, although wild, was justified.

---

Give a man a fish:  <%-{-{-{-<

inspired by your use of sum, the expected sum(1..n) = n*(n+1)/2, so take the found sum from the expected sum:

use List::Util qw(sum);
my @arr=(1..3,5..7); 
print +(1+@arr)*(2+@arr)/2 - sum(@arr);
[download]

update: clarification = use 1+ and 2+ here because an element is missing from @arr

you got easier answers, pardon me for the following (long)oneliner:

perl -E "@sr=sort{$a<=>$b}@ar=(5..7,8,10,-3);map{$h{$_}++}$sr[0]..$sr[
+-1],@ar;say for grep{$h{$_}==1}sort{$a<=>$b} keys %h"
-2
-1
0
1
2
3
4
9
[download]

L*

Given an increasing sequence of numbers from 1 to n with only one missing number, how can you find that missing number

The solution to that problem can be found using binary search in O(logN).

ah! given the above task the oneliner is much simpler!

perl -E "@ar=(1..3,5,6,7);$h{$_}++for$ar[0]..$ar[-1];delete$h{$_}for@a
+r;print keys %h"

4
[download]

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

Slices, slices...

perl -E '\@h{1..(@a=(1..3,5,6,7))+1};delete@h{@a};say%h'
[download]

hey, let's play golf!

perl -e'$_>++$i&&die"$i\n"for 1..3,5,6,7'
[download]

Or an array version.

perl -E '@b=0..(@a=(1..3,5,6,7))+1;@b[0,@a]="";say@b'
[download]

Hi Salva,

Thanks for pointing that out. I missed that. :(

Thinkpad T430 with Ubuntu 16.04.2 running perl 5.24.1 thanks to plenv!!

Hi Monks,

Thank you for your responses. Indeed, Perl is powerful and flexible.

Using the updated problem (numbers starting at 1 in order, only one missing), here's something completely DIFFerent :)

#!/usr/bin/perl -l

# http://perlmonks.org/?node_id=1186862

use strict;
use warnings;
use Algorithm::Diff qw(traverse_sequences);

my @arr = (1..3,5,6,7);

traverse_sequences( \@arr, [ 1 .. @arr + 1 ],
  { DISCARD_B => sub { print "missing: ", 1 + $_[1] } } );
[download]