N के सभी क्रमबद्ध विभाजन को सूचीबद्ध करें

Question

चुनौती किसी दिए गए सकारात्मक पूर्णांक के सभी क्रमबद्ध विभाजनों (रचना (संयोजन)) को सूचीबद्ध करना है n। ये संख्याओं की सूची है 1कि nकिसका योग है n। उदाहरण के लिए, दिए गए इनपुट n = 4, परिणाम होना चाहिए:

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

परिणाम किसी भी क्रम में हो सकता है, लेकिन प्रत्येक क्रमबद्ध विभाजन को एक बार शामिल करना होगा। इस साधन के लिए है कि n = 4, [1, 1, 2], [1, 2, 1]और [2, 1, 1]सभी परिणाम का हिस्सा होना चाहिए।

यहाँ मेरा अपना जावास्क्रिप्ट कोड है जो इसे प्राप्त करता है:

function range(n) {
    for (var range = [], i = 0; i < n; range.push(++i));
    return range;
}

function composition(n) {
    return n < 1 ? [[]] : range(n).map(function(i) {
        return composition(n - i).map(function(j) {
            return [i].concat(j);
        });
    }).reduce(function(a, b) {
        return a.concat(b);
    });
}

गोल्फ, ईएस 6 ( 169 167 119 109 105 89 85 बाइट्स ):

n=>n?[].concat(...[...Array(n)].map((x,i)=>i+1).map(b=>m(n-b).map(a=>[b,...a]))):[[]]

Comments

साइट पर आपका स्वागत है! आपको एक विजेता मानदंड निर्दिष्ट करने की आवश्यकता है। कोड-गोल्फ शायद? इसके अलावा, क्या यह उस विशिष्ट क्रम में होना चाहिए? यदि हां, तो आदेश को सामान्य रूप से कैसे परिभाषित किया जाता है? मुझे लगता है कि lexicographic आदेश अधिक सार्थक होगा; या बेहतर अभी तक, किसी भी आदेश की अनुमति दें। आप उन्हें यहां पोस्ट करने से पहले भविष्य की चुनौतियों के लिए सैंडबॉक्स का उपयोग करना चाह सकते हैं

— लुइस मेंडो सेप

@Fatalize यहाँ [2 1 1] वहाँ के विपरीत [1 2 1] से अलग है। मुझे संदेह है कि दृष्टिकोण काफी भिन्न हो सकते हैं

— लुइस मेंडो सेप

जो लोग ठग के रूप में बंद हुए हैं: क्या आप सुनिश्चित हैं कि टिप्पणियों में इंगित अंतर प्रासंगिक नहीं है? मैं फिर से मतदान नहीं कर रहा हूँ, क्योंकि मुझे लगता है कि हथौड़ा भी उसी दिशा में काम करेगा

— लुइस मेंडू सेप

मैं एक उत्तर अभी तक स्वीकार नहीं करने का सुझाव दूंगा (भले ही आप इसे किसी भी समय बदल सकते हैं) क्योंकि सामने वाले पृष्ठ पर स्वीकार किए गए प्रश्न को देखकर लोग यह सोच सकते हैं कि यह खत्म हो गया है और भाग नहीं लिया है।

— xnor

इन आदेशित विभाजनों के लिए सामान्य शब्द " रचनाएं " हैं।

— ग्रेग मार्टिन

Answer 1

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

7 बाइट समाधान:

Pyth का पूर्णांक विभाजन बिल्ट है ./, इसलिए 7 बाइट्स में से 5 को ऑर्डर मिल रहा है।

