Try adding a couple of print statements to your program and see what it is doing.

#! perl -slw
use strict;

my @numbers = (3, 2, 1);
my $highest;

## NOTE Perl arrays start from 0 (zero) not 1 (one).
for (my $i = 0; $i < @numbers; $i++)   {
    print "Comparing $numbers[$i] with $numbers[$i+1]";
    if ($numbers[$i] > $numbers[$i + 1])   {
        print "Setting \$highest to $numbers[$i]";
        $highest = $numbers[$i];
    }
 }

 print $highest;
__END__
[download]

prints

C:\test>217736
Comparing 3 with 2
Setting $highest to 3
Comparing 2 with 1
Setting $highest to 2
Use of uninitialized value in concatenation (.) or string at C:\test\2
+17736.pl line 8.
Comparing 1 with
Use of uninitialized value in numeric gt (>) at C:\test\217736.pl line
+ 9.
Setting $highest to 1
1
[download]

Does that make it any clearer for you?

Why do something C-style when you can speak simple Perlish?

my @sorted = sort {$b <=> $a} @numbers;
my $highest = $sorted[0];
[download]

This sorts your array from highest to lowest and puts it in @sorted.

Update: changed "my $highest = $numbers[0];" to "my $highest = $sorted[0];" Many thanks to UnderMine for pointing this out.

John J Reiser
newrisedesigns.com

This may be Perlish, but it is also rather inefficient: O(n*log(n)) vs. O(n).

If you want to do it the Perlish way, why not use max that can be found in the wonderful List::Util module?

Just my 2 cents, -gjb-

Oddly enough, it's more efficient to use sort rather than an explicit Perl loop for for up to a dozen or two elements, if I recall the benchmarks.

Of course, List::Util has a max function, which would be faster still.

But don't be so quick to optimize... you may be unoptimizing.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

my $highest =(sort {$b <=> $a} @numbers)[0];
[download]

This is a bit more compact

Hope it helps
UnderMine

thanks but i need to keep the order of the array intact for the next stage. ;-)

You still have your original list in @numbers: sort copies, it doesn't change the original list.

Hope this helps, -gjb-

use strict;

my @array = (1, 5, 4, 10, 20, 2, 1, 3, 7);
my $highest = $array[0];

foreach (@array) {
    $highest = $_ if $_ > $highest;
}

print $highest;
[download]

No... that would be known as the slow way. This is an operation which should only have to traverse the array *once* where sort() has higher overhead (perhaps gjb has it right as O(n*log(n)) versus O(n)).

The better answer is to use something akin to what you posted. I'd want to check for undefined values as well. For an answer I just copied right from a toy mapping app I just coded up last night.

sub max { my $m;
          for (@_) {
            next unless defined;
            $m = $_, next unless defined $m;
            $m = $_, next if $m < $_;
          }
          $m }
[download]

__SIG__
use B;
printf "You are here %08x\n", unpack "L!", unpack "P4", pack
  "L!", B::svref_2object(sub{})->OUTSIDE;
[download]

thanks LTjake this is cool, but how could you adapt it to calculate second and third highest numbers also??

    how could you adapt it to calculate second and third highest numbers?

something like:

use strict;

my @array = (1, 5, 4, 10, 20, 2, 1, 3, 7);
my @hi = (0) x 3;                # '0' assumes positive #'s

foreach (@array) {
   $_ <= $hi[0] and next;
   @hi = (sort $a<=>$b, @hi, $_)[-3..-1];
}

print "@hi";
[download]

(untested)   (and, as said, of course the sort method would be better, at least for small arrays, and would be even more better for finding the top three values:  (sort ..., @array)[-3..-1] )

  p

#!/usr/bin/perl -w

use strict;
use List::Util; #for the max function

my @numbers = qw( 10 4 7 2 5 8 1 3 11);
my $highest=$numbers[0]; # Initialise this for case of all negatives

 for (my $i = 1; $i < @numbers; $i++)    {

       if ($numbers[$i] > $highest)     { #compare to the previous hig
+hest

             $highest = $numbers[$i];
          }

  }

print "\$highest is $highest\n";

#now use List::Util::max

print "Max is ", List::Util::max(@numbers),"\n";
[download]

There are a couple of problems with your code.

By looking at $numbers[$i+1], you're going to be reading past the end of the array... Not really a serious problem in perl, but something to keep in mind. You're also skipping element 0 in the array.

You'll also mark as highest any value that's followed by a lower number. So if @numbers is (1,0,100,0,2,0), you'll get 2 instead of 100.

You should be comparing $numbers[$i] with the highest value you've seen so far.

# we assume numbers was set up somewhere above...
my $highest;
# we'll get undef if @numbers is empty
$highest=$numbers[0] if @numbers;
for(my $i=1; $i<@numbers; $i++) {
    if($numbers[$i]>$highest) {
        $highest=$numbers[$i];
    }
}
print $highest;
[download]

@stuff = ( 90, 5, 4 );
[download]

my $highest = 0;
foreach my $element ( @numbers ) {
   $highest = $element if $element > $highest;
}
print $highest;
[download]

Simply compare $numbers[$i] with $highest rather than $numbers[$i+1], initializing $highest = $numbers[0] (outside of the for).

Hope this helps, -gjb-

if (scalar(@numbers) > 0) {
  # compare only when array has entries
  my $highest = $numbers[0]; # set startvalue
  foreach my $compNum (@numbers){
    # compare all numbers in array
    $highest = $compNum if ($compNum > $highest);
  }
} else {
  # nothing to compare
}
[download]