Trying to print one element of an array somehow prints all elements - arrays

Question

I am writing a script to take a list of integers from file aryData, sort them, print the sorted array, the highest value, and the lowest value.
aryData
89 62 11 75 8 33 95 4
But when printing the highest or lowest value, all elements of the array are printed.
This is my Perl code
#!/bin/perl
use strict;
use warnings;
print "Enter filename to be sorted: ";
my $filename = <STDIN>;
chomp( $filename );
open( INFILE, "<$filename" );
my #nums = <INFILE>;
close INFILE;
my #sorted = sort { $a cmp $b } #nums;
open my $outfile, '>', "HighLow.txt";
print $outfile "Sorted numbers: #sorted";
print $outfile "Smallest number: $sorted[0] \n";
print $outfile "Largest number: $sorted[-1] \n";
output HighLow.txt
Sorted numbers: 89 62 11 75 8 33 95 4
Smallest number: 89 62 11 75 8 33 95 4
Largest number: 89 62 11 75 8 33 95 4

Answer 1

This answer will have a large portion of code review and explain concepts that are not directly related to the question.
Let's look at the part of your code that reads in the array.
open(INFILE, "<$filename");
my #nums = <INFILE>;
close INFILE;
This code is fine for what you are doing, but it has a few security and style issues that I will get into further below.
So you have a file name, and you read in a file line by line. Each line goes into one element in the array #nums. Since your stuff is not working the way you want, the first step you need to take to debug this is to try to look at the array.
Your attempt to do this was not a bad idea.
print "Sorted numbers: #sorted";
Interpolating an array in a double quoted "" string in Perl joins the the elements of the array with the variable $,, which is also known as the output field separator. By default, it's a blank space .
my #foo = (1, 2, 3);
print "#foo";
This will give the following output
1 2 3
Unfortunately your input file already had spaces as separators, and all numbers were on one line. So you couldn't really see that the array wasn't properly set up. That's one of those facepalm moments when you notice it yourself. You could have noticed it by looking at the sorted numbers. You did sort them, but they were not sorted.
Sorted numbers: 89 62 11 75 8 33 95 4
A better way to figure out what's in the array would be to use Data::Dumper, which lets you serialize data structures. It's included with Perl.
use Data::Dumper;
my #foo = (1, 2, 3);
print Dumper \#foo;
The module gives you a Dumper function. It likes works better on references, so you need to add the backslash to create a reference to #foo. What that means exactly is not relevant at this point. Just remember that if your variable does not have a $, you put a backslash in front.
$VAR1 = [
1,
2,
3
];
This is useful. It tells us the three elements. Now lets look at your code. Instead of an actual file, I am using the pseudo-filehandle DATA, which reads from the __DATA__ section at the end of the program. This is great for testing and for examples.
use Data::Dumper;
my #nums = <DATA>;
my #sorted = sort { $a cmp $b } #nums;
print Dumper \#sorted;
__DATA__
89 62 11 75 8 33 95 4
This prints
$VAR1 = [
'89 62 11 75 8 33 95 4
'
];
We can see two things here. First, all numbers are on one line, and thus they went into the first element. Second, the line has a newline at the end. You already know that you can remove that with chomp.
So lets try to fix this. We now know that we need to split the line of numbers. There are many different ways to accomplish this task. I will go with a very verbose one to explain the steps involved.
use Data::Dumper;
my $line = <DATA>; # only read one line
chomp $line; # remove the line ending
my #nums = split / /, $line;
my #sorted = sort { $a cmp $b } #nums;
print Dumper \#sorted;
__DATA__
89 62 11 75 8 33 95 4
We use split with an empty pattern / / to turn the string of numbers into a list of numbers, and put that in an array. Then we sort.
$VAR1 = [
'11',
'33',
'4',
'62',
'75',
'8',
'89',
'95'
];
As you can see, we now have a sorted list of numbers. But they are not sorted numerically. Instead, they are sorted asciibetically. That's because cmp is the operator that sorts by ASCII character number. It's also the default behavior of Perl's sort, so you could have omitted that whole { $a cmp $b } block. It's the same as just saying sort #nums.
But we want to sort numbers by their numerical value, so we need to use the <=> sorting operator.
use Data::Dumper;
my $line = <DATA>; # only read one line
chomp $line; # remove the line ending
my #nums = split / /, $line;
my #sorted = sort { $a <=> $b } #nums;
print Dumper \#sorted;
__DATA__
89 62 11 75 8 33 95 4
Now the program prints the right output.
$VAR1 = [
'4',
'8',
'11',
'33',
'62',
'75',
'89',
'95'
];
I'll leave it to you to put this back into your actual program.
Finally, a word about your open. You are using what's called glob filehandles. Those things like INFILE are global identifiers. They are valid throughout your program, even in other modules that you might load. While in this tiny program that doesn't really make a difference, it might cause problems in the future. If for example the Data::Dumper module was to open a file and use the same identifier INFILE, and you had not called close INFILE, your program might either crash or do very weird things, because it would reuse the same handle.
Instead, you can use a lexical file handle. A lexical variable is only valid inside of a certain scope, like a function or the body of a loop. It's just a regular variable, declared with my. It will automatically call close for you when it goes out of scope.
open my $fh, "<foo";
my #nums = <$fh>;
close $fh;
You are calling open with two arguments. That's also not a good idea. Right now you have the mode <, but if you leave that out and do open my $fh, "$file" and read the $file from the user, they might pass in bad things, like | rm -rf slash. Perl will then treat the pipe | as the mode, open a pipe and delete all your stuff. Instead, use three-argument open.
open my $fh, '<', 'foo';
Now that you explicitly set the mode, you're safe.
The last point is that you should always check if open worked. That's easy.
open my $fh, '<', 'foo' or die $!;
The variable $! contains the error that open encountered. The or will only trigger if the return value of the open call was false. And die makes the program terminate. The error you might receive could look like this.
No such file or directory at /home/foo/code/scratch.pl line 6154.
So the full file reading should look something like this.
open my $fh, '<', $filename or die "Could not read $filename: $!";
my #nums = <$fh>;
close $fh;

