#!/usr/bin/perl 
 
my @letters = qw(G L); 
my $letter = shift @letters; 
my %lines; 
my $i = 0; 
while (<>) { 
    chomp; 
    if (my $l = $lines{$_}) { 
        my $ll = $l->{letters}; 
        next if ($ll->[-1] eq $letter); 
        push @$ll, $letter; 
    } 
    else { 
        $lines{$_} = { 
            f => scalar(@letters), 
            i => $i++, 
            letters => [$letter], 
        } 
    } 
    if (eof) { 
        $letter = shift @letters; 
        $i = 0; 
    } 
} 
print $_, ' ', join('', @{$lines{$_}{letters}}), "\n" for sort { 
    $lines{$a}{i} <=> $lines{$b}{i} or $lines{$b}{f} <=> $lines{$a}{f} 
} keys %lines;

use strict; 
use warnings; 
my %H_list; 
do { 
    open my $H_list, '<', 'xxxH.txt' or die "Cannot open xxxH.txt: $!"; 
    my @temp = <$H_list>; 
    close $H_list; 
    @H_list{@temp} = 1 x scalar @temp; 
}; 
my %A_list; 
do { 
    open my $A_list, '<', 'xxxA.txt' or die "Cannot open xxxA.txt: $!"; 
    my @temp = <$A_list>; 
    close $A_list; 
    @A_list{@temp} = 1 x scalar @temp; 
}; 
open my $L_list, '<', 'xxxL.txt' or die "Cannot open xxxL.txt: $!"; 
while (<$L_list>) { 
    chomp; 
    print; 
    print ' H' if exists $H_list{$_}; 
    print ' A' if exists $A_list{$_}; 
    print "\n"; 
}

    print ' H' if $H_list{$_} == $L_list($_);  
    print ' A' if $A_list{$_} == $L_list($_);

#!/usr/bin/perl 
 
use strict;  
use warnings;  
  
my ( $xxxL, $xxxH, %hash, $reverse ) = @ARGV;  
  
while (<>) {  
	my @fields = $reverse ? reverse split : split;  
	$hash{"@fields"}{$ARGV}++;  
	$reverse++ if eof;  
}  
  
for my $key ( sort { ( split ' ', $a )[0] cmp ( split ' ', $b )[0] } keys %hash ) {  
	print $key if exists $hash{$key}{$xxxL};  
	print ' H' if keys %{ $hash{$key} } == 2;  
	print "\n";  
}

#!/usr/bin/perl 
 
use strict;  
use warnings;  
  
my ( $listL, $listH, $listA, %hash ) = @ARGV;  
 
while (<>) {  
	my @fields = (); 
	$hash{"@fields"}{$ARGV}++;  
}  
  
for my $key ( sort { ( $a[0] cmp ( $b[0] && $c[0] ) } keys %hash ) {  
	print $key if exists $hash{$key}{$listL};  
	print ' H' if keys %{ $hash{$key} } == 2;  
	print ' A' if keys %{ $hash{$key} } == 2; 
	print "\n";  
}

my ( $listL, $listH, $listA, %hash ) = @ARGV;

while (<>) { # ...

#!/usr/bin/perl 
use strict;  
use warnings;  
my %H_list;  
do {  
    open my $H_list, '<', 'listH.txt' or die "Cannot open xxxH.txt: $!";  
    my @temp = <$H_list>;  
    close $H_list;  
    @H_list{@temp} = 1 x scalar @temp;  
};  
my %A_list;  
do {  
    open my $A_list, '<', 'listA.txt' or die "Cannot open xxxA.txt: $!";  
    my @temp = <$A_list>;  
    close $A_list;  
    @A_list{@temp} = 1 x scalar @temp;  
};  
open my $L_list, '<', 'listL.txt' or die "Cannot open xxxL.txt: $!";  
while (<$L_list>) {  
    chomp;  
    print;  
#    print ' H' if exists $H_list{$_};  
#    print ' A' if exists $A_list{$_};  
# The above 2 lines yield no flags 
# Some variation of this code *should* work but can't figure out how to fix it ;-( 
for my $key ( sort { ($L_list{$_})[0] cmp ( ($H_list{$_})[0] || ($A_list{$_})[0]) ) } keys %hash ) {  
	print $key if exists $hash{$key}{$L_list{$_}};  
	print ' H' if keys %{ $hash{$key}{$H_list{$_}} } == 2;  
	print ' A' if keys %{ $hash{$key}{$A_list{$_}} } == 2; 
	print "\n"; 
} 
}

#!/usr/bin/perl  
use strict;   
use warnings;   
my %H_list;   
do {   
    open my $H_list, '<', 'listH.txt' or die "Cannot open xxxH.txt: $!";   
    my @temp = <$H_list>;   
    close $H_list;   
    @H_list{@temp} = 1 x scalar @temp;   
};   
my %A_list;   
do {   
    open my $A_list, '<', 'listA.txt' or die "Cannot open xxxA.txt: $!";   
    my @temp = <$A_list>;   
    close $A_list;   
    @A_list{@temp} = 1 x scalar @temp;   
};   
open my $L_list, '<', 'listL.txt' or die "Cannot open xxxL.txt: $!";   
while (<$L_list>) {   
    chomp;   
    print;   
    print ' H' if exists $H_list{$_} and $H_list{$_} == $L_list{$_};   
    print ' A' if exists $A_list{$_} and $A_list{$_} == $L_list{$_};   
    print "\n";  
}

    print ' H' if exists $H_list{$_} and $_ == $L_list;   
    print ' A' if exists $A_list{$_} and $_ == $L_list;

    print ' H' if exists $H_list{$_} and $H_list{$_} == $L_list{$_};    
    print ' A' if exists $A_list{$_} and $A_list{$_} == $L_list{$_};

	 
 
Checking for Existence  
  
If you try to access a key/value pair from a hash that doesn't exist, you'll normally get the undefined value, and if you have warnings switched on, then you'll get a warning generated at run time. You can get around this by using the exists function, which returns true if the named key exists, irrespective of what its value might be:  
  
#!/usr/bin/perl  
  
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);  
  
