You've got a few issues with your code. You're re-declaring some of your variables with my incorrectly (always put use warnings; and use strict; at the top of your scripts), you're using @array in a global sense when you should be passing it into the subroutine instead, and unless you have good reason not to, you should be putting your use statements at the top of your code as it's far easier to see what the code is using.

With these changes and additions, does it do what you expect? I create the array, send it in as a list of parameters to the sub, perform actions on each element, push the result to a new array, then when done the loop, return the entire new array:

use warnings;
use strict;

use List::Util qw( min max );

my @not_normalized = qw(5 4 9 9 6);

my @normalized = normalizer(@not_normalized);

print "$_\n" for @normalized;

sub normalizer {
    my @not_normalized = @_;

    my $min_numarray = min @array;
    my $max_numarray = max @array;
    my $normalized;

    my @normalized_list;

    foreach my $element (@not_normalized){
        my $numdiv = $element - $min_numarray;
        my $numden = $max_numarray - $min_numarray;
        $normalized = $numdiv / $numden;
        push @normalized_list, $normalized;
    }
    return @normalized_list;
}
[download]

Output:

0.2
0
1
1
0.4
[download]

update: renamed arrays to have sensible names

Yes, thanks! :) this is what I expected.

Other approaches using a for-loop are perfectly OK and you should be sure you understand them. But as you gain more experience with Perl, you'll see that there's a good deal of wasted motion there. Here's a solution I find neat and easy to understand — once you understand the powerful map built-in!

c:\@Work\Perl\monks>perl -le
"use warnings;
 use strict;
 ;;
 use List::Util qw( min max );
 ;;
 my @not_normalized = qw(5 4 9 9 6);
 ;;
 my @normalized = normalizer(@not_normalized);
 ;;
 printf qq{$_  } for @normalized;
 ;;
 sub normalizer {
   my $min_numarray = min @_;
   my $max_numarray = max @_;
   my $numden = $max_numarray - $min_numarray;
   ;;
   return map { ($_ - $min_numarray) / $numden } @_;
   }
"
0.2  0  1  1  0.4
[download]

Update: And if you can stand to operate on the elements of the array in place (definitely fastest for large arrays), here's yet another approach:

c:\@Work\Perl\monks>perl -le
"use warnings;
 use strict;
 ;;
 use List::MoreUtils qw(minmax);
 ;;
 my @array = qw(5 4 9 9 6);
 ;;
 normalizer(@array);
 ;;
 printf qq{$_  } for @array;
 ;;
 sub normalizer {
   return unless @_ >= 2;
   my ($min, $max) = minmax @_;
   my $numden = $max - $min;
   ;;
   $_ = ($_ - $min) / $numden for @_;
   }
"
0.2  0  1  1  0.4
[download]

Thanks for the for loop suggestion! Will definitely try it :)

my $normalized = my $numdiv / $numden;
[download]

foreach my $element(@array) {    # loop over args
    ... 
    my $normalized = my $numdiv / $numden; # normalize
}
return $normalized;
[download]

You can use $element to modify the array (it is an alias, not a copy). $numden is not dependent on the array element, so there is no need to calculate it each time.

use List::Util qw( min max );

sub normalizer {
    my @array = @_;

    my $min_numarray = min @array;
    my $max_numarray = max @array;

    my $numden = $max_numarray - $min_numarray;
    foreach my $element (@array) {
        my $numdiv = $element - $min_numarray; 
        $element = $numdiv / $numden;
    }

    return @array;
}
[download]

use strict;
use warnings;

my @not_normalized = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
my @normalized = normalizer(@not_normalized);
print "@normalized";

sub normalizer {
    # to normalize an input array bw 0 and 1
    my @array = @_;
    use List::Util qw( min max );    # import min and max module
    my $min_numarray = min @array; # get min of args
    my $max_numarray = max @array; # get max of args
    my $numden = $max_numarray - $min_numarray; # denominator: max tot
+al - min total
    foreach my $index (0..$#array) {    # loop over args
        my $numdiv = $array[$index] - $min_numarray;    # numerator: n
+ - min total 
        $array[$index] = $numdiv / $numden; # normalize
    }
    return @array;
}
[download]

While the code I give here is just yours with minimum modifications to do what you want, I actually first attempted to find a CPAN module with a "normalize this array of numbers" sort of function built in. I couldn't find one, but perhaps I'm just bad at searching, because it seems like that's something that probably exists...

I love it when things get difficult; after all, difficult pays the mortgage. - Dr. Keith Whites
I hate it when things get difficult, so I'll just sell my house and rent cheap instead. - perldigious

When I tried "statistics normalize" this came right up.

Celebrate Intellectual Diversity

Thanks! Actually before (attempting to) write my own subroutine, I also tried to google that and I did not find any hits. Maybe we're both bad at googling. :)