Oh yes! Great tip!

You do it the other way round: first you read the smaller file into a hash. Then you open the bigger file, check for each ID if it exists in the hash and only print if it does not.

Yeah, true, I was just hoping there could be an one-liner solution to this, and not need to write a "normal" script...

You can do that in one line. The easiest way is to use a really long line and to fill that line by removing all line breaks from the script.

Maybe you can show us the code you've already written to solve the problem. Then we can help you with the technical hurdles that might prevent that code from working as a one-liner.

Something like this perhaps:

$ cat 1028930_short
2
5
6
8
[download]

$ cat 1028930_long
1
2
3
4
5
6
7
8
9
[download]

$ perl -i -nE 'chomp; if ($s) { $d{$_} or say } else { ++$d{$_}; ++$s 
+if eof; say }' 1028930_short 1028930_long
[download]

$ cat 1028930_short
2
5
6
8
[download]

$ cat 1028930_long
1
3
4
7
9
[download]

perl -pie '
BEGIN {
  open $fh, "<" , "littlefile" or die "Cannot read file";
  our %hash = map { $_ => 1} <$fh>;
}
print if not $hash{$_};
' < bigfile
[download]

All the above will go on one line. any minor bugs are your problem (chomps may be needed for example) :-)

perl -ne "$small||=$ARGV; $small eq $ARGV? $h{$_}++: $h{$_}?0:print" s
+mall.txt large.txt
[download]

Use single-quotes if you run in *nix.

Good idea, but removing the hard coding of file names perhaps gives....

perl -ne "
$ARGV eq $ARGV[0] ?
    $h{$_}++ : 
        $h{$_} ? 0 : print;
" small.txt large.txt
[download]

A Monk aims to give answers to those who have none, and to learn from those who know more.

Here's another way; I'm going to grab some sleep instead of turning it into a one-liner. :-)

#!/usr/bin/perl -w

use strict;

sub slurp {
        my  $file = shift;
        open my $fh, '<', $file or return undef;
        local $/ unless wantarray;
        return <$fh>;
}

my @long = slurp 'long';
my @short = slurp 'short';

my %diff;
@diff {@long} = ();
delete @diff {@short};
my @diff = sort keys %diff;

print "@diff\n";
[download]

perl -ne 'BEGIN {open my $sh, "<", shift; %h = map {$_ => 1} <$sh>} print unless $h{$_}' small large

Read the small file in the BEGIN block and shift it out of @ARGV.

A minor plus of this approach is that any number of "large" files can be passed, after the "small" file.

If you have File::Slurp available:

perl -MFile::Slurp=slurp -ne 'BEGIN {%h = map {$_ => 1} slurp shift} print unless $h{$_}' small large

exclude smallfile from largefile

grep -i -v -f smallfile largefile
[download]

include only smallfile from largefile

grep -i -f smallfile largefile
[download]

include only smallfile from largefile in reverse order numberic by kolumn 2

grep -i -f smallfile largefile | sort -r -b -g -k 2
[download]