Personally, I would use a different approach by restating the problem: You are interested in all *.mrg files that have no corresponding *.did file :

opendir DIR, $dir
  or die "Couldn't open directory '$dir' : $!";
my @files = grep { /(.*)\.mrg$/ and not -f "$dir/$1.did" } readdir DIR
+;
closedir DIR;
[download]

My method might be a bit slower, as for each .mrg file, an additional call to stat will be made, which can be very slow on full directories, but I think that the shorter code makes up for the slower code. If speed should really become an issue, I'd readdir the directories contents into a hash and then check for existence in the hash much like your example:

  opendir DIR, $dir
    or die "Couldn't read '$dir' : $!";
  my @all_files = map { lc $_ } readdir DIR;
  closedir DIR;
  my %did = map { /(.*)\.did$/ and ($1 => 1) } grep { /\.did$/ } @all_
+files;
  my @files = grep { /(.*)\.mrg$/ and not $did{$1} } @all_files;
[download]

Also, I don't think that production code should contain references to Perlmonks node IDs, but rather an explanation of what happens :

  # return a list or a reference to an array, depending
  # on what the caller wants:
  return wantarray ? @files : \@files;
[download]

Update: Added "faster" alternative

Update 2: Fixed code in response to merlyns bugfinding

perl -MHTTP::Daemon -MHTTP::Response -MLWP::Simple -e ' ;    # The  
$d = new HTTP::Daemon and fork and getprint $d->url and exit;#spider
($c = $d->accept())->get_request(); $c->send_response( new   #in the
HTTP::Response(200,$_,$_,qq(Just another Perl hacker\n))); ' #  web
[download]

opendir DIR, $dir
  or die "Couldn't open directory '$dir' : $!";
my @files = grep { /(.*)\.mrg$/ and not -f "$1.did" } readdir DIR;
closedir DIR
[download]

No, that's testing "-f" on a file in the current directory for a name that should be checked in a different directory. A traditional readdir mistake. {grin}

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Which is why globing can be so lovely, as it includes the file path for you :) I'm not sure if this is any faster than Abigail-II's solution. At least this does only check for the existence of each file once rather than two checks.

my $dir = '/path/to/dir';

print join ", ", grep {
  /(.*)\.mrg\z/ and not -f "$1.did"
} <$dir/*\.mrg>'
[download]

use strict;
use Data::Dumper;

chomp(my @files = <DATA>);

# find unique basenames
my @basenames = keys %{{ map { (split/\./)[0] => 1 } @files }};

# find unpaired files
foreach my $basename (@basenames) {
    my @matches = grep (/$basename/, @files);
    print "$matches[0]\n" if $#matches == 0;
}

__DATA__
00000001.did
00000001.mrg
00000002.did
00000002.mrg
00000003.did
00000004.mrg
[download]

00000004.mrg
00000003.did
[download]

use strict;
use Data::Dumper;

chomp(my @files = <DATA>);

# find unique basenames
my @basenames = keys %{{ map { (split/\./)[0] => 1 } @files }};

# find unpaired files
foreach my $basename (@basenames) {
    my @matches = grep (/$basename/, @files);
    print "$matches[0]\n" if $#matches == 0;
}
[download]

No, this solution breaks if any filenames have regex-significant metachars, or are partially within a larger filename.

In my opinion, the original solution is actually the most direct, as this is a classic set difference problem.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

opendir my $dh => $dir or die;
my %files;
   @files {map {lc} readdir} = ();    
closedir $dir;
my @missing = grep {/^(.*)\.did$/s && !exists $files {"$1.mrg"} keys %
+files;
[download]

Abigail

use strict;
use File::Find;

my %temp;
find( sub { s/mrg$/did/; 
            /did$/ and $temp{$_}++; }, '.' );
my @files = grep { $temp{$_} == 1 } keys %temp;

print "@files";
[download]

use strict;
use File::Find;

my %temp;
find( sub { m/^(.+)\.(mrg|did)/ 
            and 
            push(@{$temp{"$1.did"}}, $2) }, '.' );
my @files = grep { @{ $temp{$_} } == 1 
                   and 
                   $temp{$_}->[0] eq 'did'
                 } sort keys %temp;
print "@files";
[download]

opendir my $DIR, '.' or die "Can't opendir . : $!\n";
my %single;
my %other = (did => 'mrg', mrg => 'did');

while (my $file = readdir $DIR) {
#print "$file\n";
    my ($name,$ext) = ($file =~ /^(.*)\.(did|mrg)$/)
        or next;
    if (exists $single{"$name.$other{$ext}"}) {
        delete $single{"$name.$other{$ext}"};
    } else {
        $single{$file} = undef;
    }
}

print "Unpaired files:\n";
foreach my $file (keys %single) {
    print "\t$file\n";
}
[download]

A bit longer than most but if the readdir gives you the filenames in order (my does), there is a lot of such files and only a minimum unpaired I believe it would be the quickest and least memory hungry.

Update: Of course if your filesystem is case insensitive you should lowercase the filename to make sure you look for the pairs case insensitively. You may want store the original case in the %single hash in such case.

Edit by castaway: Closed small tag in signature

use strict;

my %files;
my @files;

@files =<DATA>;
@files = map { s/\n//; $_ } @files;
close(DATA);

foreach (@files) {
    $files{substr($_,0,(length()-4))}++;
}

foreach (keys %files) {
    print "$_ is not matched and has a count of $files{$_}\n" if $file
+s{$_} == 1;
}

__DATA__
001.did
001.mrg
002.did
002.mrg
003.did
004.did
005.did
005.mrg
[download]