Bir kümenin yinelenmeden sırasız olduğunu unutmayın.

Tanım Bir N -Eşsiz katkı grubu S uzunluğu olan K bir dizi gibi olduğu, tüm N olarak uzunlukta alt-gruplar G farklı sayılara toplamı. Başka bir deyişle, S'nin N- uzunluk alt kümelerinin toplamlarının hepsi farklıdır.

Amaç girdi olarak bir dizi / seti ve bir dizi göz önüne alındığında Nherhangi bir makul biçimde bir fonksiyona ya da tam bir program bulmak ve dönüş ya da çıkış truthy veya Falsey değeri giriş olup olmadığını gösteren (Falsey için erroring tamam) , N - benzersiz katkı.

Her öğenin en fazla bir kez göründüğünü ve her sayının dilinizin yerel veri türünde olduğunu varsayabilirsiniz. Gerekirse, girişin sıralandığını da varsayabilirsiniz. Son olarak, bunu varsayabilirsiniz 0 < N <= K.

Örnekler

Seti S = {1, 2, 3, 5}ve düşünelim N = 2. İşte tüm benzersiz çiftlerin toplamları S(benzersiz olanlar toplamlar için sadece ilgi alanlardır):

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

Çıktıda herhangi bir kopya olmadığını görebiliriz, bu yüzden S 2 benzersiz bir katkı maddesidir.

Şimdi seti düşünelim T = {12, 17, 44, 80, 82, 90}ve N = 4. Dört uzunluktaki tüm olası toplamlar:

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

Hepsi benzersizdir ve bu nedenle T 4 benzersiz bir katkı maddesidir.

Test Durumları

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

XN!sSdA

Çevrimiçi deneyin!

true(Olarak görüntülenir 1) veya false(olarak görüntülenir ) döndürür 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)

Jöle, 7 bayt

œcS€ṢIP

Çevrimiçi deneyin!

Doğruluk için pozitif bir sayı ve falsey için sıfır döndürür.

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

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

Bu fonksiyon pozitif bir değer (aslında döner niçin) truthy ve iadeler bir gibi bir hata Falsey (geçerli göre cevap Bu yoruma )

Açıklama:

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 bayt

{IsM.cFQ

Test odası.

       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 bayt

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

Kullanım örneği: 6 # [3,4,7,9,12,16,18]-> True.

Tanımın doğrudan uygulanması: n uzunluğundaki tüm alt dizilerin toplamlarının bir listesini yapın ve yinelenenleri kaldırılmış olarak kendini eşitleyip eşitlemediğini kontrol edin.

JavaScript (ES6), 132 bayt

(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'den n'ye kadar olan katkı listelerini oluşturur ve sonuncuyu benzersiz olup olmadığını kontrol eder.

Brachylog , 20 bayt

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

Listeyi ve ardından tamsayıyı Girdi olarak içeren ve Çıktı içermeyen bir liste bekler, ör run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2])..

açıklama

• Ana Tahmin

             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
  

• Tahmin 1: Bir listenin sabit uzunlukta tüm sipariş edilen alt kümelerini bulun

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

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

Çevrimiçi deneyin!

Nasıl çalışır

Bu \, Array / Int bağımsız değişkenleri için ikili işleci tanımlar .

combinations(x,n)x'in tam olarak n farklı öğesinin tüm dizilerini döndürür . Biz map bu diziler üzerinde ve içinde sonucunu saklamak t .sum

t∪tt dizisinin küme birleşimini kendisi ile gerçekleştirir, bu uniqueda bu durumda daha uzun süre çalışır .

Son olarak, biz karşılaştırmak t deduplicated ile t dönen, trueve tüm toplam farklıdır yalnızca eğer.

Python, 89 bayt

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

Ideone üzerinde test edin .

Nasıl çalışır

c(s,n)listeler her n ve bu aşamaların s yani, her liste n farklı elemanları, s . sumOrtaya çıkan listelerin haritasını çıkarırız, böylece n uzunluk alt listelerinin tüm olası toplamlarını hesaplarız .

Koğuşlardan sonra c(...,2), elde edilen meblağların tüm çiftlerini oluşturmak için kullanırız . X ve y değerlerinden herhangi biri eşitse 0x^y döndürür ve False döndürür . Tersine, eğer tüm meblağlar benzersizse, her zaman doğrudur ve True döndürür .allx^yany

J, 34 bayt

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

Düz ileri yaklaşım, yalnızca işlev statsiçin eklenti gerektirir comb. İade 0yanlış kelimelerini ve 1gerçek için.

combYerleşik kullanmaya alternatif olarak , güç setini üreten ve n boyutundaki alt kümeleri seçen 38 baytlık bir çözüm vardır .

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

kullanım

   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

Yakut , 50 bayt

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

Çevrimiçi deneyin!

Tüm öğeler benzersizse, uniq!döndürür nil. Bu sonucu reddetmek, olduğu gibi !(...).uniq!güzel bir teklik testi yapar.

Bu soru, 9 bayt tasarruf sağlayacak olan Ruby 2.4.0-önizleme1'den birkaç hafta önce yayınlandı Enumerable#sum.

41 bayt (Ruby 2.4+)

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

Çevrimiçi deneyin!

R , 41 bayt

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

Tüm n uzunluk s alt kümelerini toplar ve bu toplamların olasılık tablosundaki tüm değerlerin 1 olup olmadığını kontrol eder (tüm toplamlar benzersizdir).

Çevrimiçi deneyin!