{s.pM./

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

स्पष्टीकरण:

     ./  Integer partition (sorted by default)
  .pM    get all the orderings of each of the partitions as a nested list of lists of orderings
 s       Flatten by one layer
{        Remove duplicates

6 बाइट समाधान:

यदि आपके पास एक सूची है, तो ./आदेशों के साथ गणना करेंगे; वह सब जो सूची संख्याओं को फिर से बनाने के लिए है।

lMM./m

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

स्पष्टीकरण:

     m  Get lists by gathering a list of [0, 1,...input] (I could use U as well)

   ./   Partition with orderings
 MM     Map an operation across each of the orderings lists of elements
l       where that operation is the length of the sublists

Comments

गजब का। यह सबसे छोटा है जिसे मैंने अब तक देखा है!

— 28 अक्टूबर

Answer 2

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

f 0=[[]]
f n=[a:x|a<-[1..n],x<-f$n-a]

xnor ने दो बाइट्स बचाए।

Comments

ऐसा लगता है कि अधिक सीधा f n=[a:x|a<-[1..n],x<-f$n-a]कम है।

— 10

आपको शून्य चेक ( given positive integer n ... numbers from 1 to n)

— nyro_0

f 0=[[]]बस एक छोटा सा बेस केस होता है f 1=[[1]]:)

— लिन

@xyLe_ इसमें एक पुनरावर्ती आधार मामले का उपयोग किया गया है।

— xnor

यकीन है, तुम सही हो, मेरे बुरे

— nyro_0

Answer 3

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

f=lambda n:[x+[n-i]for i in range(n)for x in f(i)]or[[]]

एक पुनरावर्ती समाधान: का आदेश दिया विभाजन nकुछ छोटे के एक विभाजन कर रहे हैं iके साथ 0<=i<n, शेष के बाद n-iपिछले तत्व के रूप में। आधार मामले के लिए, n=0केवल खाली विभाजन है।

Comments

सरल, छोटा और अभी भी आश्चर्यजनक पठनीय है। यही मुझे पाइथन से प्यार है।

— ड्रिमिमा

Answer 4

पायथन 2, 61 बाइट्स

f=lambda n,s='1,':1/n*[eval(s)]or f(n-1,'1+'+s)+f(n-1,'1,'+s)

यह सबसे छोटा नहीं है, लेकिन मुझे वास्तव में यह पसंद है क्योंकि यह बहुत अजीब है।

पुनरावर्ती रूप से 2**(n-1)तार उत्पन्न करता है और मूल्यांकन करता है , जैसे

1+1+1+1,
1,1+1+1,
1+1,1+1,
1,1,1+1,
1+1+1,1,
1,1+1,1,
1+1,1,1,
1,1,1,1,

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

Comments

सर्वश्रेष्ठ गैर-पुनरावर्ती संस्करण मैं कर सकता थाimport re lambda n:map(lambda n:map(len,re.finall('10*',bin(n))),range(1<<n-1,1<<n))

— नील

कोड के साथ एक स्पष्टीकरण वास्तव में इसे सुंदर बना देगा।

— नोमान पौगेट सेप

Answer 5

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

f=n=>n?[for(i of Array(n).keys())for(a of f(i))[n-i,...a]]:[[]]

Comments

फ़ायरफ़ॉक्स 30+ इंटरनेट के अधिक परिपक्व उपयोगकर्ताओं के लिए एक विशेष ब्राउज़र की तरह लगता है।

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

संभवत: इससे छोटा नहीं होता ...

— ETHproductions

किसी भी तरह से यह अन्य ब्राउज़रों में जावास्क्रिप्ट के लिए ungolfed किया जा सकता है?

— ड्रिमिमा

@ अनंत काल मैं आपके लिए @ xnor के अन्य उत्तर को पोर्ट कर सकता हूं f=n=>n<2?[[1]]:f(n-1).map(([n,...a])=>r.push([1+n,...a],[1,n,...a]),r=[])&&r:।

— नील

Answer 6

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

Join@@Permutations/@IntegerPartitions@#&

Mathematica के बिल्ट-इन पूर्णांक विभाजन के लिए सभी क्रमबद्ध विभाजन नहीं देते हैं , इसलिए हमें उनमें से प्रत्येक के सभी संभावित क्रम उत्पन्न करने होंगे, और फिर परिणाम को समतल करना होगा।

Answer 7

CJam , 17 14 बाइट्स

ri"X)"m*{~]p}/

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

व्याख्या

मुझे पता है कि मैंने कहा कि कार्टेशियन उत्पाद का उपयोग करना अधिक लंबा है, लेकिन मैंने इसे और अधिक कुशलता से उपयोग करने का एक तरीका ढूंढ निकाला। मुझे लगता है कि दोनों दृष्टिकोण अपने आप में दिलचस्प हैं, इसलिए मैं उन्हें अलग-अलग पोस्ट में डाल रहा हूं।

यह अभी भी इस विचार पर आधारित है कि, हम वर्तमान विभाजन को लागू करने या वर्तमान विभाजन के अंतिम तत्व को बढ़ाने के nबीच का समय चुन सकते हैं 1। इस समाधान में, हम 2 ^n-1 अलग ^- अलग कार्यक्रमों को उत्पन्न करके ऐसा करते हैं जो इन विभिन्न विकल्पों के अनुरूप हैं।

