โปรดจำไว้ว่าชุดจะไม่มีการเรียงลำดับโดยไม่มีการซ้ำซ้อน

นิยามไม่มีสารเติมแต่ง -uniquely ชุดSมีความยาวKเป็นชุดดังกล่าวว่าทุกNมีความยาวย่อยในSรวมกับตัวเลขที่แตกต่างกัน กล่าวอีกนัยหนึ่งผลรวมของชุดย่อยN -length ทั้งหมดของSนั้นแตกต่างกันทั้งหมด

วัตถุประสงค์ป.ร. ให้อาร์เรย์ / ชุดเป็น input และตัวเลขNเพื่อฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบในรูปแบบที่เหมาะสมใด ๆ ค้นหาและการกลับมาหรือส่งออก truthy หรือ falsey ค่า (erroring สำหรับ falsey ไม่เป็นไร) แสดงถึงหรือไม่ว่าใส่เป็นN - สารเติมแต่งที่ไม่ซ้ำกัน

คุณอาจคิดว่าแต่ละองค์ประกอบจะปรากฏเพียงครั้งเดียวมากที่สุดและแต่ละหมายเลขนั้นอยู่ในประเภทข้อมูลดั้งเดิมของภาษาของคุณ ถ้าจำเป็นคุณอาจสมมติว่าอินพุตถูกเรียงลำดับ 0 < N <= Kสุดท้ายคุณอาจคิดว่า

ตัวอย่าง

ลองพิจารณาการตั้งค่าและ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นี่คือผลรวมทั้งหมดที่เป็นไปได้ของความยาวสี่:

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) สำหรับtruthyและผลตอบแทนที่มีข้อผิดพลาดเป็นfalseyคำตอบ (ตามที่ถูกต้องเพื่อความคิดเห็นนี้ )

คำอธิบาย:

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

Julia, 46 41 ไบต์

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

ลองออนไลน์!

มันทำงานอย่างไร

(อีกครั้ง) นี้กำหนดตัวดำเนินการไบนารี\สำหรับอาร์กิวเมนต์ Array / Int

combinations(x,n)ส่งกลับอาร์เรย์ทั้งหมดของว่าnองค์ประกอบที่แตกต่างกันของx เรา map sumมากกว่าอาร์เรย์เหล่านี้และเก็บผลในเสื้อ

t∪tดำเนินการชุดยูเนี่ยนของอาร์เรย์tด้วยตัวเองซึ่งใช้งานได้ยาวนานกว่าuniqueในกรณีนี้

สุดท้ายเราเปรียบเทียบtกับ deduplicated 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)แสดงรายการทั้งหมดn -combinations ของsคือรายการทั้งหมดของnองค์ประกอบต่างๆของs เราแมปsumผ่านรายการผลลัพธ์ดังนั้นจึงคำนวณผลรวมย่อยของความยาวทั้งหมด nทั้งหมด

หลังจากหอผู้ป่วยเราใช้c(...,2)เพื่อสร้างผลรวมจำนวนคู่ที่เกิดขึ้นทั้งหมด ถ้ามีสองเงินก้อนxและy ที่มีค่าเท่ากันx^yจะกลับ0และallจะกลับเท็จ ตรงกันข้ามถ้าผลรวมทั้งหมดจะไม่ซ้ำกันx^yจะเป็น truthy และanyจะกลับมาทรู

J, 34 ไบต์

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

วิธีการตรงไปข้างหน้าเพียงแค่ต้องใช้statsแอดออนสำหรับcombฟังก์ชั่นเท่านั้น ส่งคืน0ค่าเท็จและ1จริง

ในฐานะที่เป็นทางเลือกในการใช้ด้วย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

ผลรวมชุดย่อยความยาว n ทั้งหมดของ s และตรวจสอบว่าค่าทั้งหมดในตารางฉุกเฉินของผลรวมเหล่านี้เป็น 1 (ผลรวมทั้งหมดไม่ซ้ำกัน)

ลองออนไลน์!