if(defined $cache[$num]) {return $cache[$num];}
if($num < 0) {return 0;}
[download]

In Perl, -1 is a valid array index, meaning the last element of the array (-2 is the second-to-last, and so on). Move the if($num < 0) check before the if(defined $cache[$num]) check and your code produces the expected output. Another option would be to use a hash instead of an array as the cache.

A couple more tips:

• Instead of a global, you could define your cache as what is known as a "static" variable in other languages, using state.
• Update: While implementing the cache yourself like that is fine, note that Perl has a module for that, Memoize.
• The &find() style of calling subs is outdated, call your subs without the &.
• The if($num == 0) check isn't necessary if you pre-populate your array with that index.
• You can use Test::More instead of inputting your test cases manually:

use warnings;
use strict;
use feature 'state';

sub find {
    state @cache = (1);
    my $num = shift;
    return 0 if $num < 0;
    if ( defined $cache[$num] ) { return $cache[$num] }
    $cache[$num] = find($num-1) + find($num-2) + find($num-3);
    return $cache[$num];
}

use Test::More tests=>3;
is find(2), 2;
is find(3), 4;
is find(4), 7;
[download]

It was helpful. Thank you

Ehm... If you accept 3 in list of answers for input "3", then there should be 4 in list for "4", then total count for the latter would be 8, not 7. In fact, said count is equal 2**(N-1), rather than Tribonacci sequence with whatever initial triplet as your code implies.

Visualize it this way: there are N ones 1,1,1,.... You insert any number of pluses in between and perform these additions to get partial answer. So, emit all subsets of all positions, it should be clear enough. I'd NOT recommend to submit code below if this is HW assignment. Result is correct, algo is kind of joke.

use strict;
use warnings;
use Algorithm::Combinatorics 'subsets';

$" = ' + ';
use constant N => 5;
my $i = subsets [ 1 .. N - 1 ];

while () {
    my $s = '1,' x N;
    substr $s, 2 * $_ - 1, 1, '+'  
        for @{ $i-> next or last };
    print eval( $s = "@{[ eval $s ]}" ), 
        " = $s\n";
}

__END__

5 = 5
5 = 1 + 4
5 = 2 + 3
5 = 1 + 1 + 3
5 = 3 + 2
5 = 1 + 2 + 2
5 = 2 + 1 + 2
5 = 1 + 1 + 1 + 2
5 = 4 + 1
5 = 1 + 3 + 1
5 = 2 + 2 + 1
5 = 1 + 1 + 2 + 1
5 = 3 + 1 + 1
5 = 1 + 2 + 1 + 1
5 = 2 + 1 + 1 + 1
5 = 1 + 1 + 1 + 1 + 1
[download]

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11114280
use warnings;
use List::Util qw( uniq );

my @cache = [];

for my $n ( 3 .. 4 )
  {
  print "$_\n" for sort @{ find($n) };
  print "\n";
  }

sub find
  {
  my $n = shift;
  $cache[$n] //= [ uniq $n, map { my $nn = $_;
      map { my $t = $_; map "$t+$_", @{ find($nn) } } @{ find($n - $nn
+) }
      } 1 .. $n - 1 ];
  }
[download]

Outputs:

1+1+1
1+2
2+1
3

1+1+1+1
1+1+2
1+2+1
1+3
2+1+1
2+2
3+1
4
[download]

You describe the output for a single number as input, but your program reads two numbers from <>. The intention is not clear to me.

Don't know if this is related to your problem.

your program reads two numbers from <>. The intention is not clear to me.

It's pretty common on sites like HackerRank etc. to have the solutions first read in the number of test cases, and then read in each test case.