ri      e# Read input and convert to integer N.
        e# Decrement.
"X)"m*  e# Get all strings of length N which consist of 'X' and ')'. If
        e# we treat these strings as CJam code then 'X' pushes a 1 and ')'
        e# increments the top of the stack.
        e# Note that some of these strings will begin with an increment that
        e# doesn't have anything on the stack to work with. This will result in
        e# an error and terminate the program. Luckily, the programs are ordered
        e# such that all programs starting with 'X' are first in the list, so
        e# we get to print all the 2^(N-1) permutations before erroring out.
{       e# For each of these programs (well for the first half of them)...
  ~     e#   Evaluate the string as CJam code. This leaves the partition as
        e#   individual integers on the stack.
  ]p    e#   Wrap the stack in a list and pretty-print it.
}/

Comments

मैंने इसे देखा और सोचा " यह सही नहीं हो सकता है, यह एक त्रुटि देगा जब यह पहली स्ट्रिंग का मूल्यांकन करता है जो इसके साथ शुरू होता है) "। इसलिए मैंने जोड़ा edऔर परीक्षण किया। त्रुटि के रचनात्मक दुरुपयोग के लिए +1।

— पीटर टेलर

Answer 8

जेली , 7 6 बाइट्स

@ बाइट के लिए -1 बाइट धन्यवाद ( ḅ1प्रत्येक के लिए प्रत्येक राशि के बजाय एकात्मक से परिवर्तित करें S€€)

1ẋŒṖḅ1

TryItOnline

कैसे?

1ẋŒṖḅ1 - Main link: n          e.g. 4
1ẋ     - repeat 1 n times          [1,1,1,1]
  ŒṖ   - partitions of a list     [[[1],[1],[1],[1]], [[1],[1],[1,1]], [[1],[1,1],[1]],
                                   [[1],[1,1,1]],     [[1,1],[1],[1]], [[1,1],[1,1]],
                                   [[1,1,1],[1]],     [[1,1,1,1]]]
    ḅ1 - from base 1 (vectorises)  [[1,1,1,1],        [1,1,2],         [1,2,1],
                                   [1,3],             [2,1,1],         [2,2],
                                   [3,1],             [4]]

Answer 9

शुद्ध बैश, 51

यह @ xnor के शानदार उत्तर का एक बंदरगाह है , जो वांछित परिणाम प्राप्त करने के लिए कई स्तरों के बैश विस्तार का उपयोग करता है:

