एन-अनूठे योजक सेट

Question

याद रखें कि एक सेट डुप्लिकेट के बिना unordered है।

परिभाषा एक एन -uniquely additive सेट एस जिसकी लंबाई है कश्मीर एक सेट ऐसा है कि सभी एन में -length सबसेट एस अलग नंबरों के लिए राशि। दूसरे शब्दों में, S के सभी N -length सबसेट के योग अलग-अलग हैं।

उद्देश्य एक सरणी / इनपुट के रूप में सेट और किसी Nफ़ंक्शन या किसी उचित प्रारूप में एक पूर्ण कार्यक्रम के लिए एक संख्या को देखते हुए, एक सत्य या गलत मूल्य को खोजने या वापस लाने या (गलत के लिए गलत है) यह दर्शाता है कि इनपुट एन है या नहीं - विशिष्ट रूप से additive।

आप यह मान सकते हैं कि प्रत्येक तत्व केवल एक बार ही दिखाई देता है और प्रत्येक संख्या आपकी भाषा के मूल डेटाटाइप के भीतर है। यदि आवश्यकता हो, तो आप यह भी मान सकते हैं कि इनपुट क्रमबद्ध है। अंतिम, आप ऐसा मान सकते हैं 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

हम देख सकते हैं कि आउटपुट में कोई डुप्लिकेट नहीं है, इसलिए एस 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

वे सभी अनूठे हैं, और इसलिए टी 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

Comments

आपका मतलब है N <= K?

— नील

@ नील, मैं करता हूँ। माफ़ करना!

— कॉनर ओ'ब्रायन

क्या एक त्रुटि कुछ के रूप में गिना जाता है falsey?

— दोष

@flawr ज़रूर, मैं स्वीकार करता हूँ कि

— कॉनर ओ'ब्रायन

Answer 1

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)

Answer 2

जेली, 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

Answer 3

मतलाब, 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

Comments

इसमें त्रुटि क्यों होती है?

— कॉनर ओ'ब्रायन

मैंने सिर्फ एक स्पष्टीकरण जोड़ा। त्रुटि अंतिम पंक्ति से आती है। यदि हम डुप्लिकेट हैं, तो यह एक त्रुटि का कारण बनता है k। पुनश्च: मतलाब वाक्य रचना हाइलाइटिंग आखिरकार काम करता है !!!

— 23

उसी को वापस करने के लिए अच्छा विचार है n!

— लुइस मेंडो

Answer 4

पायथ, 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)?

Comments

क्या splatमतलब है?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ वही बात जो हर दूसरी भाषा में होती है: किसी फ़ंक्शन के तर्क के रूप में एक सरणी का उपयोग करें।

— दरवाज़े

ओह, ठीक है, मैं गूंगा हूं: पी धन्यवाद

— कॉनर ओ'ब्रायन

हर दूसरी भाषा में जिसका वास्तव में यह कार्य है

— त्रुटी

मैंने उस बग को ठीक कर दिया, जिसकी आवश्यकता Qअंत में थी।

— isaacg

Answer 5

हास्केल, 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 के सभी बाद के योगों की एक सूची बनाएं और जांचें कि क्या यह स्वयं डुप्लिकेट के साथ बराबर है।

Answer 6

जावास्क्रिप्ट (ईएस 6), 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 तक योगात्मक सूचियों का निर्माण करता है और फिर अद्वितीयता के लिए अंतिम जांच करता है।

Answer 7

ब्रेकीलॉग , 20 बाइट्स

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

एक सूची की अपेक्षा करता है जिसमें सूची और फिर इनपुट के रूप में पूर्णांक और कोई आउटपुट नहीं है, उदाहरण के लिए run_from_atom(':{[L:I]hs.lI}f:+aLdL', [[1:2:3:5]:2]).।

व्याख्या

• मुख्य Predicate

             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
  

Answer 8

जूलिया, 46 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

यह (पुनः) \Array / Int तर्कों के लिए बाइनरी ऑपरेटर को परिभाषित करता है।

combinations(x,n)बिल्कुल के सभी सरणियों रिटर्न n के विभिन्न तत्वों एक्स । हम sumइन सरणियों पर मैप करते हैं और परिणाम को t में संग्रहीत करते हैं ।

t∪tसरणी टी के सेट यूनियन को स्वयं के साथ करता है, जो uniqueइस मामले में लंबे समय तक काम करता है ।

अंत में, हम तुलना टी deduplicated साथ टी , लौटने trueयदि और केवल यदि सभी राशियों अलग हैं।

Answer 9

पायथन, 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 रों , यानी, के सभी सूचियों n के विभिन्न तत्वों रों । हम sumपरिणामी सूचियों का नक्शा बनाते हैं, इस प्रकार लंबाई n के सब्लिस्ट्स के सभी संभावित योगों की गणना करते हैं ।

वार्ड के बाद, हम c(...,2)परिणामी रकम के सभी जोड़े बनाने के लिए उपयोग करते हैं। यदि कोई दो sums x और y समान हैं, x^yतो 0 वापस आएगा और allवापस आएगा False । इसके विपरीत, यदि सभी रकम अद्वितीय हैं, x^yतो हमेशा सच्चाईany होगी , और यह सच लौटेगा ।

Answer 10

जे, 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

Comments

वाह, statsमॉड्यूल के बारे में पता नहीं था । बहुत अच्छा!

— कॉनर ओ'ब्रायन

मुझे अभी इसके बारे में भी पता चला है, मैंने वास्तव में जे में ऐड-ऑन में बहुत ज्यादा देरी नहीं की है। यदि मैं अधिक बहादुर था, तो मैं ग्राफिक्स ऐड-ऑन का प्रयास करूंगा।

— मील

Answer 11

रूबी , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यदि सभी तत्व अद्वितीय हैं, तो uniq!रिटर्नnil । उस परिणाम की उपेक्षा करना, जैसा कि !(...).uniq!एक अच्छी विशिष्टता परीक्षण के लिए होता है।

यह प्रश्न कुछ सप्ताह पहले पोस्ट किया गया था रूबी 2.4.0-प्रीव्यू 1 , जो कि पेश किया गया Enumerable#sum, जिससे यहां 9 बाइट्स बचेंगे।

41 बाइट्स (रूबी 2.4+)

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

इसे ऑनलाइन आज़माएं!

Answer 12

आर , 41 बाइट्स

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

S की सभी n-लंबाई उपसमूहों को जांचता है और जांचता है कि क्या इन रकमों की आकस्मिक तालिका में सभी मान 1 हैं (सभी रकम अद्वितीय हैं)।

इसे ऑनलाइन आज़माएं!