请记住，集合是无序的，没有重复项。

定义长度为K的N个唯一加法集合S是一个集合，使得S中所有N个长度子集的总和为不同的数。换句话说，S的所有N个长度的子集的和都是不同的。

目标给定一个数组/集合作为输入，并N以任意合理格式给函数或完整程序提供一个数字，查找并返回或输出表示输入是否为N的真实或假值（错误为假）。独特的添加剂。

您可以假设每个元素最多只能出现一次，并且每个数字都在您语言的本机数据类型之内。如果需要，您还可以假设输入已排序。最后，您可以假设0 < N <= K。

例子

让我们考虑一下set S = {1, 2, 3, 5}和N = 2。这是所有唯一对的总和S（因为唯一对是唯一的总和）：

1 + 2 = 3
1 + 3 = 4
1 + 5 = 6
2 + 3 = 5
2 + 5 = 7
3 + 5 = 8

我们可以看到输出中没有重复项，因此S是2唯一加法的。

现在让我们考虑集合T = {12, 17, 44, 80, 82, 90}和N = 4。以下是长度4的所有可能总和：

12 + 17 + 44 + 80 = 153
12 + 17 + 44 + 82 = 155
12 + 17 + 44 + 90 = 163
12 + 17 + 80 + 82 = 191
12 + 17 + 80 + 90 = 199
12 + 17 + 82 + 90 = 201
12 + 44 + 80 + 82 = 218
12 + 44 + 80 + 90 = 226
12 + 44 + 82 + 90 = 228
12 + 80 + 82 + 90 = 264
17 + 44 + 80 + 82 = 223
17 + 44 + 80 + 90 = 231
17 + 44 + 82 + 90 = 233
17 + 80 + 82 + 90 = 269
44 + 80 + 82 + 90 = 296

它们都是唯一的，因此T是4唯一的加法。

测试用例

[members], N => output
[1, 4, 8], 1 => true
[1, 10, 42], 1 => true                ; all sets trivially satisfy N = 1
[1, 2, 3, 4], 3 => true
[1, 2, 3, 4, 5], 5 => true
[1, 2, 3, 5, 8], 3 => true
[1, 2, 3, 4, 5], 2 => false           ;  1 +  4       =  5 =        2 + 3
[-2, -1, 0, 1, 2], 3 => false         ; -2 + -1 + 2   = -1 =   -2 + 0 + 1
[1, 2, 3, 5, 8, 13], 3 => false       ;  1 +  2 + 13  = 16 =    3 + 5 + 8
[1, 2, 4, 8, 16, 32], 3 => true
[1, 2, 4, 8, 16, 32], 4 => true
[1, 2, 4, 8, 16, 32], 5 => true
[1, 2, 4, 8, 16, 32], 6 => true
[3, 4, 7, 9, 12, 16, 18], 6 => true
[3, 4, 7, 9, 12, 16, 18], 3 => false  ; 3 + 4 + 12 = 19 = 3 + 7 + 9

MATL，7个字节

XN!sSdA

在线尝试！

返回true（显示为1）或false（显示为0）。

XN   % Take array S and number N. Generate all combinations of elements from S 
     % taken N at a time. Gives a 2D array where each combination is a row
!    % Transpose. Each combination is now a column
s    % Sum of each column: gives a row array. If N=1 computes the sum of
     % the only row, and so gives a number
S    % Sort vector
d    % Array of consecutive differences. For a single number gives an empty array
A    % True if all elements of the input array are nonzero (for an empty array
     % it also gives true)

果冻，7个字节

œcS€ṢIP

在线尝试！

返回真值的正数，假值返回零。

œc       find combinations
  S€     sum each combination
    Ṣ    sort the sums
     I   find the difference between each pair of sums 
           iff any sums are the same, this returns a list containing 0
      P  product of the elements of the resulting list

Matlab，78个字节