a=$[10**($1-1)]
eval echo \$[${a//0/{+,']\ $[}1'}],

Ideone।

• पहली पंक्ति बस एक अंकगणितीय विस्तार एक चर बनाने के लिए है $aयुक्त 1के बाद n-1शून्य।
• पहला विस्तार स्ट्रिंग की प्रतियों के साथ ${a//0/{+,']\ $[}1'}प्रत्येक 0को बदलता है । इस प्रकार n = 4 हम स्ट्रिंग प्राप्त करते हैं$a{+,']\ $[}1'1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1'
• यह उपसर्ग के साथ है $[और postfixed साथ ],करने के लिए दे$[1{+,']\ $[}1'{+,']\ $[}1'{+,']\ $[}1]
• यह एक ब्रेस विस्तार है जिसका विस्तार होता है $[1+1+1+1], $[1+1+1] 1, $[1+1] $[1+1], $[1+1] 1 1,...
• यह अंततः आवश्यक परिणाम देने के लिए अंकगणितीय रूप से विस्तारित किया जाता है।

उद्धरण, बैकस्लैश से बचने का सावधानीपूर्वक उपयोग और evalयह सुनिश्चित करता है कि विस्तार सही क्रम में हो।

Answer 10

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

f=->n{n<1?[[]]:(1..n).map{|i|f[n-i].map{|x|x<<i}}.flatten(1)}

ungolfed

f=->n{
  n < 1 ?
    [[]]
  :
    (1..n).map { |i|
      f[n-i].map { |x|
        x << i
      }
    }.flatten(1)
}

प्रयोग

p f[4]
# => [[1, 1, 1, 1], [1, 1, 2], [1, 2, 1], [1, 3], [2, 1, 1], [2, 2], [3, 1], [4]]

Comments

हिया! क्या आप उन लोगों (जैसे मेरे) के लिए थोड़ा सा स्पष्टीकरण जोड़ सकते हैं जो रूबी से परिचित नहीं हैं?

— AdmBorkBork 12

x<<iसे छोटा है [i]+x।

— m-chrzan

@ टिम्मीड I ने एक असम्बद्ध कोड और उपयोग जोड़ा।

— cia_rana

@ m-chrzan आपकी सलाह के लिए धन्यवाद! मैंने उसे संपादित किया।

— cia_rana

कोई कारण .flatten(1)नहीं है .flatten 1?

— साइओस

Answer 11

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

~lL#++?,L:=f:{:0x}ad

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

व्याख्या

यह एक ऐसी स्थिति है जहां आपको लगता है कि घोषणात्मक भाषाएं अच्छा करेंगी, लेकिन ओवरलोडिंग +और अलग-अलग तरीके से एक योग लिखने में व्यापकता के कारण जो कि बाधाओं का ठीक से प्रचार करता है, वे नहीं करते हैं।

~lL                     L is a list of length Input
  L#+                   L is a list of non-negative integers
  L  +?,                The sum of the elements of L results in the Input
        L:=f            Find all values for the elements of L which satisfy those constraints
            :{:0x}a     Remove all 0s from each sublist of the result of Findall
                   d    Remove all duplicate sublists

Comments

मुझे लगता है कि यह तेजी से अगर आप पर ध्यान केंद्रित एक बहुत प्रचार होगा सकारात्मक पूर्णांक, और की लंबाई जाने Lहोना के बीच 1 और इनपुट।

— मैट

@mat यह वही है जो मैंने मूल रूप से किया था लेकिन यह अधिक लंबा है । चूंकि +यह एक पूर्णांक पर भी काम करता है, इसलिए मुझे इसके .साथ एक सूची बनाने के लिए बाध्य करने की आवश्यकता है ##, और चूंकि +यह सूची की सूची पर भी काम करता है, इसलिए मुझे यह आरोप लगाने की आवश्यकता है कि तत्व .पूर्णांक के साथ हैं :#$a।

— 15

तो मुख्य मुद्दा डेटा संरचनाओं की डिफ़ॉल्टता है: जब एक चर ऑपरेशन के तर्क के रूप में प्रकट होता है जो वेक्टर होता है, तो आप यह नहीं बता सकते हैं कि चर एकल पूर्णांक या (संभवतः नेस्टेड) ​​सूची के लिए है। यह एक कठिन मुद्दा है, और इसे हल करने का एक सुंदर तरीका हो सकता है, अपने मूल संस्करण से शुरू होकर उपयुक्त भाषा निर्माण की खोज करना जो इसे सरल बना सके। किसी भी मामले में अच्छा काम!

— Mat

Answer 12

CJam , 19 बाइट्स

Lari{_1af.+1@f+|}*p

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

व्याख्या

CJam में पूर्णांक विभाजन के लिए एक उपयोगी कॉम्बिनेटरिक्स नहीं है। तो हम इसे मैन्युअल रूप से करेंगे। पूर्णांक के सभी क्रमबद्ध विभाजनों को खोजने के लिए n, हम nलोगों की एक सूची देख सकते हैं और विभाजकों को सम्मिलित करने के लिए हर संभव तरीके पर विचार कर सकते हैं । फिर हम 1प्रत्येक सेक्शन में योग करेंगे । इसके लिए उदाहरण n = 3:

1 1 1 => 3
1 1|1 => 2|1
1|1 1 => 1|2
1|1|1 => 1|1|1

मैंने इन सभी विभाजकों को उत्पन्न करने के लिए कार्टेशियन उत्पाद का उपयोग करने की कोशिश की, लेकिन यह 21 बाइट्स में समाप्त हो गया। इसके बजाय मैं पावर सेट बनाने के लिए इस पुरानी तकनीक पर वापस गया (यह डेनिस के एक पुराने उत्तर पर आधारित है लेकिन मैं इसे अभी नहीं पा सकता हूं)। विचार यह है: सभी विभाजन उत्पन्न करने के लिए हम एक खाली सूची से शुरू कर सकते हैं। फिर nकई बार हम एक द्विआधारी निर्णय ले सकते हैं: या तो हम एक संलग्न करते हैं 1(उपरोक्त उदाहरण में एक विभाजक से मेल खाते हैं) या हम सूची के अंतिम मूल्य को बढ़ाते हैं (एक विभाजक नहीं होने से मेल खाती है)। सभी विभाजन उत्पन्न करने के लिए, हम बस प्रत्येक चरण में दोनों ऑपरेशन करते हैं और अगले चरण के लिए सभी संभव आउटपुट रखते हैं। यह पता चला है कि CJam में, पहले तत्व को छोटा करना और बढ़ाना कम है, लेकिन सिद्धांत समान है:

La       e# Push [[]] onto the stack. The outer list will be the list of
         e# all possible partitions at the current iteration, and we initialise
         e# it to one empty partition (basically all partitions of 0).
ri       e# Read input and convert to integer N.
{        e# Repeat this N times...
  _      e#   Duplicate the list of partitions of i-1.
  1af.+  e#   Increment the first element in each of these. This is done
         e#   by performing a pairwise addition between the partition and [1].
         e#   There is the catch that in the first iteration this will turn
         e#   the empty array into [1], so it's equivalent to the next step.
  1@f+   e#   Pull up the other copy of the list of partitions of i-1 and
         e#   prepend a 1 to each of them.
  |      e#   Set union. This gets rid of the duplicate result from the first
         e#   iteration (in all other iterations this is equivalent to concatenating
         e#   the two lists).
         e#   Voilà, a list of all partitions of i.
}*
p        e# Pretty-print the result.

Answer 13

टी-एसक्यूएल, 203 बाइट्स

golfed:

USE master
DECLARE @ INT=12

;WITH z as( SELECT top(@)cast(number+1as varchar(max))a FROM spt_values WHERE'P'=type),c as(SELECT a*1a,a b FROM z UNION ALL SELECT c.a+z.a,b+','+z.a FROM c,z WHERE c.a+z.a*1<=@)SELECT b FROM c WHERE a=@

Ungolfed:

USE master --needed to make sure it is executed from the correct database
DECLARE @ INT=12

;WITH z as
(
  SELECT top(@)cast(number+1as varchar(max))a
  FROM spt_values
  WHERE'P'=type
),c as
(
  SELECT a*1a,a b
  FROM z
  UNION ALL
  SELECT c.a+z.a,b+','+z.a
  FROM c,z
  WHERE c.a+z.a*1<=@
)
SELECT b 
FROM c
WHERE a=@

बेला

Answer 14

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

विभाजन से संबंधित निर्मितियों का उपयोग किए बिना एक प्रयास। आकार k के प्रत्येक क्रमबद्ध विभाजन से , k + 1 के दो उत्तराधिकारी विभाजन उत्पन्न होते हैं: एक पूर्ववर्ती 1 द्वारा, और दूसरा पहला मान बढ़ाकर।

Nest[##&[{1,##},{#+1,##2}]&@@@#&,{{1}},#-1]&

एक मजेदार, लेकिन दुख की बात है कि 2 बाइट्स समान विचार को लागू करने का लंबा रास्ता तय करते हैं:

#@{1}&/@Tuples[Prepend[1]@*MapAt[#+1&,1],#-1]&

Comments

@alephalpha नहीं, वह तब मदद नहीं करेगा जब तक मुझे MapAtइंडेक्स -1 में बदलना होगा ।

— feersum

Answer 15

05AB1E , 14 12 बाइट्स

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

>G¹LNãvyO¹Q—

व्याख्या

>G              # for N in range(1..input)
  ¹L            # range(1, input)
    Nã          # cartesian product with N (all combinations of length N)
      v         # for each resulting list
       yO¹Q—    # if it's sum equals the input print it

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

संबंधित समाधान 2 बाइट्स में 2 बाइट्स छोटा होता है ।

2sable , 10 बाइट्स

>GLNãvyOQ—

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

Comments

आप —इसके बजाय iy,:) का उपयोग कर सकते हैं ।

— अदनान

@ अदनान: धन्यवाद! उस एक के बारे में भूल गए।

— एमिग्ना

Answer 16

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

f 1=[[1]]
f n=do a:b<-f$n-1;[1:a:b,a+1:b]

कम से कम हास्केल समाधान नहीं है, लेकिन मुझे यह पसंद है कि यह [..]श्रेणियों का उपयोग नहीं करता है। इसके बजाय, यह पुनरावर्ती nरूप से विभाजन के रूप में गणना करता है n-1या तो एक नया 1 के साथ शुरू होता है या पहला मूल्य एक उच्च होता है। यह स्पष्ट करता है कि 2^(n-1)उनमें से क्यों है।

Answer 17

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

मार्टिन एंडर के जवाब को हरा नहीं करता है, जो बिल्ट-इन का उपयोग करता है IntegerPartitions फ़ंक्शन (और बिल्ट-इन मेरे द्वारा पूरी तरह से ठीक हैं)। (और न ही यह feersum के जवाब को हरा देता है, जिसे मैंने बहुत देर तक नहीं देखा था।) लेकिन मैं एक गोल्फ पुनरावर्ती कार्य का अभ्यास करना चाहता था।

If[#<1,{{}},Join@@Table[#~Append~j&/@#0[#-j],{j,#}]]&

रिकर्सिवली सभी संभव अंतिम संख्या उत्पन्न करके, सभी रचनाओं उत्पन्न करता है jऔर उसके बाद पर ही बुला #-jजहां #इनपुट है।

Comments

आप एक सूची का उपयोग करके और इससे बचने के Arrayबजाय एक ऑपरेटर को परिभाषित करके और :TableAppendApply±0={{}};±n_:=Join@@Array[{##,n-+##}&@@@±#&,n,0]

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

क्या करता @@है?

— साइयो

यह एक अभिव्यक्ति के "सिर" की जगह लेता है। उदाहरण के लिए, का f@@g[a,b]मूल्यांकन करता है f[a,b]। यहां हम इस तथ्य का उपयोग कर रहे हैं कि { { {1,1,1}, {2,1} } , { {1,2} }, { {3} } }अदृश्य रूप से एक सूची में सिर है List; इसलिए Join@@{ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } }मूल्यांकन करने के लिए Join@@List[ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } ]मूल्यांकन करने के लिए Join[ { {1,1,1}, {2,1} } , { {1,2} }, { {3} } ]मूल्यांकन करता है { {1,1,1}, {2,1}, {1,2}, {3} }।

— ग्रेग मार्टिन

Answer 18

रेटिना , 32 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$*
+%1`1
!$'¶$`,!
!+
$.&
A`^,

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

व्याख्या

यह मेरे CJam उत्तर के समान है । हम एक सूची के माध्यम से जाते Nहैं और प्रत्येक स्थिति में हम बाइनरी निर्णय की दोनों शाखाओं को लेते हैं a) अंतिम मान बढ़ाते हैं या b) 1 पर एक नया मान शुरू करते हैं।

चरण 1

.+
$*

इनपुट को unary में बदलें।

चरण 2

+%1`1
!$'¶$`,!

+रेटिना बताता है एक पाश में इस स्तर पर अमल करने तक उत्पादन बदल रहा बंद हो जाता है। %यह इनपुट लाइनों में चरण लागू करने से पहले वापस एक साथ बाद में विभाजित है और उन्हें शामिल होने के लिए कहता है। के %बाद लगाकर+ , रेटिना विभाजन और प्रत्येक पुनरावृत्ति के बाद जुड़ता है। मंच का एक पुनरावृत्ति उन निर्णयों में से एक बनाता है जिनका मैंने उल्लेख किया है और इस तरह विभाजन के वर्तमान सेट को द्विभाजित करता है।

यह वास्तव में कैसे काम करता है कि यह एक से मेल खाता है 1(लेकिन केवल पहले वाले के रूप 1में बैकटिक के सामने दर्शाया गया है ), और इसे बदल देता है !(जिसका उपयोग हम अपने आउटपुट के एक अंक के रूप में करेंगे), इसके बाद शेष 1s इस पंक्ति पर (यह अंतिम मान बढ़ाता है)। फिर एक और लाइन ( ¶) पर यह वर्तमान लाइन के उपसर्ग को प्रिंट करता है, उसके बाद ,!, जो एक विभाजक को सम्मिलित करता है और फिर अगले मूल्य को शुरू करता है 1।

स्टेज 3

!+
$.&

यह !दशमलव पूर्णांक के रनों को उनकी लंबाई के साथ बदलकर परिवर्तित करता है ।

स्टेज 4

A`^,

और अंत में, हम नोटिस करते हैं कि हमने दो बार जितनी लाइनें चाहें, उतनी बार उत्पन्न की हैं, और उनमें से आधी एक के साथ शुरू होती हैं ,(उन जगहों पर जहां हमने शुरू में विभाजन का निर्णय लिया था, भले ही अभी तक विभाजन के बाद कुछ भी नहीं था)। इसलिए, हम उन सभी लाइनों को छोड़ देते हैं जो एक से शुरू होती हैं ,।

Answer 19

पर्ल, 44 बाइट्स

-n(कोड का उपयोग करता है) के लिए +3 शामिल है $'और $0इसलिए इसे एक के रूप में नहीं चलाया जा सकता है-e कमांडलाइन के )

STDIN पर विभाजन के लिए नंबर दें:

partitions.pl <<< 4

partitions.pl

#!/usr/bin/perl -n
$_=$&-$_.",$_$'",do$0for/\d+/..$&-1;print

यदि आप एक पंक्ति के अंत और एक अतिरिक्त न्यू लाइन इस 42 बाइट समाधान भी काम करता है पर अतिरिक्त रिक्त स्थान कोई आपत्ति नहीं है (के रूप में चलाने perl -M5.010 partitions.pl):

#!/usr/bin/perl -n
$_=$`-$_." $_ $'",do$0for/\s/..$_-1;say

Answer 20

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

f(N)=unique(reduce(vcat,(map(x->[permutations(x)...],[vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N]))))

गैर-पुनरावर्ती समाधान

व्याख्या की:

1. [vcat([1 for _=i+1:N],sum([1 for _=N-i:N-1])) for i=1:N] N को राशि देने वाली सूचियों का एक सेट बनाएँ, जिनके क्रमपरिवर्तन समाधान के समान होंगे (जैसे N = 4 के लिए: [[1,1,1,1], [1,1,2], [1,3], [4 ]])
2. map(x->[permutations(x)...],) सभी क्रमपरिवर्तन की गणना करें
3. reduce(vcat,) उन्हें सूचियों की सूची में मिलाएं
4. unique() फ़िल्टर डुप्लिकेट करता है

Comments

हमें पूर्ण कार्यक्रम या कार्य करने के लिए सबमिशन की आवश्यकता होती है, इसलिए इस मामले में आपको Nइनपुट के रूप में लेना होगा । आप N->3 बाइट्स की कीमत पर प्रीपेडिंग करके लंबोदर फंक्शन कर सकते हैं ।

— एलेक्स ए।

@AlexA। आह, माफ करना f(N)=, नकल करने में हार गए, बाइट्स गिनते समय मैंने ऐसा किया है

— nyro_0

Answer 21

MATL , 15 बाइट्स

:"G:@Z^t!XsG=Y)

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

व्याख्या

इनपुट को देखते हुए n, इस एक्स्पोनेंट्स में वृद्धि के साथ कार्तीय बिजली की गणना kसे 1करने के लिए n; और प्रत्येक प्रतिपादक kउन टुपल्स का चयन करता है जिनके पास इनपुट के बराबर राशि होती है।

:       % Take input n implicitly and push range [1 2 ... n]
"       % For each k in that range
  G:    %   Push [1 2 ... n] again
  @     %   Push k
  Z^    %   Cartesian power. Gives 2D array, say A, with each k-tuple in a row.
  t     %   Duplicate
  !     %   Transpose
  Xs    %   Sum of each column. Gives a row vector
  G=    %   True for entries that equal the input
  Y)    %   Use as logical vector into the rows of array A
        % End implicitly
        % Display stack implicitly

Answer 22

लुआ 214 203 182 बाइट्स

function g(m, l, n,c)for i=1,m do if i+n < m then l[#l+1]=i;g(m,l,n+i,c+1)elseif i+n == m then l[#l+1]=i;print(unpack(l))end end for k=c,#l do l[k]=nil end end g(io.read()*1,{},0,0)

अनगढ़ संस्करण।

function g(m, l, n,c)
    for i=1,m do 
        if i+n < m then 
            l[#l+1]=i
            g(m,l,n+i,c+1)
        elseif i+n == m then 
            l[#l+1]=i
            print(unpack(l))
        end 
    end 
    for k=c,#l do 
        l[k]=nil 
    end 
end 
g(io.read()*1,{},0,0)

एक भटके हुए व्हाट्सएप को मिला और एक अनावश्यक चर को सुरक्षित करके 11 बाइट्स को हटा दिया गया। जैसा कि यह पता चला है, table.insert () बाइट अक्षम है

Answer 23

PHP, 125 बाइट्स

for($i=$n=$argv[1];$i<=str_repeat(1,$n);$i++)if(array_sum($a=str_split($i))==$n&!strpos($i,"0"))$r[]=$a;echo json_encode($r);

के print_r($r);बजाय के लिए -4 बाइट्सecho json_encode($r); आउटपुट के लिए

250 बाइट्स के साथ एक पुनरावर्ती समाधान

function f($n){global$a;foreach($a as$x)foreach(range(1,$n)as$y)$a[]=array_merge((array)$x,[$y]);if(--$n)f($n);}$a=range(1,$w=$argv[1]);f($w-1);foreach($a as$z)if(array_sum((array)$z)==$w)$c[join("-",(array)$z)]=$z;echo json_encode(array_values($c));

Answer 24

प्रोलॉग, कॉल करने के लिए 81 बाइट्स + 6 बाइट्स

L*L.
[H|T]*L:-H>1,M is H-1,[M,1|T]*L.
[H,K|T]*L:-H>1,M is H-1,N is K+1,[M,N|T]*L.

इसे ऑनलाइन आज़माएं!
के साथ बुलाना[4]*L. , साथ दोहराएं;तब तक जब तक सभी समाधान प्रस्तुत नहीं किए जाते हैं।

वैकल्पिक रूप से, यदि बार-बार दबाव ;ठीक नहीं है (या बाइट की गिनती में जोड़ा जाना चाहिए), bagof(L,[4]*L,M).जिसके साथ कॉल के लिए 17 बाइट्स कहते हैं।

Answer 25

जे , 30 26 बाइट्स

#&1<@(+/;.1)~2#:@(+i.)@^<:

2 ^एन के द्विआधारी मूल्यों का उपयोग करके यूनिरी एन की सूची को विभाजित करके काम करता है ।

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

व्याख्या

#&1<@(+/;.1)~2#:@(+i.)@^<:  Input: n
                        <:  Decrement n
             2         ^    Compute 2^(n-1)
                 (   )@     Operate on that
                   i.         Make the range [0, 1, ..., 2^(n-1)-1]
                  +           Add 2^(n-1) to each in that range
              #:@           Convert each in that range to binary
#&1                         Make n copies of 1 (n in unary)
     (     )~               Operate over each row on RHS and unary n on LHS
        ;.1                   Chop unary n starting at each 1
      +/                        Reduce by addition on each chop
   <@                           Box the sums of each chop

Answer 26

दरअसल, १ 17 16 बाइट्स

यह उत्तर आंशिक रूप से लुइस मेंडो के MATL उत्तर पर आधारित है । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

;╗R`╜R∙i`M`Σ╜=`░

Ungolfing

         Implicit input n.
;╗       Duplicate n and save a copy of n to register 0.
R        Take the range of [1..n].
`...`M   Map the following function over the range. Variable k.
  ╛R       Push n from register 0 and take the range [1..n] again.
  ∙        Take the k-th Cartesian power of the range.
  i        Flatten that product.
`...`░   Push values of the previous map where the following function returns a truthy value.
          Variable L.
  Σ        Push sum(L).
  ╜        Push n from register 0.
  =        Check if sum(L) == n.
         Implicit return.

Answer 27

दरअसल, 17 16 15 बाइट्स

यह मार्टिन एंडर के सीजेम उत्तर का एक दिलचस्प कांटा है (कार्टेशियन उत्पाद के साथ एक) , जिसके कार्यान्वयन में एक अंतर है जो मुझे लगा कि यह दिलचस्प था। जब मार्टिन के तारों में से एक वृद्धि के साथ शुरू होता है, तो त्रुटियां उस स्ट्रिंग का मूल्यांकन करने से रोकती हैं। वास्तव में, त्रुटि को दबा दिया जाता है और स्ट्रिंग का मूल्यांकन वैसे भी किया जाता है। यह kसीमा में हर की रचनाओं को समाप्त करता है[1..n] ।

अतिरिक्त रचनाओं को हटाने की कोशिश करने के बजाय, मैंने एप्लाइड ए की n-1वें कार्टेशियन पावर ली"1u""1" प्रत्येक स्ट्रिंग की शुरुआत में । यह ट्रिक केवल की रचनाएँ देती है n। यह दुर्भाग्य से, मार्टिन के जवाब से अधिक लंबा है।

गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

D"1u"∙`1@Σ£ƒk`M

Ungolfing

         Implicit input n.
D        Decrement n.
"1u"∙    Take the (n-1)th Cartesian power of the string "1u".
          In Actually, 1 pushes 1 to the stack and u is increment.
`...`M   Map the following function over the Cartesian power. Variable s.
  1@       Push a 1 to be used later.
  Σ        Summing a list of chars joins the chars into one string.
  £ƒ       Turn s into a function and call it immediately on the 1 in the stack.
  k        Take the whole stack and wrap in a list. This is a composition of n.
         Implicit return.