->a{(1..a.size).flat_map{|n|a.sort.combination(n).select{|c|c.reduce(:+)==10}.uniq}}

(1..a.size)              # Для диапазона от 1 до длины массива А
  .flat_map{ |n|         # ...сконкатенировать для каждого следующее (где N текущее):
    a.sort               #   Из отсортированного массива А...
     .combination(n)     #   ...взять все комбинации длиной N элементов
     .select{ |c|        #   ...выбрав только те из них (где С текущее), в которых:
       c.reduce(:+)==10} #     Cвёртка С сложением равна 10.
     .uniq}              #   ...убрав повторения.

c[]=[[]]
c(x:l)=c l++[x:r|r<-c l]
g n l=nub$filter((n==).sum)$c$sort l

c [] = [[]]
c (x:l) = c l ++ [ x:r | r <- c l ]
g n l = nub $ filter (x -> sum x == n) $ c $ sort l

sub X{my($n,%r)=pop;@_=sort@_;map{my$c=pop;$r{"$c,$_"}++for X(@_,$n-$c||$r{$c}++&&0)}@_;keys%r}

sub X {                              # Основная функция
  my$n=pop;                          # $n=первый параметр (текущий остаток)
 @_=sort@_;                          # Сортируем входной массив
 my %r;                              # Объявляем хеш результатов
 map {                               # перебираем массив
  my$a=$n-(my$c=pop);                # вытаскиваем очередной элемент массива (в $c)
                                     # и вычисляем текущий остаток минус данный элемент массива
    $r{"$c,$_"}++ for X(@_,$a)       # Кладем в хеш результатов каждый элемент массива,
                                     # который вернет функция перед которым текущий элемент с запятой
  $r{$c}++ if!$a                     # Если разность 0 - то кладем в результаты само число
 } @_;
 keys%r                              # возвращаем массив результатов
}

# Вызов
@A=(1,3,4,5,3,3,7,2,7,10);           # Тестовый массив
$,="n";
print X(@A,10);

f=(n,s,r=[],c={},i=0)=>{s||(c[r.join(',')]=r);for(;i<n.length;)f(n,s-n[i],[n[i],...r].sort(),c,++i);return c}

solve <- function(a) {
  # собираем вектор с допустимыми длинами комбинаций
  sizes <- c(1:length(a))
  # сопоставляем каждой длине комбинации, получаем список списков комбинаций, каждая комбинация пропускается через sort
  combinations <- Map(function(size) combn(a, size, FUN = sort, simplify = FALSE), sizes)
  # делаем список с комбинациями плоским
  combinations <- unlist(combinations, recursive = FALSE)
  # оставляем только комбинации дающие в сумме 10
  combinations <- Filter(function(x) sum(x) == 10, combinations)
  # выкидываем дубликаты
  combinations <- unique(combinations)
  #возвращаем результат
  combinations
}

s(c(2,3,5,5))

a=>[...Array(2e3)].map((x,q)=>a.filter((x,i)=>q&1<<i).sort()).sort().filter((x,i,a)=>x+""!=a[i-1]&!x.reduce((x,y)=>x+y,-10))

def r(a,c=[],z=[]):
 a.sort()
 for i,v in enumerate(a):z+=[c+[v]]if v+sum(c)==10*0**(c+[v]in z)else r(a[i+1:],c+[v],z)*0
 return z

res = r( [1,4,5,5,2,3,1,4] )
print( res )

def recur( arr, curArr, maxSumm ):
    arr.sort()
    curSumm = sum( curArr ) # текущая набранная сумма, не забываем, что sum([]) == 0
    result = []
    for i in range( len( arr ) ):
        if arr[i] + curSumm == maxSumm: # если в сумме набрали нужное число, то добавляем к результату
            result+=[ curArr + [ arr[i] ] ]
        elif arr[i] + curSumm < maxSumm: # если сумма меньше, то добавляем результат рекурсивного вызова
            result+= recur( arr[i+1:], curArr + [ arr[i] ], maxSumm )
    return result

def unique( arr ): # уникальные значения массива
    unique = []
    [ unique.append(i) for i in arr if i not in unique ]
    return unique

function f($a,&$o){while(++$i<1000){shuffle($a);$t=array_slice($a,0,rand(1,10));sort($t);array_sum($t)==10?$o[serialize($t)]=$t:'';}}

<?php
$a = [5,2,3,5,7,1,10,8];

function f($a,&$o){
    while(++$i<1000){
        shuffle($a);
        $t=array_slice($a,0,rand(1,10));
        sort($t);
        array_sum($t)==10?$o[serialize($t)]=$t:'';
    }
}
f($a, $o);
var_dump($o);

function f($a,&$o){sort($a);$c=count($a);for($k=-1,$i=0;$i<$c;$k=$i++){$t=[];while(++$k<$c){$t[]=$a[$k];($s=array_sum($t))==10?$o[implode($t)]=$t:$s>10?array_pop($t):1;}}}

function f($a,&$o){
    sort($a);
    $c=count($a);
    for($k=-1,$i=0;$i<$c;$k=$i++){
        $t=[];
        while(++$k<$c){
            $t[]=$a[$k];
            ($s=array_sum($t))==10?$o[implode($t)]=$t:$s>10?array_pop($t):1;
        }
    }
}