if( exists($data{'Lisa'} ) ) {  
   print "Lisa is $data{'Lisa'} years old\n";  
}  
else{  
   print "I don't know age of Lisa\n";  
}

	 
 
if( exists($H_list{'ID#HERE'} ) ) {  
   print " H\n";  
}

  DB<23> $H_list{'ID#HERE'} = 1; 
 
  DB<24> print " H\n" if exists $H_list{'ID#HERE'} 
 H

use strict;  
use warnings;  
my %H_list;  
 
open my $H_list, '<', 'xxxH.txt' or die "Cannot open xxxH.txt: $!";  
while (my $line = <$H_list>) { 
	chomp $line; 
	$H_list{$line} = 1; 
}  
close $H_list;  
 
my %A_list;  
open my $A_list, '<', 'xxxA.txt' or die "Cannot open xxxA.txt: $!";  
while (my $line = <$A_list>) { 
	chomp $line; 
	$A_list{$line} = 1; 
}  
close $A_list;  
 
open my $L_list, '<', 'xxxL.txt' or die "Cannot open xxxL.txt: $!";  
while (<$L_list>) {  
    chomp;  
    print;  
    print ' H' if exists $H_list{$_};  
    print ' A' if exists $A_list{$_};  
    print "\n";  
}

Example/Sample: 
 
(List) L entries: 
 
ABC123 
DEF456 
GHI/789 
JIK00/3P 
L357 
 
(List) H entries 
 
DEF456 
GHI/789 
 
(List) A entry 
 
JIK00/3P 
 
So the desire output .txt file would be: 
 
ABC123 
DEF456 H 
GHI789 H 
JIK00/3P A 
L357 
 
If possible, the ultimate would be to add 3 lines at the end of the output .txt file with a total count summary like: 
 
L = 5 <-- The Total ID's in List L 
H = 2 <-- The Total ID's flagged from list H 
A = 1 <-- The Total ID's flagged from list A 
 
This would eliminate having to import the final output file into Excel and do 2 sorts to tally up the H and A flags (and to double-check that all entries from 'Master List' L are included).

#!/usr/bin/perl  
use strict;   
use warnings;   
my %H_list;   
do {   
    open my $H_list, '<', 'listH.txt' or die "Cannot open xxxH.txt: $!";   
    my @temp = <$H_list>;   
    close $H_list;   
    @H_list{@temp} = 1 x scalar @temp;   
} 
; 
 
foreach (sort keys %H_list) { 
     print "$_"; 
}

   print ' H' if exists $H_list{$_} and $_ eq $L_list;   
   print ' A' if exists $A_list{$_} and $_ eq $L_list;

    print ' H' if exists $H_list{$_} and $H_list{$_} eq $L_list;   
    print ' A' if exists $A_list{$_} and $A_list{S_} eq $L_list;

$ perl  test_l_h.pl 
ABC123 
DEF456 H 
GHI/789 H 
JIK00/3P A 
L357

use strict;  
use warnings;  
my %H_list;  
 
