रकम के सेट का पता लगाएं

Question

मुझे इस साइट को पढ़ने में मज़ा आया है; यह मेरा पहला सवाल है। संपादन का स्वागत है।

यह देखते हुए धनात्मक पूर्णांक n और मीटर , के सभी आदेश दिया विभाजन की गणना मीटर वास्तव में एन भागों सकारात्मक पूर्णांक भागों, और प्रिंट उन्हें कॉमा और नई पंक्तियों से सीमांकित। कोई भी आदेश ठीक है, लेकिन प्रत्येक विभाजन को एक बार बिल्कुल दिखाई देना चाहिए।

उदाहरण के लिए, दिए गए m = 6 और n = 2, संभावित विभाजन सकारात्मक पूर्णांक के जोड़े हैं जो 6 तक हैं:

1,5
2,4
3,3
4,2
5,1

ध्यान दें कि [१,५] और [५,१] अलग-अलग क्रमबद्ध विभाजन हैं। आउटपुट बिल्कुल ऊपर के प्रारूप में होना चाहिए, एक वैकल्पिक अनुगामी न्यूलाइन के साथ। (EDIT: विभाजन का सटीक क्रम मायने नहीं रखता है)। इनपुट / आउटपुट मानक कोड-गोल्फ I / O के माध्यम से हैं ।

M = 7, n = 3 के लिए एक और उदाहरण आउटपुट:

1,1,5
1,2,4
2,1,4
1,3,3
2,2,3
3,1,3
1,4,2
2,3,2
3,2,2
4,1,2
1,5,1
2,4,1
3,3,1
4,2,1
5,1,1

1 सप्ताह की जीत के बाद बाइट्स में सबसे छोटा कोड।

फिर से, यदि आवश्यक हो तो संपादित करें।

परिशिष्ट:

@TimmyD ने पूछा कि पूर्णांक इनपुट के किस आकार का कार्यक्रम को समर्थन करना है। उदाहरणों से परे कोई न्यूनतम न्यूनतम नहीं है; वास्तव में, आउटपुट का आकार तेजी से बढ़ता है, मोटे तौर पर इसके द्वारा निर्मित: लाइनें = e ^ (0.6282 n - 1.8273)।

n | m | lines of output
2 | 1 | 1
4 | 2 | 2
6 | 3 | 6
8 | 4 | 20
10 | 5 | 70
12 | 6 | 252
14 | 7 | 924
16 | 8 | 3432
18 | 9 | 12870
20 | 10 | 48620
22 | 11 | 184756
24 | 12 | 705432

Comments

क्या जवाबों को मनमाने ढंग से बड़े पूर्णांक का समर्थन करने की आवश्यकता है, या 2 ^ 31-1 की तरह एक उचित ऊपरी सीमा है?

— AdmBorkBork 21

"सेट" शब्द भ्रामक है क्योंकि ऑर्डर मायने रखता है। मुझे लगता है कि जिस शब्द की आप तलाश कर रहे हैं वह विभाजन का आदेश दिया गया है।

— xnor

हालाँकि इसे बदलना आवश्यक नहीं है, लेकिन आमतौर पर हमारे पास इससे कम उत्पादन प्रारूप होता है।

— lirtosiast 21

मैंने फ़ंक्शन तर्क, संकेतों और अन्य I / O विधियों के माध्यम से I / O की अनुमति देने के लिए आपके शब्दों को बदल दिया है, जिन्हें हम आमतौर पर स्वीकार्य मानते हैं।

— lirtosiast 21

@ टिम्मीड, आउटपुट का आकार विस्फोटक रूप से बढ़ता है, इसलिए यह कुछ सौ से अधिक मी और एन की कोशिश करने के लिए व्यावहारिक नहीं है , अकेले 2 ^ 31-1।

— cuniculus

Answer 1

अजगर, 14 बाइट्स

V^SQEIqsNQj\,N

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

V^SQEIqsNQj\,N   implicit: Q = first input number
  SQ             create the list [1, 2, ..., Q]
    E            read another number
 ^               cartesian product of the list
                 this creates all tuples of length E using the numbers in SQ
V                for each N in ^:
     IqsNQ          if sum(N) == Q:
          j\,N         join N by "," and print

Comments

इसके अलावा 14 बाइट्स, अलग दृष्टिकोण jjL\,fqsTQ^SQE:।

— पुरकाकूदरी

Answer 2

पायथन 3, 77 बाइट्स

def f(n,m,s=''):[f(i,m-1,',%d'%(n-i)+s)for i in range(n)];m|n or print(s[1:])

एक पुनरावर्ती फ़ंक्शन जो प्रत्येक आउटपुट स्ट्रिंग बनाता है और इसे प्रिंट करता है। हर संभव पहली संख्या को लेता है, जो घटे हुए योग के साथ समाधान खोजने के लिए नीचे आता है n, और एक कम सारांश m, और sउस संख्या के साथ एक स्ट्रिंग उपसर्ग । यदि आवश्यक राशि और शब्दों की संख्या दोनों समान हैं, तो हमने निशान मारा है, इसलिए हम परिणाम को प्रिंट करते हैं, प्रारंभिक अल्पविराम को काटते हैं। यह m|n0 (झूठी) होने के रूप में जाँच की जाती है ।

