प्रतिस्थापन के साथ संयोजन उत्पन्न करें

Question

प्रतिस्थापन के साथ संयोजन के सभी सूची (या पुनरावृत्ति के साथ संयोजन) n तत्वों के एक समूह से आकार k ।

प्रतिस्थापन के साथ एक संयोजन एक अनियंत्रित मल्टीसेट है कि इसमें प्रत्येक तत्व एन तत्वों के सेट में भी हैं। ध्यान दें कि:

• यह अव्यवस्थित है। इसलिए पहले से प्रिंट किए गए सेट को फिर से प्रिंट नहीं किया जाना चाहिए।
• यह एक मल्टीसेट है। एक ही तत्व (लेकिन आवश्यक नहीं है) एक से अधिक बार दिखाई दे सकता है। प्रतिस्थापन के साथ संयोजन और सामान्य संयोजन के बीच यह एकमात्र अंतर है।
• सेट में बिल्कुल k तत्व होने चाहिए ।

वैकल्पिक रूप से, यह मल्टीसेट का एक आकार- k सबसेट भी है जिसमें प्रत्येक n तत्व k बार होते हैं।

इनपुट या तो n और k होना चाहिए , जहाँ तत्व पहले n पॉजिटिव या नॉन-निगेटिव पूर्णांक हैं, या n एलिमेंट्स और k हैं , जहाँ आप मान सकते हैं कि एन एलिमेंट्स सभी एक दूसरे से अलग हैं।

आउटपुट दिए गए सेट से आकार k के साथ प्रतिस्थापन के साथ सभी संयोजनों की एक सूची होनी चाहिए । आप उन्हें और उनमें से प्रत्येक में तत्वों को किसी भी क्रम में मुद्रित कर सकते हैं।

आप प्रतिस्थापन के साथ संयोजन बनाने वाले बिल्डरों का उपयोग नहीं कर सकते हैं। लेकिन आप सामान्य संयोजन, क्रमपरिवर्तन, ट्यूपल्स इत्यादि उत्पन्न करने के लिए बिल्डरों का उपयोग कर सकते हैं।

यह कोड-गोल्फ, सबसे छोटा कोड जीत है।

उदाहरण

Input: 4 2
Output: [0 0] [0 1] [0 2] [0 3] [1 1] [1 2] [1 3] [2 2] [2 3] [3 3]

Answer 1

जेली, 4 बाइट्स

2 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।

ṗṢ€Q

इनपुट है nऔर kउस क्रम में कमांड लाइन तर्क के रूप में। के 1लिए तत्वों का उपयोग करता है n।

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

व्याख्या

ṗ     # Get k-th Cartesion power of n.
 Ṣ€   # Sort each tuple.
   Q  # Remove duplicates.

Answer 2

CJam (8 बाइट्स)

{m*:$_&}

ऑनलाइन डेमो

विच्छेदन

{    e# Declare block (anonymous function); parameters are n k
  m* e# Cartesian product, which implicitly lifts n to [0 1 ... n-1]
  :$ e# Sort each element of the Cartesian product, to give them canonical forms
  _& e# Deduplicate
}

Answer 3

गणितज्ञ, 31 29 बाइट्स

2 बाइट्स बचाने के लिए ए सिमंस को धन्यवाद।

{}⋃Sort/@Range@#~Tuples~#2&

एक अनाम फ़ंक्शन लेने nऔर kउस क्रम में पूर्णांक तर्क के रूप में और सूचियों की सूची लौटाता है। तत्वों हो जाएगा 1करने के लिए n। पीटर के सीजेएम उत्तर के समान ही काम करता है।

Comments

@ jimmy23013 मुझे इस बात की जानकारी नहीं है।

— मार्टिन एंडर

मुझे लगता है कि आप दो बाइट्स बचा सकते हैं{}∪Sort/@Range@#~Tuples~#2&

— A Simmons

@ASimmons अच्छा विचार है, धन्यवाद!

— मार्टिन एंडर

Answer 4

MATL , 11 बाइट्स

( कार्टेशियन शक्ति पर आधारित 9-बाइट समाधान है , लेकिन पीटर टेलर ने पहले ही ऐसा कर दिया है । आइए कुछ अलग करने की कोशिश करें)।

प्रतिस्थापन के साथ संयोजन निम्न प्रकार से प्रतिस्थापन के बिना संयोजन में कम किया जा सकता है। हम चाहते हैं n Cr k, उदाहरण के लिए n=3, k=2:

0 0
0 1
0 2
1 1
1 2
2 2

हम गणना कर सकते हैं n+k-1 C k:

0 1
0 2
0 3
1 2
1 3
2 3

और फिर 0 1 ... k-1प्रत्येक पंक्ति से घटाएँ :

+q:2GXn2G:-

स्पष्टीकरण:

+q     % take two inputs n, k and compute n+k-1
:      % range [1,2...,n+k-1]
2G     % push second input, k
Xn     % combinations without replacement
2G:    % range [1,2,...,k]
-      % subtract with broadcast. Display

कोड भाषा / संकलक के रिलीज के 13.1.0 में काम करता है , जो चुनौती से पहले है।

आप इसे ऑनलाइन आज़मा सकते हैं ! ध्यान दें कि ऑनलाइन संकलक को 14.0.0 जारी करने के लिए अपडेट किया गया है, इसलिए Xnइसे बदलने की आवश्यकता है XN।

Answer 5

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 71 बाइट्स

f=(n,k)=>k?[for(m of Array(n).keys())for(a of f(m+1,k-1))[...a,m]]:[[]]

मैं keys()एक बार के लिए उपयोग करने के लिए मिलता है ।

Answer 6

रूबी, 56 55 बाइट्स