open my $H_list, '<', 'xxxH.txt' or die "Cannot open xxxH.txt: $!";  
while (my $line = <$H_list>) { 
	chomp $line; 
	$line =~ s/\r//g; # removes windows CR characters 
	$line =~ s/\s+$//; # removes trailing white spaces 
	$H_list{$line} = 1 
}  
close $H_list;  
 
my %A_list;  
open my $A_list, '<', 'xxxA.txt' or die "Cannot open xxxA.txt: $!";  
while (my $line = <$A_list>) { 
	$line =~ s/\r//g; 
	$line =~ s/\s+$//; 
	chomp $line; 
	$A_list{$line} = 1 
}  
close $A_list;  
 
open my $L_list, '<', 'xxxL.txt' or die "Cannot open xxxL.txt: $!";  
while (<$L_list>) {  
    chomp;  
    s/\r//; 
    s/\s+$//; 
    print;  
    print ' H' if exists $H_list{$_};  
    print ' A' if exists $A_list{$_};  
    print "\n";  
}

print ' H' if exists $H_list{$_} and $H_list{$_} == $L_list{$_};    
print ' A' if exists $A_list{$_} and $A_list{$_} == $L_list{$_};

print ' H' if exists $H_list{$_} and $_ eq $L_list;    
print ' A' if exists $A_list{$_} and $_ eq $L_list;

print ' H' if exists $H_list{$_} and $H_list{$_} eq $L_list;    
print ' A' if exists $A_list{$_} and $A_list{S_} eq $L_list;

print ' H' if exists $H_list{$_}; 
print ' A' if exists $A_list{$_};

use strict;  
use warnings;

my ($L_count, $A_count, $H_count); 
open my $L_list, '<', 'xxxL.txt' or die "Cannot open xxxL.txt: $!";  
while (<$L_list>) {  
    chomp;  
    s/\r//; 
    s/\s+$//; 
    $L_count ++; 
    print;  
    $H_count ++ and print ' H' if exists $H_list{$_};  
    $A_count++ and print ' A' if exists $A_list{$_};  
    print "\n";  
} 
print "L: $L_count; A: $A_count; H: $H_count \n";

$ perl  test_l_h.pl 
ABC123 
DEF456 
GHI/789 H 
JIK00/3P 
L357 
L: 5; A: 1; H: 2

use strict;   
use warnings;   
my %H_list;   
 
# ============================================================== 
# Special thanks to BillKSmith and Laurent_R at www.perlguru.com  
# for the code that works and tremendous educational experience! 
# ============================================================== 
  
open my $H_list, '<', 'listH.txt' or die "Cannot open listH.txt: $!";   
while (my $line = <$H_list>) {  
	chomp $line;  
	$line =~ s/\r//g; # removes windows CR characters  
	$line =~ s/\s+$//; # removes trailing white spaces  
	$H_list{$line} = 1  
}   
close $H_list;   
  
my %A_list;   
open my $A_list, '<', 'listA.txt' or die "Cannot open listA.txt: $!";   
while (my $line = <$A_list>) {  
	$line =~ s/\r//g;  
	$line =~ s/\s+$//;  
	chomp $line;  
	$A_list{$line} = 1  
}   
close $A_list;  
 
my %F_list;   
open my $F_list, '<', 'listF.txt' or die "Cannot open listF.txt: $!";   
while (my $line = <$F_list>) {  
	$line =~ s/\r//g;  
	$line =~ s/\s+$//;  
	chomp $line;  
	$F_list{$line} = 1  
}   
close $F_list;  
 
my %N_list;   
open my $N_list, '<', 'listN.txt' or die "Cannot open listN.txt: $!";   
while (my $line = <$N_list>) {  
	$line =~ s/\r//g;  
	$line =~ s/\s+$//;  
	chomp $line;  
	$N_list{$line} = 1  
}   
close $N_list;  
 
my ($L_count, $A_count, $H_count, $F_count, $N_count);  
open my $L_list, '<', 'listL.txt' or die "Cannot open listL.txt: $!";   
while (<$L_list>) {   
    chomp;   
    s/\r//;  
    s/\s+$//;  
    $L_count ++;  
    print;   
    $H_count ++ and print ' H' if exists $H_list{$_};   
    $A_count ++ and print ' A' if exists $A_list{$_};   
    $F_count ++ and print ' F' if exists $F_list{$_};   
    $N_count ++ and print ' N' if exists $N_list{$_};  
    print "\n";   
}  
print "L: $L_count; H: $H_count; A: $A_count; F: $F_count; N: $N_count \n";