N के विभाजन की गणना करें

Question

आपकी चुनौती सरल है: एक पूर्णांक एन को जीआईएन करें , सकारात्मक पूर्णांकों की प्रत्येक सूची को अलग कर देता है जो कि एन को देता है । उदाहरण के लिए, यदि इनपुट 5 था, तो आपको आउटपुट करना चाहिए

[1, 1, 1, 1, 1]
[1, 1, 1, 2]
[1, 1, 3]
[1, 2, 2]
[1, 4]
[2, 3]
[5]

इन सूचियों को किसी विशेष क्रम में आउटपुट नहीं करना है, और न ही प्रत्येक सूची के अंदर संख्याएँ हैं। उदाहरण के लिए, यह भी '5' के लिए एक स्वीकार्य आउटपुट होगा:

[1, 1, 1, 2]
[5]
[3, 1, 1]
[2, 1, 2]
[4, 1]
[1, 1, 1, 1, 1]
[2, 3]

आप सुरक्षित रूप से मान सकते हैं कि इनपुट एक सकारात्मक पूर्णांक होगा, और आप इस संख्या को किसी भी उचित प्रारूप में ले सकते हैं।

आप ऐसा करने वाले किसी भी अंतर्निहित कार्यों का उपयोग नहीं कर सकते हैं ।

यदि आपका प्रोग्राम या तो विफल रहता है या बड़े एन के लिए बहुत लंबा है तो यह ठीक है, लेकिन आपको पहले 15 के लिए सही आउटपुट का उत्पादन करना चाहिए।

स्टैंडर्ड लूपहोल्स लागू होते हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है!

परीक्षण IO

1:
[[1]]

2:
[[1, 1], [2]]

3:
[[1, 1, 1], [1, 2], [3]]

4:
[[1, 1, 1, 1], [1, 1, 2], [1, 3], [2, 2], [4]]

5:
[[1, 1, 1, 1, 1], [1, 1, 1, 2], [1, 1, 3], [1, 2, 2], [1, 4], [2, 3], [5]]

7:
[[1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 3], [1, 1, 1, 2, 2], [1, 1, 1, 4], [1, 1, 2, 3], [1, 1, 5], [1, 2, 2, 2], [1, 2, 4], [1, 3, 3], [1, 6], [2, 2, 3], [2, 5], [3, 4], [7]]

10:
[[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 2], [1, 1, 1, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 1, 2, 2], [1, 1, 1, 1, 1, 1, 4], [1, 1, 1, 1, 1, 2, 3], [1, 1, 1, 1, 1, 5], [1, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 2, 4], [1, 1, 1, 1, 3, 3], [1, 1, 1, 1, 6], [1, 1, 1, 2, 2, 3], [1, 1, 1, 2, 5], [1, 1, 1, 3, 4], [1, 1, 1, 7], [1, 1, 2, 2, 2, 2], [1, 1, 2, 2, 4], [1, 1, 2, 3, 3], [1, 1, 2, 6], [1, 1, 3, 5], [1, 1, 4, 4], [1, 1, 8], [1, 2, 2, 2, 3], [1, 2, 2, 5], [1, 2, 3, 4], [1, 2, 7], [1, 3, 3, 3], [1, 3, 6], [1, 4, 5], [1, 9], [2, 2, 2, 2, 2], [2, 2, 2, 4], [2, 2, 3, 3], [2, 2, 6], [2, 3, 5], [2, 4, 4], [2, 8], [3, 3, 4], [3, 7], [4, 6], [5, 5], [10]]

सुपर बड़े परीक्षण का मामला: 15 को इसका उत्पादन करना चाहिए

