Now let's do this in Perl:

# First make the program know the two numbers:
$Number1 = 48;
$Number2 = 12;

# Now divide the numbers:
$Result = $Number1 / $Number2;

# ...and look if we got a decimal:
[download]

# Using your sub
is_integer_string($Result)

# Look for a .
$Result =~ /\./;

# Check if the number is the same as its integer part:
$Result == int($Result)
[download]

if (condition) { print "Yes"; } else { print "No"; }
[download]

Regarding your subroutine... I think it won't work as you expect: Leaving the \s* alone, you're matching a + sign followed by zero or one - sign followed by numbers. +3 matches, but the string representation of a number doesn't include a leading + in Perl. Better to put [] around the \+ and \- (and keep the ?). This will match either a -, a + or nothing before the number.
Perl could do a good part of the job for you if you want to match using a regexp:

sub is_integer_string {
 my $N = $_[0] + 0;
 return $N =~ /^\-?\d+$/;
}
[download]

Update: Just noticed JavaFan's comment and he's right: modulo is the quickest way to do it, but all the others shown here also work.

1.2e40 is an integer as well, and does contain a dot in stringified form.

The . - test is ok for beginners who are doing their first programming steps, but I agree that it isn't good for productional software.
Besides the module way, I prefer the $X == int($X) - which also works for 1.2e40

$_[0] =~ /^\s*\+\-?\d+\s*$/
[download]

In a scalar context it returns the number of matches.

Therefore as the regex is anchored start and end, if the supplied string is an integer the regex returns 1 otherwise 0, which are evaluated as true and false. Thus the above routine could be employed as follows

if (is_integer_string($input){
   do_integer_function($input);
}
else{
   die "You must supply an integer\n";
}
[download]

Hope that clarifies.

This is my first experience with subroutines ever, and I'm straight up confused.

Ok, so you were sick the day they covered subroutines, I'll try to clear them up a bit. You were given a subroutine with some commonly used shortcuts. Here's a different example broken down into four versions that do exactly the same thing.

# calling the subroutine. in this example the
# first arg is a variable, second is a literal value
my $arg1 = 100;
my $return_value = add_these($arg1, 200);

print $return_value;

# subroutines receive arguments via an array named @_
# this version gets the args by array index
sub add_these{
    my $first = $_[0];
    my $second = $_[1];
    my $answer = $first + $second;
    return $answer; 
}

# this one shifts values off the front of the array 
# note that @_ is implied if an array is not given as 
# the argument to shift. commonly seen as:
# my $value = shift; 
sub add_these{
    my $first = shift @_;
    my $second = shift @_;
    my $answer = $first + $second;
    return $answer; 
}

# as shown here it is not necessary to assign the 
# arguments to an intermediate variable - you can
# use them directly (however the extra variables
# often makes the code more readable)
sub add_these{
    my $answer = $_[0] + $_[1];
    return $answer; 
}

# you don't even need to return a variable, you can 
# directly return the value calculated by an expression,
# as shown here and in the "hint" example you were given
sub add_these{
    return  $_[0] + $_[1];  
}
[download]

As for the multiples problem, you're looking for a boolean (true/false) value, represented as true = 1, false = 0. So your subroutine would determine if the arguments were multiples and return 1 if they are, 0 if they're not. And yes, use an if statement, (and the modulo operator as others suggested). There are other ways to do it, but no sense getting fancy till you have a handle on the basics.

I think JavaFan had it right but I didn't notice, since his reply didn't have code, till I wrote some. So…

while ( <DATA> )
{
    chomp;
    my ( $first, $second ) = split;
    print
        "$first:$second --> ",
        multiple($first,$second) ? "yes" : "no",
        "\n";
}

sub multiple {
    my ( $one, $two ) = @_;
    ! ( $one > $two ? $one % $two : $two % $one );
}

__DATA__
1 2
2 3
3 9
9 3
11 7
2 108
4 4
[download]

Thanks guys. I finally got a chance to work on this.

I just did the modulus route and it works. I had a somewhat of a basic clue of what to do, just needed an extra push.

I agree though, I don't think a subroutine is necessary for this program. I need to look more into this modulus operator, it seems nifty. My first try resulted in a incorrect answer. It said that it was a multiple, even though the quotient was .5 (2 / 4), and when it said it wasn't a multiple when the quotient was 4 (48 / 12) I fixed it by flipping the operands. Just was an unexpected result. Something to research for sure.

Anyways, thanks again guys.