红宝石，84 91

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

第一个从网站上看仍然适合一行的解决方案！

这是一个用输入数组调用的 lambda 文字。结果将是一组找到的组合。

艾迪酮

在Ruby中，获取数组元素组合的功能是直接在类中实现的Array，在标准库中。哎哟。

否则，解决方案将尽可能直接并很好地翻译成自然语言：

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

Поскольку порядок в комбинациях неважен, чтобы не получить дубликатов, массив можно отсортировать. Можно отсортировать и комбинации постфактум, но это медленнее и требует больше символов.

Haskell, 42 70 символа

g=nub.filter((10==).sum).subsequences.sort

Требует импорта функций nub, sort и subsequences из Data.List

Запуск: main = print $ g [5,5,2,3] http://ideone.com/5jUIsy

Как работает:

• входной список сортируется (иначе функция nub, см. далее, не поймет);
• функция subsequences находит все сочетания (без ограничения длины), их 2^m, где m - длина входного списка;
• при помощи filter выбираются те сочетания, которые дают нужную сумму;
• при помощи nub выбираются различные сочетания.

PS спасибо участнику Artem Konovalov за то, что опосредованно подсказал мне не писать велосипед, а заглянуть в стандартную библиотеку языка :)

SQL SQLite Oracle 11.2, 104 114 124 147 176

обнаружен баг (см.комментарии)

Реализация алгоритма выборки комбинации слагаемых для получения заданной суммы из заданного набора значений, с помощью рекурсивных SQL-запросов

• Решение на конкурс

 WITH t(p,w,s)AS(SELECT'',0,0 UNION SELECT p||i||';',r,i+s FROM t,a WHERE r>w)SELECT p FROM t WHERE s=10;

• Подготовка

-- создаём таблицу с данными
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);

• Читаемый вариант решения
  в конкурсном убраны алиасы. вместо t.r - w, a.r - r, a.i - i

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

• Выдача

P
5;5;
5;2;3;   

• Тест (Home - читабельный код, Tab 2 - конкурсный)

珀尔，78     81 95 98 109 112 118 121 123 178

use List::Util 'sum';  # В размере не учитывается - библиотека "из коробки"

sub X{for$c(sort@_){@r=map{$_,[@$_,$c]}@r,[]}grep{!$f{"@$_"}++&&10==sum@$_}@r}

在ideone.com上测试

未压缩版本：

sub X{
 for $c(sort@_) {             # Перебираем отсортированный входной массив
  @r=map {$_,[@$_,$c]} @r,    # Для каждого элемента в массиве вариантов добавляем
                              # такой же но с добавленным текущим числом
                          []  # Затравка первого цикла - пустой массив
 }
 grep {                       # Выбираем те элементы массива
       !$f{"@$_"}++ &&        # Которые еще не встречались ранее
       10==sum@$_             # И сумма элементов которых равна 10
      } @r
}

带递归的旧版本（95 个字符）：

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);

JavaScript, 163 148 141 129 124 118 109 92

比赛的字节码 :) 与@Mike 共同创作。

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

代码说明：

var input = prompt('Введите цифры через запятую, к примеру 5,5,2,0,3,4,10,2,56,2,0,8');
input = input ? input.split(',').map(function(v){return parseInt(v);}) : [];

f=(n/*входной массив чисел*/,
   s/*желаемая сумма*/,
   c/*выходные данные*/,
   r=[]/*слагаемые - промежуточная переменная*/,
   i=0/*текущий шаг - промежуточная переменная*/)=>{
  /*запуск рекурсии, которая обойдёт все комбинации чисел в массиве 
   , комбинация на каждом шаге в аргументе r
   , (желаемая_сумма - сумма_комбинации) : в аргументе s*/
  for(
    s?0:c[r.join()]=r;/*если сумма == 0 - записываем слагаемые в выходные данные*/
    i<n.length;/*рекурсия останавливается, когда доходим до последнего элемента*/
  )
  f(n,
    s-n[i]/*вычитаем из суммы текущий элемент массива*/
    ,c
    ,[n[i],...r].sort()/*добавляем в слагаемые текущий элемент массива, сортируем для уникальности*/
    ,++i/*повторяем операцию для следующего элемента массива*/)
}

var output = {};
f(input, 10, output);
alert('Комбинации, дающие 10: ' + Object.keys(output).join('; '));

混淆测试：

var input = prompt('Введите цифры через запятую, к примеру 5,5,2,0,3,4,10,2,56,2,0,8');
input = input ? input.split(',').map(function(v){return parseInt(v);}) : [];

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

var output = {};
f(input, 10, output);
alert('Комбинации, дающие 10: ' + Object.keys(output).join('; '));

PS 并发的变体为了简洁起见有多余的参数：
第二个参数必须是所需的数量，在我们的例子中是 10。
第三个参数是将写入结果的对象，希望允许在返回时保存）

R, 111

s<-function(a)unique(Filter(function(x)sum(x)==10,unlist(Map(function(n)combn(a,n,sort,F),c(1:length(a))),F)))

Код на IDE ONE

Человекопонятный код:

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))

PHP, 114   120 127 130 131 132 143 151 140 142 145 149 163 171 172

По количеству так-же, но выдает меньше предупреждений и работает быстрее.

function($a,&$o){for(;2e3-$c++;$d&=$t=[])foreach($a as$k=>$e)1<<$k&$c?:($d+=$t[]=$e)-sort($t)-9?:$o[join($t)]=$t;}

sandbox

function($a, &$o){
    for(; 2e3 - $c++; $d &= $t = [])                 // Перебор битовых масок массива 0..1023(2000)
        foreach($a as $k => $e)
            1<<$k&$c                                 // Попадает ли элемент в маску?
                ?: ($d += $t[] = $e) - sort($t) - 9  // sort() == 1,  ($d += $t[] = $e) == $d
                    ?: $o[ join($t) ] = $t;          // join совместно с sort обеспечивают уникальность
}

Python3, 130          131 136 144 147 168 182 216 226

缩小版：

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

现场示例：http:
//ideone.com/ggl9lO

Javascript ES6, 165 161 150 147 145 134 133 125 123 (错误) 124 118

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

笔记：

1. 数组长度限制为 10 个数字，因此您可以使用掩码搜索。
2. lambda 函数不是递归的，因此将其保存到变量中不计入字符数。在 codegolf 上阅读更多内容。
3. 当前版本的函数不创建全局变量

考试：

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

console.log(f([5,5,2,3]).join("   "))
console.log(f([5,2,3]).join("   "))
console.log(f([0,10,10,5,0]).join("   "))
console.log(f([0,10,10,5,0,5]).join("   "))
console.log(f([9]).join("   "))

Scala, 69 73, 80

Нечитабельный вариант:

def f(a:Seq[Int])=a.indices.flatMap(a.combinations).filter(_.sum==10)

пример использования

val a = List(1,2,3,4,5,6,7,8,9,10)
println(f(a))

Читабельный вариант:

def getSeq(list: List[Int]) =
 list
  //берем индексы т.е. получаем последовательность от 0 до size
  .indices
  //берем всевозможные комбинации длиной index из элементов списка
  .flatMap(index => list.combinations(index))
  //фильтруем списки по сумме элементов == 10
  .filter(s => s.sum == 10)

Демка