function n=f(s,n);p=perms(s);k=sum(unique(sort(p(:,1:n)),'rows')');unique(k)-k

此函数n为true返回一个正值（实际上是），并返回一个错误作为false答案（根据此注释有效）

说明：

function n=f(s,n);
p=perms(s); %create all permutations of the set

k=sum(unique(sort(p(:,1:n)),'rows')');
                  %just take the first n entries of each permutation
             %sort those entries and
      %filter out all duplicates (we sorted as the order should NOT matter)
  %then sum each of those candidates

unique(k)-k
%if all those sums are distinct, unique(k) will have the same size 
% as k itself, and therefore we can subtract, otherwise it will throw 
% an error as we try to subtract vectors of different sizes

Pyth，8个字节

{IsM.cFQ

测试套件。

       Q   eval input (provided as a 2-element array)
    .cF    splat over combination
  sM       sum each combination
{I         is the result invariant under { (dedup/uniq)?

Haskell，69个字节

import Data.List
n#s=(==)=<<nub$[sum x|x<-subsequences s,length x==n]

用法示例：6 # [3,4,7,9,12,16,18]-> True。

该定义的直接实现：列出长度为n的所有子序列的总和，并检查其是否等于自己，并删除重复项。

JavaScript（ES6），132个字节

(a,n)=>a.map(m=>{for(i=n;i--;)s[i].map(k=>s[i+1].push(m+k))},s=[...Array(n+1)].map(_=>[]),s[0]=[0])&&new Set(s[n]).size==s[n].length

建立从1到n的加法列表，然后检查最后一个的唯一性。

Brachylog，20个字节

:1f:+aLdL
[L:I]hs.lI

期望包含该列表的列表，然后为整数，作为Input，不包含Output，例如run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2]).。

说明

• 主谓词

             Input = [A:I]
  :1f        Find all ordered subsets of A of length I
     :+aL    Apply summing to each element of that list of subsets. Call that L
         dL  True if L minus all duplicate elements is still L
  

• 谓词1：查找列表中固定长度的所有有序子集

  [L:I]      Input = [L:I]
       hs.   Unify Output with an ordered subset of L
          lI True if I is the length of Output
  

朱莉娅，46 41字节

x\n=(t=map(sum,combinations(x,n)))==t∪t

在线尝试！

怎么运行的

这（重新）定义了\Array / Int参数的二进制运算符。

combinations(x,n)返回x的恰好n个不同元素的所有数组。我们映射这些数组并将结果存储在t中。sum

t∪t与自身执行数组t的集合并集，unique在这种情况下，它的工作时间更长。

最后，我们将t与去重复的t进行比较，true当且仅当所有总和都不同时才返回。

Python，89个字节

from itertools import*
lambda s,n,c=combinations:all(x^y for x,y in c(map(sum,c(s,n)),2))

在Ideone上进行测试。

怎么运行的

c(s,n)列出所有Ñ的-combinations 小号，即，所有列表Ñ的不同元件小号。我们映射sum到结果列表，从而计算长度为n的所有子列表的和。

在病房之后，我们用于c(...,2)创建所有对的结果和。如果两个和x和y相等，x^y将返回0并all返回False。相反，如果所有和都是唯一的，x^y则将始终为真，any并将返回True。

J，34个字节

load'stats'
[:*/@~:[:+/"1(comb#){]

直截了当的方法，只需要功能的stats附件即可comb。返回0false和1true。

作为使用comb内置函数的替代方法，有38个字节的解决方案可生成幂集并选择大小为n的子集。

[:*/@~:(>@{[:(</.~+/"1)2#:@i.@^#)+/@#]

用法

   f =: [:*/@~:[:+/"1(comb#){]
   2 f 1 2 3 5
1
   4 f 12 17 44 80 82 90
1
   3 f _2 _1 0 1 2
0
   6 f 3 4 7 9 12 16 18
1
   3 f 3 4 7 9 12 16 18
0

Ruby，50个字节

->s,n{!s.combination(n).map{|c|c.inject :+}.uniq!}

在线尝试！

如果所有元素都是唯一的，则uniq!返回nil。否定该结果，例如!(...).uniq!进行良好的唯一性测试。

这个问题是在 Ruby 2.4.0-preview1（引入）的几周前发布的Enumerable#sum，在这里可以节省9个字节。

41字节（Ruby 2.4+）

->s,n{!s.combination(n).map(&:sum).uniq!}

在线尝试！

R，41个字节

function(s,n)max(table(combn(s,n,sum)))<2

对s的所有n长度子集求和，并检查列和表中这些和的所有值是否均为1（所有和都是唯一的）。

在线尝试！