Data::Dumper is a good example how to print a data structure. It is also not difficult to write a recursive sub that does a similar thing. See below. You could also add a callback function that searches for whatever. I made some assumptions about the data structure you are looking at but I think my example is relatively general.

use strict;
use Data::Dumper;

my %hash;
$hash{Company_A}{ Identifier_1 } = ["a", "b"]; 
$hash{Company_A}{ Identifier_2 } = ["b", "g"];                        
+      
$hash{Company_A}{ Identifier_3 } = "c"; 

$hash{Company_B}{ Identifier_1 } = "a"; 
$hash{Company_B}{ Identifier_2 } = "g"; 
$hash{Company_B}{ Identifier_3 } = "x"; 

print Dumper(%hash);

traverse( 0, \%hash );

sub traverse {
  my $level = shift;
  my $ref = shift;
  if( ref($ref) =~ /HASH/ ) {
    print "\n";
    for my $key (keys %$ref) {
      print "\t" x $level, $key;
      traverse( $level+1, $$ref{$key} );
    }
  } elsif( ref($ref) =~ /ARRAY/ ) {
    print "\n";
    for (@$ref) {
      print "\t" x $level;
      traverse( $level+1, $_ );
    }
  } else {
    print "\t" x $level, $ref, "\n";
  }
}
[download]

I was just thinking to myself that I need something like Data::Dumper :). Cheers

#!/usr/bin/perl
use strict;
use warnings;
use 5.014;
use Data::Dumper;

my %hash = ( Company_A => { 
                             Identifier_1 => ['a', 'b'],
                                Identifier_2 => ['b', 'g'],
                                 Identifier_3 => ['c']
                             }, 

             Company_B => { Identifier_1 => ['a'],
                                 Identifier_2 => ['g'],
                                 Identifier_3 => ['x']
                             });

my $b_count = map { grep {$_ eq 'b'} @$_ } values %{ $hash{Company_A} 
+};

for my $company (sort keys %hash) {
    my (@ones, @multi);
    
    my $href = $hash{$company};
    for my $id (sort keys %$href) {
        my $aref = $href->{$id};
        if (1 == @$aref) {
            push @ones, $aref->[0];    
        }
        else {
            push @multi, $aref;    
        }
    }
    if (@multi) {
        for my $m (@multi) {
            print "$company ", join(",", @$m, @ones), "\n";
        }
    }
    else {
        print "$company ", join(",", @ones), "\n";
    }
}
[download]

C:\Old_Data\perlp>perl t6.pl
Company_A a,b,c
Company_A b,g,c
Company_B a,g,x
[download]

OP here. Thanks very much guys, I get the idea and will play around with the code.

1.

my $b_count = () = map { grep { $_ eq "b" } @$_ } values %{$Hash{Compa
+ny_A}};
[download]

Sorry, I couldn't understand your second question. Perhaps reading perlreftut will help you solving it yourself.

map is simply a loop construct, like foreach(), while() or even grep(). If you have a composite type (like hash or array) you need a loop to get at all values. If you have a composite type inside another composite type (for example a HashofArrays) you obviously need a loop inside a loop aka nested loops. For even higher dimensions you need the corresponding number of nested loop constructs. Right?

Now you have a HashOfArrays, a composite type of dimension 2, so you need a nested loop. If you want to use map (instead of foreach) then you need a nested map, i.e. a map inside a map. The outer map is for the hash, the inner map is for the array.