Any suggestions as to how to simplify/condense this code snippet ?

As opposed to condensing it, if I came across this code I'd rather it be expanded:

    my %Y;
 
    while (<>) {
        ...
        my ($y) = ...;
        next unless $y;

        if (@ARGV) {
            for (@ARGV) { 
                $Y{$y}++;
                next if $y eq $_;  
            }
        } 
        else { 
            $Y{$y}++; 
        }
    }
[download]

As far as changes, I agree with the implementation of more descriptive variable names. I'm also picky about unless for some weird, unconfirmed reason (probably because 'unless' isn't seen in other languages and/or the '!' stands out loudly), so I'd write that as next if ! $y, but I digress.

One simplification that can condense things a bit is changing this:

    if (@ARGV) {
        for (@ARGV) { 
            $Y{$y}++;
            next if $y eq $_;  
        }
    }
[download]

... to this:

    for (@ARGV) { 
        $Y{$y}++;
        next if $y eq $_;  
    }
[download]

In other words, unless you explicitly need to, there's no need to check whether the @ARGV variable is true before you attempt to iterate over it. The for()/foreach() implicitly does this for you.

++$Y{$y} if grep { $y eq $_ } @ARGV;
[download]

It does loose the short-circuiting aspect, but that's not likely to be relevant. But what if we take it a step further.

my $re;
if ( @ARGV ) {
   my $pat = join "|", map quotemeta, @ARGV;
   $re = qr/^(?:$pat)\z/;
}

my %Y;
while ( <> ) {
  my ( $y ) = ...;

  ++$Y{ $y } if $y && ( !$re || $y =~ $re );
}
[download]

Update: Hash simpler than regex.

my $re;
my %valid;
++$valid{ $_ } for @ARGV;

my %Y;
while ( <> ) {
  my ( $y ) = ...;

  ++$Y{ $y } if $y && ( !%valid || $valid{ $_ } );
}
[download]

The first version does not allow for empty @ARGV; both versions do not allow for the possibility that @ARGV may have repeated elements.

I think a short form that preserves all the current behaviour could look like this:

  ...
  next unless $y;
  $Y{$y} += @ARGV ? (grep $y eq $_, @ARGV) : 1;
[download]

It would, though, be preferable to have some clue about what the code is intended to achieve: it is always possible that the behaviour on repeated elements is unintentional or irrelevant.

The first version does not allow for empty @ARGV

That's not true. If you remove the if, sure, but noone said to do that.

my %Y;
while (<>) {
  ...
  my ($y) = ... ;
  next unless $y;
  
  # Add the scalar number of elements in @ARGV to the hash
  # Always add at least 1 to the hash even if @ARGV contains
  # no elements
  # the value $y is meaningless and plays no role
  
  if(@ARGV) {
      # next is always executed regardless of $y eq $_
      foreach (@ARGV) { $Y{$y}++,next if $y eq $_;  }
  } else { $Y{$y}++ }
}
[download]

scalar @ARGV ? $Y{$y} += @ARGV : $Y{$y}++;
[download]

foreach (@ARGV) { next if $y eq $_; # don't count any occurrences of
                                    # $y
                  $Y{$y}++,
                }
[download]

scalar @ARGV ? $Y{$y} += (grep $y ne $_, @ARGV) : $Y{$y}++; Without some more English language explanation, I have no idea what the code is supposed to do.

I would characterize the effect of the code as:

For each input line, process it and extract an id. When run with no arguments, count in %Y the number of times each id appears; when run with a list of ids as arguments, count only how often the specified ids appear (with multiplicity).

I suspect you have been misled by a misinterpretation of:

foreach (@ARGV) { ++$Y{$y}, next if $y eq $_; }
[download]

which is equivalent to:

foreach (@ARGV) {
    if ($y eq $_) {
        ++$Y{$y};
        next;
    }
}
[download]

(I assume the useless next is left over from cutting down the original code.)

This is an idiom I actually use quite commonly for compactness when parsing arguments:

while (@ARGV && $ARGV[0] =~ /^-/) {
    my $arg = shift @ARGV;
    last if $arg eq '--';
    ($max = $arg || shift(@ARGV)), next if $arg =~ s{^-x}{};
    $inject = 1, next if $arg eq '-i';
    ++$debug, next if $arg eq '-d';
    die "Unknown option '$arg'\n";
}
[download]

Update: The following is wrong. Ignore it.

$Y{$y} += (grep $y eq $_, @ARGV) || 1;

In the OP, it looks like if @ARGV is true but no $y matches $_ then $Y{$y} should not be incremented. But the above code will increment it.

You're right, my bad.
map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]

Acme::Bleach to the rescue ;-)

SCNR

use strict;
use warnings;
use Test::More;
my $y = 5;
my %Y;
my @cases = (
    [[],        'no @ARGs'],    # 1
    [[1,2,3], 'no matches'],    # undef
    [[5,2,5],  '2 matches'],    # 2
);
plan tests=>3;

foreach my $case (@cases) {
    @ARGV = @{$case->[0]};
    %Y = ();
    my $Y_OP = OP();
    @ARGV = @{$case->[0]};
    %Y = ();
    my $Y_TEST = TEST();
    is($Y_TEST, $Y_OP, $case->[1]);
}

sub OP {
    if(@ARGV) {
      foreach (@ARGV) { $Y{$y}++,next if $y eq $_;  }
    } else { $Y{$y}++ }
    return $Y{$y};
}

sub TEST{
    my $number_of_matches = grep { $_ eq $y } @ARGV; 
    $number_of_matches = undef if $number_of_matches == 0;
    $Y{$y} = (@ARGV != 0) ? $number_of_matches : 1;
    return $Y{$y};
}
[download]

OUTPUT:

1..3
ok 1 - no @ARGs
ok 2 - no matches
ok 3 - 2 matches
[download]

Untested reduction, removed implicit $_ for clarity:

use strict;
use warnings;

my %Y = ();

MAINLOOP:
while (<>) {
  ...
  my ($y) = ... ;
  next MAINLOOP unless $y;
  $Y{$y}++;
INNERLOOP:
  foreach my $arg (@ARGV) {
    next INNERLOOP if $y eq $arg;
  }
}
[download]