Hãy nhớ rằng một bộ là không có thứ tự mà không trùng lặp.

Định nghĩa Một tập hợp phụ gia N -uniquely S có độ dài là K là một tập hợp sao cho tất cả các tập con N -length trong S tổng thành các số khác nhau. Nói cách khác, tổng của tất cả các tập con N -length của S đều khác biệt.

Mục tiêu Đưa ra một mảng / được đặt làm đầu vào và một số Ncho một hàm hoặc cho một chương trình đầy đủ ở bất kỳ định dạng hợp lý nào, tìm và trả về hoặc xuất ra một giá trị trung thực hoặc falsey (lỗi cho falsey là ổn) biểu thị liệu đầu vào có phải là N - phụ gia độc đáo.

Bạn có thể giả sử rằng mỗi phần tử chỉ xuất hiện tối đa một lần và mỗi số nằm trong kiểu dữ liệu gốc của ngôn ngữ của bạn. Nếu cần, bạn cũng có thể cho rằng đầu vào được sắp xếp. Cuối cùng, bạn có thể cho rằng 0 < N <= K.

Ví dụ

Hãy xem xét các thiết lập S = {1, 2, 3, 5}và N = 2. Dưới đây là tất cả các khoản tiền của tất cả các cặp duy nhất trên S(đối với những người duy nhất là những người quan tâm duy nhất cho các khoản tiền):

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

Chúng ta có thể thấy rằng không có sự trùng lặp trong đầu ra, vì vậy S là phụ gia 2 lần duy nhất.

Bây giờ chúng ta hãy xem xét các thiết lập T = {12, 17, 44, 80, 82, 90}và N = 4. Dưới đây là tất cả các khoản tiền có thể có độ dài bốn:

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

Chúng đều là duy nhất, và vì vậy T là phụ gia 4 duy nhất.

Các trường hợp thử nghiệm

[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 byte

XN!sSdA

Hãy thử trực tuyến!

Trả về true(hiển thị dưới dạng 1) hoặc false(hiển thị dưới dạng 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)

Thạch, 7 byte

œcS€ṢIP

Hãy thử trực tuyến!

Trả về một số dương cho sự thật và số không cho falsey.

œ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 byte

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

Hàm này trả về giá trị dương (trên thực tế n) cho tính trung thực và trả về lỗi dưới dạng câu trả lời falsey (hợp lệ theo nhận xét này )

Giải trình:

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

Bình thường, 8 byte

{IsM.cFQ

Bộ thử nghiệm.

       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 byte

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

Ví dụ sử dụng: 6 # [3,4,7,9,12,16,18]-> True.

Thực hiện trực tiếp định nghĩa: lập danh sách tổng của tất cả các chuỗi có độ dài n và kiểm tra xem nó có bằng chính các bản sao được loại bỏ không.

JavaScript (ES6), 132 byte

(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

Xây dựng danh sách phụ gia từ 1 đến n và sau đó kiểm tra tính duy nhất cuối cùng.

Brachylog , 20 byte

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

Yêu cầu một danh sách chứa danh sách và sau đó là số nguyên dưới dạng Đầu vào và không có Đầu ra, vd run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2])..

Giải trình

• Vị ngữ chính

             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
  

• Vị ngữ 1: Tìm tất cả các tập hợp con có thứ tự có độ dài cố định của danh sách

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

Julia, 46 41 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Điều này (lại) định nghĩa toán tử nhị phân \cho các đối số Array / Int.

combinations(x,n)trả về tất cả các mảng của chính xác n phần tử khác nhau của x . Chúng tôi ánh xạ sumqua các mảng này và lưu trữ kết quả trong t .

t∪tthực hiện liên kết tập hợp của mảng t với chính nó, hoạt động như dài hơn uniquetrong trường hợp này.

Cuối cùng, chúng ta so sánh t với không trùng lặp t , trở về truekhi và chỉ khi tất cả các khoản tiền khác nhau.

Python, 89 byte

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

c(s,n)liệt kê tất cả n-kết hợp của s , tức là tất cả các danh sách của n phần tử khác nhau của s . Chúng tôi ánh xạ sumqua các danh sách kết quả, do đó tính toán tất cả các khoản tiền có thể có của danh sách con có độ dài n .

Sau phường, chúng tôi sử dụng c(...,2)để tạo tất cả các cặp tổng kết quả. Nếu bất kỳ hai tổng x và y bằng nhau, x^ysẽ trả về 0 và allsẽ trả về Sai . Ngược lại, nếu tất cả các khoản tiền là duy nhất, x^ysẽ luôn luôn trung thực và anysẽ trả về True .

J, 34 byte

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

Cách tiếp cận đơn giản, chỉ yêu cầu statsbổ trợ cho combchức năng. Trả về 0sai và 1đúng.

Thay thế cho việc sử dụng combnội dung, có một giải pháp 38 byte tạo ra tập hợp năng lượng và chọn các tập hợp con có kích thước n .

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

Sử dụng

   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 byte

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

Hãy thử trực tuyến!

Nếu tất cả các yếu tố là duy nhất, uniq! trả về nil. Phủ định kết quả đó, như trong !(...).uniq!một thử nghiệm duy nhất tốt đẹp.

Câu hỏi này đã được đăng vài tuần trước khi Ruby 2.4.0-preview1, được giới thiệu Enumerable#sum, sẽ lưu 9 byte ở đây.

41 byte (Ruby 2.4+)

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

Hãy thử trực tuyến!

R , 41 byte

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

Tính tổng tất cả các tập con có độ dài n của s và kiểm tra xem tất cả các giá trị trong bảng dự phòng của các tổng này là 1 (tất cả các tổng là duy nhất).

Hãy thử trực tuyến!