if ($card_map[$num]) {
    $card_map[$num]; # return value

 } else {
    $num; # return value

 } # end if
[download]

Here is (one of your) problem(s).

$num will only be returned if you either write return $num, or if it's the last statement in your sub, which it isn't.

Also note that $card_map[$num] will return something for negative values of $num, (in that case it counts the index from the back of the array):

$ perl -wle 'my @card_map = qw(zero one two three); print $card_map[-2
+]'
two
[download]

So you most likely need something like this:

my $return_value = '';
if ($num < 0) {
     $return_value = $negative;
     # continue with the positive value from here on
     $num = -$num;
}

# and append other results here:

$return_value .= $card_map[$num];
return $return_value;
[download]

(I'm also quite sure that you should forget about local for now, and work with my).

This is a good opportunity to learn unit testing with Test::More et.al. :

# 718965.pm

use strict;
use warnings;

my @card_map = qw(zero one two three four five six seven eight nine);

sub card {
  my $num = shift;
  my $negative = "negative";

  if ($card_map[$num]) {
    return $card_map[$num];
  } else {
    return $num;
  }

  if ($num > 0) {
    return $num = -$num;
  }   

  if ($card_map[$num]) {
    return $negative . $card_map[$num];  
  } else {
    return $negative . $num;              
  }   
}   

use Test::More;
plan tests => 3;

is(card(5), 'five', 'Expect card(5) to return "five"');
is(card(6), 'six', 'Expect card(6) to return "six"');
is(card(-6), 'negative six', 'Expect card(-6) to return "negative six"
+');

__END__

$ prove 718965.pm
718965....NOK 3
#   Failed test 'Expect card(-6) to return "negative six"'
#   at 718965.pm line 32.
#          got: 'four'
#     expected: 'negative six'
# Looks like you failed 1 test of 3.
718965....dubious
        Test returned status 1 (wstat 256, 0x100)
DIED. FAILED test 3
        Failed 1/3 tests, 66.67% okay
Failed Test Stat Wstat Total Fail  Failed  List of Failed
----------------------------------------------------------------------
+---------
718965.pm      1   256     3    1  33.33%  3
Failed 1/1 test scripts, 0.00% okay. 1/3 subtests failed, 66.67% okay.
[download]

• Lingua::EN::Numbers
• Lingua::EN::Numbers::Ordinate
• Lingua::EN::Words2Nums

People often try to overthink a problem. Since you're new to programming, you probably don't fully appreciate that simplification gives clarity. Use as few logical steps as necessary, and remove any clutter as you go along. Here's some tips:

sub card {

my @card_map = qw(zero one two three four five six seven eight nine);

# these aren't used, so they should be removed
my $guess;
my $i = 0;

# there is no need for these vars to be global:
our $num;
our $negative = "negative";

# declare them as lexicals instead
my $num;
my $negative = "negative";

# declaring $num as lexical you don't need to localize:
local($num) = @_;

# this works here, but do you really understand what its doing?
# hint: list context
my ($num) = @_;

# this is better
my $num = $_[0]:

# or this:
my $num = shift @_;

# commonly shortened (@_ is implicit) to:
my $num = shift;

# for the rest, notice how much simpler the logic
# is in moritz reply above

# so putting it all together:
sub card{

    my $num = shift;
    my $negative = "negative";
    my @card_map = qw(zero one two three four five six seven eight nin
+e);
    my $return_value;

    if ($num < 0){
        $num = -$num;
        $return_value = $negative;
    }

    $return_value .= "$card_map[$num]";
    return $return_value;
}

# and simplified further:
sub card{

    my $num = shift;
    my @card_map = qw(zero one two three four five six seven eight nin
+e);

    if ($num < 0){
        $num = -$num;
        return "negative $card_map[$num]";
    }
    return $card_map[$num];
}
[download]

Update: corrected typo

Good first attempt!

Here's my version:

sub card {
  my $num = shift;
  my $result;
  my @card_map = qw(zero one two three four five six seven eight nine)
+;
  
  if ($num < 0) { 
    $result .= "negative ";
    $num = -$num;
  }
  
  if ($card_map[$num]) {
    $result .= $card_map[$num];
  } else {
    $result .= $num;
  }
  
  return $result; 
}
[download]

The code works, however my output isn't what it should be.

We could get pedantic and look at the word "compiles," too.

I personally believe that "simplicity is the ultimate sofistication" (Cit.) - indeed I had serious difficulties wandering through your code to understand what it does. Said this, and having seen code from others in this thread too, I think that your sub may be made just as simple as:

{
    my @card_map = qw(zero one two three four five six seven eight nin
+e);

    sub card {
        my ($n, $pre) = map { $_< 0 ? (-$_, 'minus ') : ($_, '') } shi
+ft;
        $pre . ($card_map[$n] // $n);
    }
}
[download]

Here, I preferred to move @card_map out of the sub because I see no point assigning to it each time the sub is called. (I also changed "negative" to "minus" which I think is proper English.)

Update: Limbic~Region /msg'd me to point out that probably "it will be a while before state declared variables become common place due to compatability issues but that would be his preference here." Indeed, he's right, and I'm using 5.10.0's // (although in this case || would suffice) under use 5.010 anyway, so I thought that for completeness I may rewrite the sub in that form as well:

This actually led me to discover something that I and appearently Limbic~Region didn't even remotely suspect, but is well documented in perldoc perlsub:

When combined with variable declaration, simple scalar assignment to state variables (as in state $x = 42 ) is executed only the first time. When such statements are evaluated subsequent times, the assignment is ignored. The behavior of this sort of assignment to non-scalar variables is undefined.

Well, to be very fussy, the documentation is not entirely consistent with the implementation since the former says that the behaviour of the assignment is "undefined" whereas the latter strictly prohibits it - and I checked, to be sure, that it is not a strict thing: even if you don't use it, compilation fails.

#! /bin/perl -w

use strict;

&routine(7);

sub routine{
   my $array_length=@_;
   my ($value)=@_;
   my $specific_value=$_[0];
   print "This function was called with $array_length argument(s) and 
+a value of $value\n the value can also be accessed from the array dir
+ectly and returns $specific_value\n";
}
[download]

Thank you very much, Monks. The examples of code really helped point out some seemingly obvious mistakes, however, after spending two days staring at code, and half of that time de-bugging the part you think you can "get", your vision becomes decidedly unclear :\

I know I still have quite a bit to learn, and please understand, that being able to de-bug my code efficiently, on my own, is a skill I am strongly striving for, yet apparently very far away from reaching...which is just as annoying as the problem itself, if not more so. I thought the ability to code would be the big hump, however, it seems as though the ability to be able to spot one's own mistakes is the real battle. However, every time ya'll help point things out to me, I do get closer to that point, it just seems as though the road is incredibly long at this level of understanding.

I thank all of you for your time, attention, code examples and the push each reply gave me towards achieving the ability to see my own mistakes. Of course further in my venture I will want to for see them before they are made, but wow, let's not get too far ahead of ourselves on that one! :)

koolgirl,
One of the most effective things you can do to quickly identify and resolve issues with your code is by adopting a consistent methodology to writing the code in the first place. For that, I would recommend reading what I wrote at Re: Refactoring a large script. If you can avoid introducing the bug then you don't have to spend time fixing it.

When you do need to start bug hunting, many people like brian's Guide to Solving Any Perl Problem. I personally have my own approach which I haven't bothered to document. Often times the biggest help is being able to visualize what's going on - How can I visualize my complex data structure?.

Again, I have my own approach but one common technique I employ is generously sprinkled print statements. If you have addressed all the issues raised by strictures and warnings but your code is still not producing the correct output, find out where your assumptions failed using the bi-section method. Pick some point in the middle of the execution of your code to output the values of your data up to that point. It doesn't matter if all the values are right or wrong - you have eliminated half of your code as being the source of the problem. Either pick the middle execution point before or after (depending on the correctness of the data values) and wash/rinse/repeate the process.

Cheers - L~R