[[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, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5], [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4], [1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3], [1, 1, 1, 1, 1, 1, 1, 1, 1, 6], [1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3], [1, 1, 1, 1, 1, 1, 1, 1, 2, 5], [1, 1, 1, 1, 1, 1, 1, 1, 3, 4], [1, 1, 1, 1, 1, 1, 1, 1, 7], [1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2], [1, 1, 1, 1, 1, 1, 1, 2, 2, 4], [1, 1, 1, 1, 1, 1, 1, 2, 3, 3], [1, 1, 1, 1, 1, 1, 1, 2, 6], [1, 1, 1, 1, 1, 1, 1, 3, 5], [1, 1, 1, 1, 1, 1, 1, 4, 4], [1, 1, 1, 1, 1, 1, 1, 8], [1, 1, 1, 1, 1, 1, 2, 2, 2, 3], [1, 1, 1, 1, 1, 1, 2, 2, 5], [1, 1, 1, 1, 1, 1, 2, 3, 4], [1, 1, 1, 1, 1, 1, 2, 7], [1, 1, 1, 1, 1, 1, 3, 3, 3], [1, 1, 1, 1, 1, 1, 3, 6], [1, 1, 1, 1, 1, 1, 4, 5], [1, 1, 1, 1, 1, 1, 9], [1, 1, 1, 1, 1, 2, 2, 2, 2, 2], [1, 1, 1, 1, 1, 2, 2, 2, 4], [1, 1, 1, 1, 1, 2, 2, 3, 3], [1, 1, 1, 1, 1, 2, 2, 6], [1, 1, 1, 1, 1, 2, 3, 5], [1, 1, 1, 1, 1, 2, 4, 4], [1, 1, 1, 1, 1, 2, 8], [1, 1, 1, 1, 1, 3, 3, 4], [1, 1, 1, 1, 1, 3, 7], [1, 1, 1, 1, 1, 4, 6], [1, 1, 1, 1, 1, 5, 5], [1, 1, 1, 1, 1, 10], [1, 1, 1, 1, 2, 2, 2, 2, 3], [1, 1, 1, 1, 2, 2, 2, 5], [1, 1, 1, 1, 2, 2, 3, 4], [1, 1, 1, 1, 2, 2, 7], [1, 1, 1, 1, 2, 3, 3, 3], [1, 1, 1, 1, 2, 3, 6], [1, 1, 1, 1, 2, 4, 5], [1, 1, 1, 1, 2, 9], [1, 1, 1, 1, 3, 3, 5], [1, 1, 1, 1, 3, 4, 4], [1, 1, 1, 1, 3, 8], [1, 1, 1, 1, 4, 7], [1, 1, 1, 1, 5, 6], [1, 1, 1, 1, 11], [1, 1, 1, 2, 2, 2, 2, 2, 2], [1, 1, 1, 2, 2, 2, 2, 4], [1, 1, 1, 2, 2, 2, 3, 3], [1, 1, 1, 2, 2, 2, 6], [1, 1, 1, 2, 2, 3, 5], [1, 1, 1, 2, 2, 4, 4], [1, 1, 1, 2, 2, 8], [1, 1, 1, 2, 3, 3, 4], [1, 1, 1, 2, 3, 7], [1, 1, 1, 2, 4, 6], [1, 1, 1, 2, 5, 5], [1, 1, 1, 2, 10], [1, 1, 1, 3, 3, 3, 3], [1, 1, 1, 3, 3, 6], [1, 1, 1, 3, 4, 5], [1, 1, 1, 3, 9], [1, 1, 1, 4, 4, 4], [1, 1, 1, 4, 8], [1, 1, 1, 5, 7], [1, 1, 1, 6, 6], [1, 1, 1, 12], [1, 1, 2, 2, 2, 2, 2, 3], [1, 1, 2, 2, 2, 2, 5], [1, 1, 2, 2, 2, 3, 4], [1, 1, 2, 2, 2, 7], [1, 1, 2, 2, 3, 3, 3], [1, 1, 2, 2, 3, 6], [1, 1, 2, 2, 4, 5], [1, 1, 2, 2, 9], [1, 1, 2, 3, 3, 5], [1, 1, 2, 3, 4, 4], [1, 1, 2, 3, 8], [1, 1, 2, 4, 7], [1, 1, 2, 5, 6], [1, 1, 2, 11], [1, 1, 3, 3, 3, 4], [1, 1, 3, 3, 7], [1, 1, 3, 4, 6], [1, 1, 3, 5, 5], [1, 1, 3, 10], [1, 1, 4, 4, 5], [1, 1, 4, 9], [1, 1, 5, 8], [1, 1, 6, 7], [1, 1, 13], [1, 2, 2, 2, 2, 2, 2, 2], [1, 2, 2, 2, 2, 2, 4], [1, 2, 2, 2, 2, 3, 3], [1, 2, 2, 2, 2, 6], [1, 2, 2, 2, 3, 5], [1, 2, 2, 2, 4, 4], [1, 2, 2, 2, 8], [1, 2, 2, 3, 3, 4], [1, 2, 2, 3, 7], [1, 2, 2, 4, 6], [1, 2, 2, 5, 5], [1, 2, 2, 10], [1, 2, 3, 3, 3, 3], [1, 2, 3, 3, 6], [1, 2, 3, 4, 5], [1, 2, 3, 9], [1, 2, 4, 4, 4], [1, 2, 4, 8], [1, 2, 5, 7], [1, 2, 6, 6], [1, 2, 12], [1, 3, 3, 3, 5], [1, 3, 3, 4, 4], [1, 3, 3, 8], [1, 3, 4, 7], [1, 3, 5, 6], [1, 3, 11], [1, 4, 4, 6], [1, 4, 5, 5], [1, 4, 10], [1, 5, 9], [1, 6, 8], [1, 7, 7], [1, 14], [2, 2, 2, 2, 2, 2, 3], [2, 2, 2, 2, 2, 5], [2, 2, 2, 2, 3, 4], [2, 2, 2, 2, 7], [2, 2, 2, 3, 3, 3], [2, 2, 2, 3, 6], [2, 2, 2, 4, 5], [2, 2, 2, 9], [2, 2, 3, 3, 5], [2, 2, 3, 4, 4], [2, 2, 3, 8], [2, 2, 4, 7], [2, 2, 5, 6], [2, 2, 11], [2, 3, 3, 3, 4], [2, 3, 3, 7], [2, 3, 4, 6], [2, 3, 5, 5], [2, 3, 10], [2, 4, 4, 5], [2, 4, 9], [2, 5, 8], [2, 6, 7], [2, 13], [3, 3, 3, 3, 3], [3, 3, 3, 6], [3, 3, 4, 5], [3, 3, 9], [3, 4, 4, 4], [3, 4, 8], [3, 5, 7], [3, 6, 6], [3, 12], [4, 4, 7], [4, 5, 6], [4, 11], [5, 5, 5], [5, 10], [6, 9], [7, 8], [15]]

