Hi, my first advice would be: take a break (honestly). You describe the symptoms of code blindness.

Then, you should listen to what use strict; use warnings; is telling you: Useless use of private variable in void context at yourfile.pl line 30. - that's a starting point. Maybe something is missing there? If your loop does not finish (runs 5 million times), then maybe the end-condition is not met? Why? Is it the condition itself? Is it something with the loop variable? What is the concrete name of the loop variable? Where is it modified? Is it modified during each iteration of the loop?

I hope, that answering theses questions gives you enough of a push - as requested.

Update/comment: By setting $i=0; you already proved you know array indices start at 0. That is not the problem here...

Your problem is that $i is only changed if $answer eq $numbers[$i]. You need to increment $i all the time. Or better, use a hash:

#usr/bin/perl
use strict;
use warnings;

my %numbers = qw(
    0 zero
    1 one
    2 two
    3 three
    4 four
    5 five
    6 six
    7 seven
    8 eight
    9 nine
    );

print "Enter a number\n";
chomp( my $input = <STDIN> );
print $numbers{ $input } if exists $numbers{ $input };
[download]

 while ($answer <= 9) {
    if ($answer eq $numbers[$i]) {
        $answer = $words[$i];
        $i++;
        $answer;
                
    } else {
        #print $answer;
    } # end if

 } # end while
[download]

Well, $answer here is a word like "eight", and the problem with the loop condition is that you cannot numerically compare "eight" to 9.

OK, let me give you a hint: When the user inputs 8, you want to print $words[7], don't you? Notice that 7 is 8-1? ;)

Two tips that should help a lot.

$answer is used to hold the input, the loop counter and the result? yow! Start by using separate variables for these things.

Consider using for instead of while, since you're looping over the indexes of an array. Actually, consider using the input as an index into the array and eliminating the loop altogether.

Minor but important note: the shebang at the top of your script needs to be

#!/usr/bin/perl
[download]

instead of the '#usr/bin/perl' or '#!usr/bin/perl' as you have it in the above scripts. Your version will work in, say, Windows (which ignores the shebang, although it honors any switches present on the shebang line), but would fail on a Unix box.

-- 
Human history becomes more and more a race between education and catastrophe. -- HG Wells

Yes, the second one had it correctly, the first was a mistake, I'm on linux. Thanks for the input, though..it's always good to know the details you've missed :)

#!/usr/bin/perl
my @list=(qw/zero one two three four five six seven eight nine/);
print "give the input:";
my $in=<STDIN>;
print "$list[$in]\n";
[download]

You have a problem if $in is 75, -8, or Platypus.

Defensive programming is good programming!

Wow++, very nice ;) I learn something new with every reply, or rather, I guess, a new way of approaching the problem. I appreciate that, from all of the Monks, because it broadens not just my knowledge, but my perspective, which enables me to begin to design my programs more efficiently. Anyone can study a bit and write some code, it's being able to design the structure of it to do what is needed well, not just to do what is needed, that begins to breed a truly talented programmer . Thank you so much for furthering my ability to learn how to do just that :)

Also, remember that array indices in Perl start at.... 0. On second look, the indexing looks OK. But tracking parallel arrays can get hairy when they need to be updated. jwkrahn's suggestion to use a hash avoids that problem.

It's easy to use, just start all your programs with

use strict;
use warnings;
use diagnostics;
[download]

Normally, I remove my .sig when I don't think it's relevant, but for this post I'll leave it alone.

OK, so the hash is the most general approach -- and as brother/sister zentara remarks, once you see how many things you can do with them, you wonder how you ever coped without.

In this special case, as brother/sister llancet points out, you could simply use an array, because Perl treats strings which contain digits as numbers (and vice versa).

So much for the wonderous ways of Perl.

From a general programming perspective however, you should worry whether the inputs are valid, especially where a human is involved, as brother/sister apl points out. So your conversion subroutine, whatever its mechanics, ought to check that its input is something it can cope with, and your program needs to be arranged to deal with out of spec input.

I just wanted to stress that, while the coding issues are interesting -- and Perl has its own little ways -- the art of programming is more than coding.