A recursive subroutine is a subroutine which contains calls to itself. 
It is often used for computing numbers from a series. A call with an 
argument $n would then result in an internal call to the same subroutine
but with argument $n-1.

For example, if we try to solve the task "compute 2*$n without using the
multiplication operator for $n>0" we could solve it like this:

   my $answer = &compute($n);

   # definition of the recursive subroutine compute
   sub compute {
      # get the input argument
      my $n = shift(@_);
      # define the answer for the extreme value (in this case the lowest: 1)
      if ($n == 1) { return(2); }
      # define the answers for other values by a recursive call
      else { return( 2+&compute($n-1) );
   }

We can test the program for a few numbers to see that it is correct. 
If we call it with $n=1 then the if statement will succeed and we will
have 2 as an answer, which is correct. For $n=2, the result will be
2+&compute(2-1). The value of the latter is 2 so the answer for $n=2 
is 4, which is also correct. And for $n=3, we obtain 2+&compute(3-1) 
which results in 2+4=6, which is also correct.

The program computing the Padovan sequence should have the same 
structure as the example program. It should contain a subroutine
with definitions for the extreme values ($n in (0,1,2)) and a recursive
call for other values. Additionally the program should read $n from
the command line arguments (with shift() applied to @ARGV) and print
the result of the computation.

Challenge: the standard way to implement the subroutine would be to
use two recursive calls, one for $n-2 and one for $n-3. This generates
some overhead since &compute($n-3) would be computed twice: once in the 
first call and once in the second call. It is possible to create a more 
efficient program by making the subroutine returning not only the
Padovan number of $n but also that of $n-1 and $n-2, and use these
values in the computation. If you would like to do a bit more of 
problem solving, you can try implementing the subroutine with only 
one call to itself.