दो समाधान, आश्चर्यजनक रूप से दोनों समान लंबाई:

->n,k{[*1..n].repeated_permutation(k).map(&:sort).uniq}
->n,k{(a=[*1..n]).product(*[a]*(k-1)).map(&:sort).uniq}

अरे, आपने कहा था कि हम क्रमचय निर्माण का उपयोग कर सकते हैं ...

यह बस सभी दोहराया क्रमपरिवर्तन उत्पन्न करता है (दूसरा एक दोहराया कार्टेसियन उत्पादों को उत्पन्न करता है) और उन लोगों को हटा देता है जो क्रमबद्ध क्रम में नहीं हैं।

मार्टिन के साथ बाइट बचाने के लिए धन्यवाद 0...n-> 1..n!

Answer 7

पायथ, 7 बाइट्स

{SM^UQE

पीटर के उत्तर के समान एल्गोरिथ्म का उपयोग करता है।

    UQ   range(input())
      E  input()
   ^     repeated Cartesian product of ^^, ^ times
 SM      map(sort)
{        uniq

Answer 8

पायथन, 63 बाइट्स

f=lambda n,k:n*k and[l+[n]for l in f(n,k-1)]+f(n-1,k)or[[]][k:]

एक पुनरावर्ती विधि। kतत्वों का एक बहुरूप बनाने के 1लिए n, हम या तो चुनते हैं:

• के एक और उदाहरण को शामिल करें n, और यह k-1तत्वों के एक बहुरूप से बना रहता 1हैn
• के एक और उदाहरण को शामिल न करें n, और यह kतत्वों का एक बहुरूप से बना रहता 1हैn-1

हम समाप्त जब या तो kया nपहुँच 0, और अगर यह kपहुंच गया 0है, हम खाली सूची के आधार मामले दे। यदि नहीं, तो हमारे पास तत्वों की गलत संख्या है, और इसलिए खाली सूची दें।

Answer 9

पायथन 3, 81 80

पुनरावर्ती समाधान:

t=lambda n,k,b=0:[[]]if k<=0 else [[i]+l for i in range(b,n)for l in t(n,k-1,i)]

यह फ़ंक्शन रेंज t(n, k, b)के सभी k-से-बहु- सब -सेट की सूची लौटाता bहै n। अगर यह सूची खाली है k <= 0। अन्यथा, हम बहु-उपसमुच्चय के सबसे छोटे तत्व के आधार पर समस्या को तोड़ते हैं, जिसे हम निरूपित करते हैं i।

प्रत्येक के लिए iसे रेंज में bकरने के लिए n, हम सभी को उत्पन्न kसबसे छोटा तत्व के साथ -मल्टी-सबसेट iसे प्रारंभ करते हुए [i]और उसके बाद प्रत्येक जोड़कर (k-1)से रेंज के -मल्टी-सबसेट iके लिए nहै, जो हम रिकर्सिवली बुला द्वारा प्राप्त t(n, k-1, i)।

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! यह एक अच्छा पहला उत्तर है। क्या आप एक स्पष्टीकरण प्रदान कर सकते हैं कि कोड कैसे काम करता है?

— एलेक्स ए।

अच्छा लग रहा है। अच्छा समाधान!

— A. पर एलेक्स ए।

Answer 10

दिल्लोग एपीएल , 22 बाइट्स

{∪{⍵[⍋⍵]}¨↓⍉⍺⊥⍣¯1⍳⍺*⍵}

आवश्यकता है ⎕IO←0, जो कई एपीएल सिस्टम में डिफ़ॉल्ट है। K को बाएं तर्क के रूप में, n को सही तर्क के रूप में लेता है।

⍳⍺*⍵0 1 2 ...
⍺⊥⍣¯1k 1 बेस k
⍉ट्रांज़ोज़
↓मेक मैट्रिक्स में बदलें सूचियों की सूची में
{⍵[⍋⍵]}¨प्रत्येक ...
∪अद्वितीय

Answer 11

जे, 18 बाइट्स

[:~.#~<@/:~@#:i.@^

@ Adám के समाधान में उपयोग किए गए समान दृष्टिकोण ।

{24 बाइट्स के लिए कार्टेशियन उत्पाद का उपयोग करते हुए एक और दृष्टिकोण । kLHS nपर और RHS पर ले जाता है ।

~.@:(/:~&.>)@,@{@(#<@i.)

प्रयोग

   f =: [:~.#~<@/:~@#:i.@^
   4 f 2
┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
│0 0│0 1│0 2│0 3│1 1│1 2│1 3│2 2│2 3│3 3│
└───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘

व्याख्या

[:~.#~<@/:~@#:i.@^ Input: n on LHS and k on RHS
                 ^ Compute n^k
              i.@  Create a range [0, 1, ... n^k-1]
    #~             Create k copies on n
            #:     On each value in the range above, convert each digit to base-n
                   and take the last k digits of it
        /:~@       For each array of digits, sort it in ascending order
      <@           Box each array of digits
[:~.               Take the distinct values in the array of boxes and return it

Answer 12

क्लोजर, 94 बाइट्स

(defn f[k n](if(= 1 k)(for[i(range n)][i])(sort(set(for[i(f(dec k)n)j(range n)](conj i j))))))

परिवर्तित पैरामीटर क्रम पर ध्यान दें: 1 है kऔर दूसरा है n। इससे 1 बाइट बच गई (f(dec k)n)।

Answer 13

गणितज्ञ, 36 बाइट्स

{##}&~Array~Table@##~Flatten~(#2-1)&

कृपया मुझे बताएं कि कोई भी [] s ... या शायद ## के कई उपयोगों के लिए 1/6 बोनस है?