if you want to print the contents of an array just do:

my @array = (1,2,3);
print join(',', @array);
[download]

in the code you posted try replacing

print "@$_\n", [ @$included, $nextValue ]
[download]

Edit:btw, your code does not return anything in @results. Instead of printing inside your sub, try pushing each new result to the @results array by replacing said print statement with push(@results, [ @$included, $nextValue ]). Then at the end of your code (after Solve() returns) do  print join(",", @$_)."\n" foreach @results

I was wondering what @$_ in print "@$_\n", [ @$included, $nextValue ] was all about...

      ...

      } else {
        print join(',', @$included, $nextValue), "\n"
            if $currentGoal == $nextValue;
        return if $nextValue >= $currentGoal;
      }
      ...
[download]

      ...

      } else {
        if ($currentGoal == $nextValue) {
          print join(',', @$included, $nextValue), "\n";
          push @results, [@$included, $nextValue];
        }
        return if $nextValue >= $currentGoal;
      }
      ...
[download]

Hi, Perl provides strictures and warnings to point out problems with your code. If you had enabled them you would have been pointed to the source of your problem immediately. See Basic debugging checklist Item 1.

After adding

use strict;
use warnings;
[download]

Can't use an undefined value as an ARRAY reference at 1228495.pl line 
+24.
[download]

 print "@$_\n", [ @$included, $nextValue ]
[download]

Hope this helps.

 } else {
        # print "@$_\n", [ @$included, $nextValue ]
        local $, = q(, );
        print  @$included, $nextValue, "\n" 
            if $currentGoal == $nextValue;
        return if $nextValue >= $currentGoal;
      }
[download]

It seemed a little long, so I just tweaked it a tiny bit :)

#!/usr/bin/perl

# https://perlmonks.org/?node_id=1228495

use strict;
use warnings;

my @results = Solve(869,
  [15, 43, 51, 56, 60, 67, 122, 152, 193, 204, 229, 271, 293, 301] );
print "@$_\n" for @results;

sub Solve
  {
  my $want = shift() or return [];
  $want > 0 or return ();
  my ($first, @rest) = @{ shift() } or return ();
  map([$first, @$_], Solve($want - $first, \@rest)), Solve($want, \@re
+st);
  }
[download]

Outputs:

15 43 51 56 60 122 229 293
15 43 51 56 204 229 271
15 43 51 67 193 229 271
15 43 51 122 152 193 293
15 56 60 67 122 152 193 204
15 56 60 122 152 193 271
15 56 204 293 301
15 67 193 293 301
43 51 56 67 122 229 301
43 51 56 67 152 229 271
43 51 60 193 229 293
43 122 204 229 271
56 60 67 122 271 293
56 67 152 293 301
[download]

It does look more elegant and compact, but it's significantly slower:

$ perl ./thescript
Benchmark: timing 1000 iterations of orig, tybalt89...
     orig:  3 wallclock secs ( 2.48 u + 0.00 s =  2.48 CPU) @403.23/s (n=1000)
 tybalt89: 10 wallclock secs (10.22 u + 0.00 s = 10.22 CPU) @ 97.85/s (n=1000)

Read more... (2 kB)

There are a few responses to this post, but what I'd like to see, is a response with the full code body.

Can you do that guys?

I can run the code, even under strict/warnings, but I see sticky things, like the lack of the instantiation variable in the for loop for example. Typically, we don't use C-style for() loops in Perl code unless under duress, or weird circumstances. There are a couple of other smaller things, but I digress.

Anyone willing to post the full code that they have that got this to work, with the actual output from OPs example?

Here's pme's changes as the whole script.

use strict;
use warnings;

sub Solve {
    my ( $goal, $elements ) = @_;
    my ( @results, $RecursiveSolve, $nextValue );
    $RecursiveSolve = sub {
        my ( $currentGoal, $included, $index ) = @_;
        for ( ; $index < @$elements ; ++$index ) {
            $nextValue = $elements->[$index];
            if ( $currentGoal > 2 * $nextValue ) {
                $RecursiveSolve->(
                    $currentGoal - $nextValue,
                    [ @$included, $nextValue ],
                    $index + 1
                );
            }
            else {
                if ( $currentGoal == $nextValue ) {
                    #print join( ',', @$included, $nextValue ), "\n";
                    push @results, [ @$included, $nextValue ];
                }
                return if $nextValue >= $currentGoal;
            }
        }
    };
    $RecursiveSolve->( $goal, [], 0 );
    undef $RecursiveSolve;    # Avoid memory leak from circular refere
+nce
    return @results;
}

my @results = Solve( 869,
    [ 15, 43, 51, 56, 60, 67, 122, 152, 193, 204, +229, 271, 293, 301 
+] );

foreach my $result (@results) {
    print join(',',@$result),"\n";
}
[download]

Absolutely brilliant!

++ and kudos for denoting a circular reference :)

OK stevieb, here is the original OP code with only the print statement corrected as described in my first post. A sample execution demonstrates that the expected output is produced.

>type pviki.pl
use strict;
use warnings;
 sub Solve
{
  my ($goal, $elements) = @_;

  # For extra speed, you can remove this next line

  my (@results, $RecursiveSolve, $nextValue);

  $RecursiveSolve = sub {
    my ($currentGoal, $included, $index) = @_;

    for ( ; $index < @$elements; ++$index) {
      $nextValue = $elements->[$index];
      # Since elements are sorted, there's no point in trying a
      # non-final element unless it's less than goal/2:
      if ($currentGoal > 2 * $nextValue) {
        $RecursiveSolve->($currentGoal - $nextValue,
                          [ @$included, $nextValue ],
                          $index + 1);
      } else {
         #print "@$_\n", [ @$included, $nextValue ]
         local $, = q(, );
         print  @$included, $nextValue, "\n"
            if $currentGoal == $nextValue;
        return if $nextValue >= $currentGoal;
      }
    } # end for
  }; # end $RecursiveSolve

  $RecursiveSolve->($goal, [], 0);
  undef $RecursiveSolve; # Avoid memory leak from circular reference
  return @results;
} # end Solve


my @results = Solve(869, [15, 43, 51, 56, 60, 67, 122, 152, 193, 204,
+229, 271, 293, 301]
);


>perl pviki.pl
15, 43, 51, 56, 60, 122, 229, 293,
15, 43, 51, 56, 204, 229, 271,
15, 43, 51, 67, 193, 229, 271,
15, 43, 51, 122, 152, 193, 293,
15, 56, 60, 67, 122, 152, 193, 204,
15, 56, 60, 122, 152, 193, 271,
15, 56, 204, 293, 301,
15, 67, 193, 293, 301,
43, 51, 56, 67, 122, 229, 301,
43, 51, 56, 67, 152, 229, 271,
43, 51, 60, 193, 229, 293,
43, 122, 204, 229, 271,
56, 60, 67, 122, 271, 293,
56, 67, 152, 293, 301,
[download]

Bill

I cleaned up the code to where it can recurse in a single sub, and a few other tweaks that make it a little faster. Here's a speed comparison:

$ perl ./script
Benchmark: timing 5000 iterations of new, orig...
       new: 11 wallclock secs (10.03 u +  0.00 s = 10.03 CPU) @ 498.50/s (n=5000)
      orig: 11 wallclock secs (10.98 u +  0.00 s = 10.98 CPU) @ 455.37/s (n=5000)