Answer 2

As you've seen from the comments, the problem here is that you don't populate your array correctly. You end up with only one element in #nums - it's a single element that contains all of your data.
You could confirm that by using something like Data::Dumper, which... er... dumps your data :-)
At the top of your program, just after the use warnings; you can add this:
use Data::Dumper;
Then after you have loaded up #nums, try dumping it:
print Dumper(\#nums), "\n";
You'll see this:
$VAR1 = [
'89 62 11 75 8 33 95 4
'
];
Compare that to what you see when we fix your problem and you'll see an obvious difference.
So we have a line of data that contains the numbers you're interested in separated by spaces. To convert that into a list of numbers which we can store in your array, we can use the split() function. split() takes two arguments - a regular expression to split the string on, and the string to split.
You have this code to read from the file and assign to your array:
my #nums = <INFILE>;
You can replace that with:
my #nums = split / /, <INFILE>;
Now our data dump looks like this:
$VAR1 = [
'89',
'62',
'11',
'75',
'8',
'33',
'95',
'4
'
];
I hope the difference is obvious. Your program basically works at this point, but we can clean things up a bit by dealing with the new-line at the end of the record in the file (you can see it after the 4 above).
We'll need to split the line into two.
chomp(my $input = <INFILE>);
my #nums = split / /, $input;
Now our data dump looks like this:
$VAR1 = [
'89',
'62',
'11',
'75',
'8',
'33',
'95',
'4'
];
At this point, your program still has a bug left in it. I'm going to leave that for you to investigate (hint: what does sort() actually do? Read the documentation) - if you have more problems, please ask another question.
But I'd like to finish by suggesting some improvements to your general coding style. I'm not sure where you're learning Perl from, but some of the stuff you're doing looks pretty dated.
When you open a file in Perl, you should always check the results from your call to open and take appropriate action if it fails. In many cases, killing the program is the appropriate action, so I'd use die() in your open statement.
open( INFILE, "<$filename" )
or die "Can't open $filename: $!\n");
The $! in the error message will tell you why Perl couldn't open the file.
It's also regarded as best practice these days to avoid "bareword filehandles" (like your INFILE) and also split the file name from the mode indicators (> or <). Putting that all together, your file handling code becomes:
open( my $in_fh, '<', $filename )
or die "Can't open $filename: $!\n";
chomp(my $input = <$in_fh>);
my #nums = split / /, $input;
close $in_fh;
I see you are already using this style for the output file. Seems strange to mix the styles within the same program.

Answer 3

Maybe You can try this to find out the max and min:
#a=qw(1 3 2 8 7 5 4 10 9);
#a=sort {$a<=>$b}#a;
print "the max number=$a[0]\nthe min number=$a[$#a]\n";