सूची

इस पोस्ट के निचले भाग में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 84165; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 31716; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Comments

संबंधित: codegolf.stackexchange.com/questions/46991/...

— DJMcMayhem

क्या आप स्पष्ट कर सकते हैं आप से क्या मतलब है संभाल ?

— डेनिस

@flawr मैं असहमत हूं - सभी विभाजनों को खोजना सख्त विभाजन खोजने से पर्याप्त रूप से भिन्न है। हालाँकि, यह एक लक्ष्य हो सकता है।

— मेघो

मुझे लगता है कि अनियंत्रित विभाजन की तलाश करना और भागों की संख्या को सीमित न करना इसे अलग बनाता है।

— xnor

क्या आप स्पष्ट कर सकते हैं कि आपके पास बिटिन का क्या मतलब है ?

— लीक नन

Answer 1

अजगर, 10 9 बाइट्स

{SMlMM./U

यह भी निश्चित नहीं है कि यह धोखा नहीं है, लेकिन नियमों ने केवल यह कहा कि कोई भी पूर्णांक विभाजन का उपयोग नहीं कर सकता है (यह स्वयं प्रश्न में स्पष्ट रूप से नहीं कहा गया है, लेकिन प्रश्न में ओपी द्वारा एक टिप्पणी पूर्णांक विभाजन कहती है)। मैं स्ट्रिंग सूची विभाजन का उपयोग कर रहा हूं , जो उस सूची के स्लाइस बनाता है जो "माँ" सूची तक पहुंचता है। मेरा मानना ​​है कि मुझे तार के बजाय सूचियों का उपयोग करने के विचार के लिए @Maltysen को धन्यवाद देना होगा।

n = 15 को मेरी मशीन पर एक सेकंड से भी कम समय लगता है।

डेटाफ़्लो छद्मकोड में:

              input       // initial data
        U     range       // makes a list of length equal to input
      ./      partition   // partitions string
   lMM        length      // length of each substring in each way to partition
 SM           sort        // sort each way to partition
{             deduplicate // removes all duplicate after sorting
              print       // implicit, output final result

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

Comments

{mSlMd./*Nएक बाइट बचाता है

— लीक नून

यदि आप स्ट्रिंग विभाजन के बजाय सूची विभाजन का उपयोग करते हैं, तो आप 7 बाइट्स के लिए जा सकते हैं: pyth.herokuapp.com/?code=sMM.%2Fm1&input=5&debug=0

— माल्टीसेन

@LeakyNun खैर मैंने वास्तव में कोशिश की और यह एक बाइट नहीं बचा। जब मैंने आपकी टिप्पणी को देखा, तो मुझे पता चला कि मेरा जवाब वास्तव में 10 बाइट्स था, इसलिए मैं वास्तव में गलत तरीके से भूल गया (1 से शुरू gedit ब्लॉकों को भूल गया)।

— बसुकक्सुआन

@ मैलेटेंस आपको प्रत्येक उप-सूची को सॉर्ट करने की आवश्यकता है, और फिर डिडुप्लिकेट करें।

— बसुक्सुआन

@ मैलेटेंस आप सही थे, सूचियों का उपयोग करने से यह छोटा हो जाता है। मैंने आपके द्वारा लिंक किए गए कोड में सॉर्ट और समर्पण जोड़ने की कोशिश की और इससे कोई मदद नहीं मिली, लेकिन यह सब आपके लिए धन्यवाद है कि मुझे * N को U के साथ बदलने का विचार आया। धन्यवाद!

— बसुकक्सुआन

Answer 2

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

L?b{SM+R-bsdsyMb]Y

इसे ऑनलाइन आज़माएं! ( yअंत में फ़ंक्शन को कॉल करने के लिए उपयोग किया जाता है)

यह काफी जल्दी है।

यह पुनरावर्तन का उपयोग करता है। इनपुट है b, मेरे विधि से विभाजन उत्पन्न होगा 0करने के लिए b-1, और फिर प्रत्येक से सही विभाजन उत्पन्न करते हैं।

उदाहरण के लिए, जब b=4:

• b=0 देता है [[]]
• b=1 देता है [[1]]
• b=2 देता है [[2], [1, 1]]
• b=3 देता है [[3], [1, 2], [1, 1, 1]]

फिर, प्रत्येक विभाजन में b=0, परिशिष्ट 4(योग 4 बनाने के लिए); में प्रत्येक विभाजन b=1, परिशिष्ट 3(योग बनाने के लिए 4); आदि।

यह मुख्य रूप से यह कैसे काम करता है।

L?b{SM+R-bsdsyMb]Y

L                    define a function called "y" which takes an argument: "b"
 ?b                  test for truthiness of b (in this case, test if b>0).


   {SM+R-bsdsyMb     if truthy:

             yMb         call this function from 0 to b-1.
            s            unpack each list of partitions, generating only partitions.
      +R                 to each partition (d), append:
        -                    the difference of
         b                   b (the argument) and
          sd                 the sum of d (the partition).
    SM                   sort each partition.
   {                     remove duplicates.


                ]Y   if falsey:

                 Y       yield [].
                ]        yield [[]].

Answer 3

MATL , 20 बाइट्स

:"0Gq:@XNG3$Yc!dS!Xu

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

इनपुट के 15लिए ऑनलाइन संकलक में लगभग 2 सेकंड लगते हैं।

व्याख्या

यह विभाजन बिंदुओं को उत्पन्न करके और फिर विभाजन की लंबाई में परिवर्तित करके काम करता है । इससे मेरा मतलब निम्नलिखित है। इनपुट एन = 5 को देखते हुए , एक संभावित विभाजन [2 2 1] है। यह विभाजन बिंदुओं द्वारा दर्शाया गया है [0 2 4 5], जैसे कि विभाजन बिंदुओं के लगातार अंतर (या लंबाई) इनपुट संख्या के परिणामी विभाजन को देते हैं।

विभाजन बिंदुओं के सभी सरणियां 0 से शुरू होती हैं और एन के साथ समाप्त होती हैं । नंबर कश्मीर मध्यवर्ती अंक के 0 से भिन्न होता है एन -1। के लिए एन और कश्मीर को देखते हुए, मध्यवर्ती अंक संख्याओं का संयोजन के रूप में उत्पन्न किया जा सकता [1, 2, ..., एन -1] ले जाया कश्मीर एक समय में।

विभाजन बिंदुओं की कई सरणियाँ एक अलग क्रम में एक ही परिणाम को जन्म दे सकती हैं। उदाहरण के लिए, विभाजन बिंदु [0 1 3 5] विभाजन की लंबाई [1 2 2], अर्थात पिछले [2 2 1] के समान ही एक अलग क्रम में देगा। यह द्वारा ध्यान में रखा जाना है छँटाई विभाजन लंबाई के प्रत्येक सरणी और डुप्लिकेट हटाने ।

:        % Implicitly input N. Push [1 2 ... N]. These are the possible values of k,
         % except with N instead of 0
"        % For each
  0      %   Push 0
  Gq:    %   Push [1 ... N-1]. These the possible intermediate points
  @XN    %   Push k and produce the combinations. Each k produces a 2D array with
         %   each combination on a row. The value k=N produces an empty array
  G      %   Push N
  3$Yc   %   Prepend a column of zeros and append a column of N to the array
  !d     %   Transpose. Consecutive differences of each column
  S!     %   Sort each column. Transpose
  Xu     %   Keep only unique rows
         % Implicitly end for and display all arrays in the stack

Comments

अच्छा है, इसे हल करने के लिए विभाजन बिंदुओं की अवधारणा एक बहुत ही चतुर तरीका है।

— निक

@ धन्यवाद धन्यवाद! और इस साइट में आपका (सक्रिय होने का) स्वागत है! :-)

— लुइस मेंडो

Answer 4

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

p=[[]]:[map(1:)q++[a+1:b|a:b<-q,all(a<)b]|q<-p]
(p!!)

Answer 5

जे, ४ ९ ४२ ३६ 35 32 बाइट्स

a:1&([:~.@,(,;}./:~@,(+{.))&>)~]

यह अब tacit है!

1 से पूर्णांक विभाजनों का निर्माण करके n के पूर्णांक विभाजन को बनाता है n । एक मिलीसेकंड में n = 15 के लिए परिणाम की गणना करता है ।

प्रारंभिक पूर्णांक विभाजन के साथ शुरू करना [[1]]जो n = 1 से मेल खाता है , दो परिणामों से परिणामों में शामिल होकर अगले पूर्णांक विभाजन का निर्माण करें: प्रत्येक विभाजन में 1 को जोड़ना; प्रत्येक विभाजन में 1 से सबसे छोटा मान बढ़ाता है। बेशक, नकली विभाजन हटा दिए जाएंगे। पूर्णांक विभाजन n = 2 और उसके बाद प्राप्त करने के लिए ,

Partition for n = 1
[[1]]

Partition for n = 2
[[1, 1]] join [[2]]
= [[1, 1], [2]]

Partition for n = 3
[[1, 2], [1, 1, 1]] join [[3], [1, 2]]
= [[3], [1, 2], [1, 1, 1]]

... and so on

प्रयोग

   f =: a:1&([:~.@,(,;}./:~@,(+{.))&>)~]
   f 1
┌─┐
│1│
└─┘
   f 2
┌───┬─┐
│1 1│2│
└───┴─┘
   f 3
┌─────┬───┬─┐
│1 1 1│1 2│3│
└─────┴───┴─┘
   f 5
┌─────────┬───────┬─────┬───┬─────┬───┬─┐
│1 1 1 1 1│1 1 1 2│1 2 2│2 3│1 1 3│1 4│5│
└─────────┴───────┴─────┴───┴─────┴───┴─┘
   # f 15
176

व्याख्या

चूँकि J, ragged सरणियों का समर्थन नहीं करता है, इसलिए प्रत्येक विभाजन को बॉक्सिंग करना पड़ता है, ताकि वे अन्य विभाजनों के साथ जोड़ दिए जाने पर शून्य गद्देदार न हों।

a:1&([:~.@,(,;}./:~@,(+{.))&>)~]  Input: n
a:                                The empty box
                               ]  Get the input n
  1&(                        )~   Repeat n times with an initial array of one empty box
           (              )&>       Operate on each partition
                     (   )            Hook a partition
                       {.               Get its head (the smallest value)
  1                   +                 Add 1 to it
  1           }.                      Drop the first value in each partition
                    ,                 Join the previous two results
                /:~@                  Sort it
  1         ,                         Prepend a 1 to the initial partition
             ;                        Box the last two results and join them
     [:   ,                         Flatten the pairs of boxes
       ~.@                          Remove duplicates and return
                                  Return the final result where each box
                                  is a partition of n

Answer 6

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

अजगर ३

def f(n,i=1,l=[]):n or print(l);i>n or[f(n-i,i,[i]+l),f(n,i+1,l)]

यह फ़ंक्शन एक विभाजन को जमा करता है और आउटपुट को प्रिंट करता है, विकल्पों पर शाखा करता है। यह तय करता है कि विभाजन में कितने 1, कितने 2 और इतने पर रखा जाना है। प्रत्येक मूल्य के लिए i, यह या तो

• आकार का एक भाग जोड़ता है i, और घटता nहैn-i , या
• की ओर बढ़ता है i+1

यदि i>n, तो कोई और भाग नहीं बनाया जा सकता है, इसलिए यह बंद हो जाता है। अगर nपड़ता है0 , तो विभाजन सफल होता है और इसलिए मुद्रित किया जाता है।

अजगर २

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

एक पुनरावर्ती विधि जो विभाजन की सूची का उत्पादन करती है। पायथन 3 कोड के साथ, यह भाग के आकार को गिनता है iऔर प्रत्येक चरण पर निर्णय लेता है कि आकार का दूसरा भाग जोड़ना है या नहींi या रोकना है।

ये दोनों n=15लगभग तुरंत करते हैं।

Answer 7

जावास्क्रिप्ट, 194 बाइट्स

p=n=>{var a=[];for(var i=1;i<=n-i;i+=1){for(v of p(n-i)){v.push(i);a.push(v.sort())}}a.push([n]);return a};n=5;s=p(n).map(v=>JSON.stringify(v));s=s.filter((v,i)=>s.indexOf(v)==i);console.log(s);

गैर न्यूनतम किया गया

एक छँटाई और एक स्ट्रिंग की तुलना द्वारा uniques ढूँढना काफी हैक है, लेकिन शायद अंतरिक्ष बचाता है।

p = n => {
    var a = [];

    for (var i = 1; i <= n-i; i++)
    {
        for (v of p(n-i)) {
            v.push(i);
            a.push(v.sort());
        }
    }

    a.push([n]);

    return a;
}

n = 5;
s = p(n).map(v =>  JSON.stringify(v));
s = s.filter((v,i) => s.indexOf(v) == i);
console.log(s);

Comments

Quite a hack but saves spaceयह वही है जो इस साइट के बारे में है। : डी

— DJMcMayhem

Answer 8

पायथन 3.5, 82 72 बाइट्स

f=lambda n:{(*sorted([*p,i]),)for i in range(1,n)for p in f(n-i)}|{(n,)}

टुपल्स का एक सेट लौटाता है। n = 15 तुरंत समाप्त।

यह repl.it पर परीक्षण करें ।

Answer 9

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

0%m=[[]]
n%m=[j:r|j<-[m..n],r<-(n-j)%j]
(%1)

सहायक फ़ंक्शन मुख्य भागों का उपयोग करके भागों में n%mविभाजन देता है । यह प्रत्येक पहली प्रविष्टि की शाखाओं के साथ शेष भागों में बंटवारे पर पुनरावृत्ति करता है जो कम से कम हैं । बेस केस सिर्फ खाली विभाजन देता है।n≥mm=1jm≤j≤nn-jjn==0

Answer 10

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

L|{SMs+LVrb0yMb]Y

नाम के एक फंक्शन को परिभाषित करता है y। इसे ऑनलाइन आज़माएं ।

Answer 11

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

b1ŒṖḅ1Ṣ€Q

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

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

b1ŒṖḅ1Ṣ€Q  Main link. Argument: n (integer)

b1         Convert n to unary, i.e., a list A of n 1's.
  ŒṖ       Generate all partitions of the list A.
    ḅ1     Convert each flat list from unary to integer.
      Ṣ€   Sort each resulting list.
        Q  Unique; deduplicate the lists.

Answer 12

जे, 39 बाइट्स

[:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:

यह एक राक्षसी क्रिया है जो पूर्णांक लेती है और बॉक्सिंग सरणियों की एक सरणी लौटाती है। इसे यहाँ आज़माएँ। उपयोग:

   p =: [:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:
   p 3
+-----+---+-+
|1 1 1|2 1|3|
+-----+---+-+

इनपुट 15 पर, यह मेरी मशीन पर लगभग एक सेकंड के लिए चलता है।

व्याख्या

यह चुनौती तुरंत कैटलॉग ( {) और कट ( ;.) के लिए एक नौकरी की तरह लग रही थी । एल्गोरिथ्म की रूपरेखा है:

• लंबाई के सभी 0-1 सरणियों का निर्माण करें n।
• उनमें से प्रत्येक के लिए, n1s के साथ एक डमी लंबाई- सरणी काटें , और प्रत्येक भाग की लंबाई सूचीबद्ध करें।
• लंबाई को क्रमबद्ध करें, और परिणाम से डुप्लिकेट सरणियों को हटा दें।

जाहिर है, लुइस मेंडो का भी यही विचार था।

कोड की व्याख्या:

[:~.i.<@\:~@(#;.1~"1 0)1,@{@;(<1 0)#~<:   Input is n.
                                     <:   n-1
                                   #~     copies of
                             (<1 0)       the boxed array [1 0].
                       1    ;             Prepend the boxed array [1].
                          {@              Catalog: produces all combinations of taking one
                                          item from each box, in a high-dimensional matrix.
                        ,@                Flatten the matrix. This results in a list of all
                                          boxed 0-1 arrays of length n that begin with a 1.
    i.                                    The array A =: 0, 1, ..., n-1.
            (     "1 0)                   For each of the boxed arrays B:
              ;.1~                          cut A along the occurrences of 1s in B,
             #                              take the length of each part,
        \:~@                                sort the lengths,
      <@                                    and put the result in a box.
[:~.                                      Remove duplicate boxes.

Comments

;.फिर से कटौती का बहुत अच्छा उपयोग ।

— मील

Answer 13

ब्रेकीलॉग , 33 बाइट्स (गैर-प्रतिस्पर्धात्मक)

:1f:oad.
:1eI,.##lI,.:{.>0}a+?,.=

बग फिक्स के कारण यह गैर-प्रतिस्पर्धात्मक है।

15मेरी मशीन पर लगभग 1 सेकंड का समय लगता है । के लिए 20और अधिक से अधिक यह एक साथ दुर्घटनाओं Out of global stackअपवाद।

व्याख्या

इसमें किसी भी प्रकार का कोई विभाजन नहीं किया गया है, और इसके बजाय इस तथ्य का उपयोग करता है कि +दोनों तरीकों से काम करता है।

• मुख्य विधेय:

  :1f                       Find the list of all valid outputs of predicate 1
     :oa                    Sort each element of that list
        d.                  Output is that list of sorted lists minus all duplicates
  

• 1 समर्पित करें:

  :1eI                      I is an integer between Input and 1
      .##lI,                Output is a list of length I
            .:{.>0}a        Elements of Output are integers greater than 0
                    +?,     The sum of the elements of Output is Input
                       .=   Assign values to the elements of Output
  

Answer 14

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

Inner[#2~Table~#&,FrobeniusSolve[r=Range@#,#],r,Join]&

एक पूर्णांक n के विभाजनों को गैर-ऋणात्मक पूर्णांकों के n -uples ( c ₁ , c ₂ , ..., c _n ) के लिए हल करके पाया जा सकता है जैसे कि c ₁ + 2 c ₂ + ... + n c _n = एन । FrobeniusSolveइस समीकरण के सभी समाधान खोजने में सक्षम है जो n के सभी पूर्णांक विभाजनों को खोजने के लिए उनके संबंधित मानों की कई प्रतियां बनाने के लिए उपयोग किया जाता है ।

Comments

... और यह बिल्ट-इन कैसे नहीं है?

— लीक नन

@LeakyNun FrobeniusSolveपूर्णांक विभाजन नहीं मिल रहा है, यह सब समाधान पाता गैर नकारात्मक पूर्णांक के x1 ... xN रूप के समीकरणों को a1 x1 + a2 x2 + ... aN xN = bदेखते हुए a1 ... aNऔर b।

— मील

Answer 15

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57) 79 ईएस 6 , 65 बाइट्स

f=(n,m=1,a=[])=>n?m>n?[]:[...f(n-m,m,[...a,m]),...f(n,m+1,a)]:[a]

@ Xnor के पायथन समाधान का पोर्ट। (यदि केवल मैंने देखा है कि आप के mरूप में अच्छी तरह से फिर से पा सकते हैं n...)