->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}              #   ...убрав повторения.

sub X{my$n=pop;@_=sort@_;my%r;while($#_+1){my$a=$n-(my$c=pop);if($a>=0){$r{"$c,$_"}=1 for X(@_,$a)}$r{$c}=1 if(!$a)}keys%r}

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

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

a=>Array(1024).fill``.map((x,q)=>a.filter((x,i)=>q&1<<i).sort()).filter(x=>x.reduce((x,y)=>x+y,0)==10).filter((x,i,a)=>!a.find((y,j)=>j<i&""+x==y))

-- создаём таблицу с данными
CREATE TABLE a (r INTEGER, i INTEGER);

-- заполняем
INSERT INTO a VALUES (1,5);
INSERT INTO a VALUES (2,5);
INSERT INTO a VALUES (3,2);
INSERT INTO a VALUES (4,3);

WITH t (p, r, s) AS
  (SELECT '', 0, 0 FROM dual -- инициализация кортежа для рекурсии
   UNION ALL
   SELECT
     p || a.i || ';' , -- сбор строки для вывода
     a.r, -- запоминаем номер строки, чтоб не взять дважды
     a.i+s -- накопительная сумма
   FROM t, a
   WHERE s <= 10 -- выйти из рекурсии, если накопили достаточно
   AND a.r > t.r -- ограничение - не использовать уже учтенные строки
  )
SELECT DISTINCT p -- выбор уникальных комбинаций
FROM t
WHERE s = 10; --наше конкурсное условие - сумма=10

P
1   5;2;3;
2   5;5;

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

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

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