Why "name" the fields. They are indexed numerically, so use the indexes to index your report array.

The following is a dump of @report. It shows that (from the 3 line sample supplied) field[0] contains 2x'483' and 1x'769'; field[1] contained 1 each of 3 values:'DS', 'OS', 'XO'; and so on.

C:\test\primes>..\junk83
[
  { 483 => 2, 769 => 1 },
  { DS => 1, OS => 1, XO => 1 },
  { "dx-14" => 1, "dx-32" => 2 },
  { 1 => 2, 5 => 1 },
  { charles => 1, james => 1, sully => 1 },
  { list3 => 1, list4 => 1, nolist => 1 },
  { "23.456.12.7" => 1, "aardvark.com" => 1, "widgets.com" => 1 },
  { "ty-off" => 1, "ty-on" => 2 },
  { "lx-on" => 3 },
  { B => 1, C => 1, V => 1 },
  { "01" => 2, "07" => 1 },
]
[download]

Code to produce the above output:

#! perl -slw
use strict;
use Data::Dump qw[ pp ];

my @report;

while( <DATA> ) {
    my @f = split ' ', $_;
    for my $field ( 0 .. $#f ) {
        $report[ $field ]{ $f[ $field ] }++;    
    }
}

pp \@report;

__DATA__
483 OS dx-32 1 charles list4 aardvark.com ty-off lx-on C 01
483 DS dx-14 1 james list3 23.456.12.7 ty-on lx-on B 01
769 XO dx-32 5 sully nolist widgets.com ty-on lx-on V 07
[download]

my @report;
while (my $line = <$log_file>) {
   my @fields = (split / /, $line);
   $report[$_]{$fields[$_]}++  for 2,4,5,9,7,1;
}
[download]

should do! (untested)

But I would rather use names for each column in a HoH (since you are skipping indices), so

   $report{ $column[$_] }{ $fields[$_] }++  for 2,4,5,9,7,1;

might be better! (for a hash my %report of course)

UPDATE

using column-numbers as names/keys in a HoH

use strict;
use warnings;
use Data::Dump qw/dd/;

my %report;
while (my $line = <DATA>) {
  next if $line =~ /^\s*$/;                     # skip empty lines
  my @fields = (split / /, $line);
  $report{$_}{$fields[$_]}++  for 2,4,5,9,7,1;
}

dd \%report;

__DATA__
483 OS dx-32 1 charles list4 aardvark.com ty-off lx-on C 01
483 DS dx-14 1 james list3 23.456.12.7 ty-on lx-on B 01
769 XO dx-32 5 sully nolist widgets.com ty-on lx-on V 07
[download]

thats what you want?

{
  1 => { DS => 1, OS => 1, XO => 1 },
  2 => { "dx-14" => 1, "dx-32" => 2 },
  4 => { charles => 1, james => 1, sully => 1 },
  5 => { list3 => 1, list4 => 1, nolist => 1 },
  7 => { "ty-off" => 1, "ty-on" => 2 },
  9 => { B => 1, C => 1, V => 1 },
}
[download]

thats exactly what I want, the HoH is a better idea. Thanks for that, LanX.

What's wrong with your "horrible" code is that you don't use the data in the outer loop. If written like that:

   OUTER: foreach my $outerField (@fields[2,4,5,9,7,1]) {
      my %hash;
         INNER: foreach my $innerField(@fields[2,4,5,9,7,1]) {
            $hash{$innerField}++;
         }
      push @report, \%hash;
   }
[download]

If I were you, I'd get the result of the split into a hash instead of an array, because selecting them by number doesn't help reading.

use strict;
use warnings;
use Data::Dumper;

my %report;
my $nameCount=0;
my @names = map { $_.++$nameCount } ('Key', ) x 10; 
# Here the names will be Key1 to Key10, 
# But you should actually give explicit names with something like
# my @names = qw/Princess Leia Obiwan Kenobi Anakin Skywalker Darth Va
+der Han Solo/;

while (my $line = <DATA>) {
   my %fields;
   @fields{@names} = (split / /, $line); # Here we put the result into
+ a slice of %fields
   foreach my $name (@names) {
      my $value = $fields{$name};
      $report{$name}{$value}++; # Auto vivification here, $report{$nam
+e} magically becomes a hashref      
   }
}

print Dumper \%report;

__DATA__
483 OS dx-32 1 charles list4 aardvark.com ty-off lx-on C 01
483 DS dx-14 1 james list3 23.456.12.7 ty-on lx-on B 01
769 XO dx-32 5 sully nolist widgets.com ty-on lx-on V 07
[download]

$VAR1 = {
          'Key10' => {
                       'C' => 1,
                       'B' => 1,
                       'V' => 1
                     },
          'Key2' => {
                      'XO' => 1,
                      'OS' => 1,
                      'DS' => 1
                    },
          'Key1' => {
                      '483' => 2,
                      '769' => 1
                    },
          'Key5' => {
                      'james' => 1,
                      'sully' => 1,
                      'charles' => 1
                    },
          'Key8' => {
                      'ty-on' => 2,
                      'ty-off' => 1
                    },
          'Key4' => {
                      '1' => 2,
                      '5' => 1
                    },
          'Key6' => {
                      'nolist' => 1,
                      'list3' => 1,
                      'list4' => 1
                    },
          'Key3' => {
                      'dx-32' => 2,
                      'dx-14' => 1
                    },
          'Key7' => {
                      'aardvark.com' => 1,
                      'widgets.com' => 1,
                      '23.456.12.7' => 1
                    },
          'Key9' => {
                      'lx-on' => 3
                    }
        };

Appart from the use of a hash instead of an array, it's pretty much the same as LanX and BrotherUk's ones.

In your log line sample there are two lines with the same first number. however if the first number is the log line and you use a sample where all the first numbers are different this shows you how to create a hash of arrays where the key is the first number in the line.

#!/usr/bin/perl
use strict;
my @sample = 
("483 OS dx-32 1 charles list4 aardvark.com ty-off lx-on C 01",
"495 DS dx-14 1 james list3 23.456.12.7 ty-on lx-on B 01",
"769 XO dx-32 5 sully nolist widgets.com ty-on lx-on V 07");
my %hoa;

foreach my $line (@sample){
  my @array = split(/ /, $line);
  my $key = $array[0];
    $hoa{$key} = \@array; #this is a reference
  }
my @keys = keys %hoa;
foreach my $item(@keys){
   print "log line $item\n";
   my @array = @{$hoa{$item}}; #this is dereferenced
   foreach my $part(@array){ print "$part - ";}
   print "\n";
}
[download]

Usually, when faced with requirements like these, I grab the various “columns” into hash buckets, just so that I can easily refer to them by name.   (I also use use constant to define those names in the code.)

Then, when it comes time to actually generate an array out of the thing, I simply iterate through a qw// list of those strings, so that it is the order of the entries in this list (effortlessly changed to suit the present whim of the marketing department ...) that defines the column-order.   You can rearrange them to your heart’s content and nothing else happens throughout the code.

By contrast, if you try to use actual array-indices ... well, the day will come when the third change of the day happens and “you miss just one of them ...”