पायथन 2 में 79 वर्ण:

def f(n,m,s=''):
 if m|n==0:print s[1:]
 for i in range(n):f(i,m-1,','+`n-i`+s)

Answer 3

सीजेएम, 22 बाइट्स

q~:I,:)m*{:+I=},',f*N*

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

q~                      Read and evaluate all input. Pushes n and m.
  :I                    Save m in I.
    ,:)                 Turn it into [1 ... I].
       m*               Push all vectors of {1 ... I}^n.
         {    },        Filter; for each vector:
          :+I=            Check if the sum of its elements equals I.
                        Keep the vector if it does.
                ',f*    Join all vectors, separating by commas.
                    N*  Join the array of vectors, separating by linefeeds.

Answer 4

पायथ, 20 18 बाइट्स

-2 बाइट्स @ डेनिस द्वारा!

jjL\,fqQlT{s.pM./E

यह nइनपुट की पहली पंक्ति के mरूप में , और दूसरी के रूप में लेता है ।

इसे यहाँ आज़माएँ ।

Answer 5

हास्केल, 68 बाइट्स

n#m=unlines[init$tail$show x|x<-sequence$replicate n[1..m],sum x==m]

उपयोग उदाहरण:

*Main> putStr $ 2#6
1,5
2,4
3,3
4,2
5,1

यह कैसे काम करता है: तैयार किए गए तत्वों के sequence $ replicate n listसभी संयोजनों को nबनाता है list। हम सब इस तरह ले xकी [1..m]जहां sumके बराबर होती है m। unlinesऔर init$tail$showआवश्यक आउटपुट स्वरूप का उत्पादन।

Answer 6

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

{↑1↓¨,/',',¨⍕¨↑⍺{⍵/⍨⍺=+/¨⍵},⍳⍵/⍺}

mबाएं तर्क के nरूप में , सही तर्क के रूप में लेता है।

लगभग आधे (के बीच {और ⍺) की आवश्यकता फ़ॉर्मेट करने के लिए है।

Answer 7

मैथेमेटिका, 65 बाइट्स

StringRiffle[Permutations/@#~IntegerPartitions~{#2},"
","
",","]&

IntegerPartitionsकार्य करता है। बाकी केवल टुप्लस को ऑर्डर करने और परिणाम को प्रारूपित करने के लिए है।

Answer 8

अजगर 3, 112

from itertools import*
lambda m,n:'\n'.join(','.join(map(str,x))for x in product(range(m),repeat=n)if sum(x)==m)

मैंने थोड़ी देर में 1 लाइनर प्रबंधित नहीं किया है। :)

Answer 9

पायथन 2.7, 174 170 152 बाइट्स

मोटा जवाब। कम से कम यह पठनीय है :)

import sys,itertools
m=int(sys.argv[1])
for k in itertools.product(range(1,m),repeat=int(sys.argv[2])):
    if sum(k)==m:print str(k)[1:-1].replace(" ","")

Comments

आप कॉमा के बाद >, उसके बाद replaceऔर उसके आसपास रिक्त स्थान निकाल सकते हैं ।

— एलेक्स ए।

Answer 10

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

f(m,n)=for u=∪(reduce(vcat,map(i->collect(permutations(i)),partitions(m,n)))) println("$u"[2:end-1])end

यह एक फ़ंक्शन है जो दो पूर्णांक तर्कों को पढ़ता है और परिणामों को एक एकल अनुरेखण लाइन फ़ीड के साथ लिखता है।

Ungolfed:

function f(m::Integer, n::Integer)
    # Get the integer partitions of m of length n
    p = partitions(m, n)

    # Construct an array of all permutations
    c = reduce(vcat, map(i -> collect(permutations(i)), p))

    # Loop over the unique elements
    for u in unique(c)
        # Print the array representation with no brackets
        println("$u"[2:end-1])
    end
end

Answer 11

पर्ल 6 , 54 बाइट्स

यदि आउटपुट सूचियों की सूची हो सकती है

{[X] (1..$^m)xx$^n .grep: $m==*.sum} # 36 bytes

my &code = {[X] (1..$^m)xx$^n .grep: $m==*.sum}
say .join(',') for code 7,3;

---

जिस तरह से यह वर्तमान में शब्द है मुझे एक जोड़ना होगा join ।

{say .join(',')for [X] (1..$^m)xx$^n .grep: $m==*.sum} # 54 bytes

{...}( 7,3 );

1,1,5
1,2,4
1,3,3
1,4,2
1,5,1
2,1,4
2,2,3
2,3,2
2,4,1
3,1,3
3,2,2
3,3,1
4,1,2
4,2,1
5,1,1