sub diff
{
    my ($a, $b) = @_;
    my %b;
    undef @b{@$b};
    grep !exists $b{$_}, @$a;
}
[download]

use List::MoreUtils qw(any);

@diff = map { my $x = $_;
              (any { $x eq $_ } @badstuff) ? () : $x;
            } @badstuff;
[download]

I personally believe that

@y = map { condition($_) ? $_ : () } @x;
[download]

is generally spelt

@y = grep { condition($_) } @x;
[download]

Of course, you have the condition reversed, but then a ! would do, and I doubt it would impose a considerable penalty in terms of efficience.

--
If you can't understand the incipit, then please check the IPB Campaign.

my %results;
@goodstuff = (1,2,3,4,5);
@badstuff = (1,3);

for (@goodstuff) { $results{$_}++ }
for (@badstuff}  { $results{$_}++ }

for (keys %results) {
  if ($results{$_} == 1) {
    print "Value: " . $_ . " was found in only one array\n";
  }
}
[download]

I think that is right, I just coded it off the top of my head so no promises...

Your correct in saying your code finds elements which are only in one of the sets. But the OP asked for an implementation to find the difference of two sets. Your code only finds the difference when @badstuff is a subset of @goodstuff.

A solution:

my %result;
@result{ @goodstuff } = ();
delete @result{ @badstuff };
my @result = keys %result;
[download]

The O.P did not state if he wanted the results in the same order as the original array.

Even without that requirement, if the original array contained duplicate values, a solution that collapsed the original into a hash would eliminate duplicates, and , IMHO, provide a wrong result.

However, 3 good solutions which do not collapse the original array have been provided by others, below.

I would suggest that educated_foo's (++) is the most portable,readable one with no dependencies.

     "A fanatic is one who redoubles his effort when he has forgotten his aim."—George Santayana

What if there are repetitions in either of the arrays? And the OP asked for a efficient solution: while I have not tested your algorithm, and it is potentially interesting for being linear in the sizes of the arrays, I believe that building a hash and then iterating over its keys will make it slow enough for many reasonable data sets. (I don't think this would matter, but the OP is convinced it does...)

--
If you can't understand the incipit, then please check the IPB Campaign.

See Set::IntSpan

From the doc : << Sets are stored internally in a run-length coded form. This provides for both compact storage and efficient computation. In particular, set operations can be performed directly on the encoded representation. >>

#!/usr/bin/perl -w
use strict;
use Data::Dumper;
use Set::IntSpan;

my $good_run_list = '1-5';
my $bad_run_list  = '1,3';
my ( $good_set, $bad_set, $x_set );

if ( valid Set::IntSpan $good_run_list and valid Set::IntSpan $bad_run
+_list ) { 
    $good_set = new Set::IntSpan $good_run_list;
    $bad_set  = new Set::IntSpan $bad_run_list;
}
else { print "Please verify your run lists\n" }

$x_set = $good_set ^ $bad_set;

# Or $x_set = $good_set->X($bad_set);

finite $x_set and my @elements = elements $x_set;
print Dumper \@elements;

__END__

Output:
$VAR1 = [
          2,
          4,
          5
        ];
[download]

hth,
PooLpi

Hello, I'm relatively new to PERL and have a pretty basic question.

I personally believe that the very fist thing you should know is that it's not PERL.

Is GREP usable in this instance?

It's certainly usable. But it all depends on the code you tell it to execute. One common technique to check whether and item belongs to an array used to involve another grep, but that would be inefficient, since it would iterate over all items of the bad list. Thus a better choice would be List::Util's first() which stops as early as an item is found. With 5.10, however, you have a specialized operator to do this kinda things: ~~:

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;

my @goodstuff=1..5;
my @badstuff=(1,3);

my @newstuff = grep !($_ ~~ @badstuff) => @goodstuff;
say "@newstuff";

__END__
[download]