এন এর পার্টিশন গণনা করুন

Question

একটি পূর্ণসংখ্যা দেওয়া: আপনার চ্যালেঞ্জ সহজ এন , যে অঙ্কের ধনাত্মক পূর্ণসংখ্যা প্রতিটি তালিকা ouput এন । উদাহরণস্বরূপ, যদি ইনপুটটি 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]]

তালিকা

এই পোস্টের নীচে স্ট্যাক স্নিপেট উত্তরগুলি থেকে ক্যাটালগ তৈরি করে a) ভাষার প্রতি সংক্ষিপ্ত সমাধানের তালিকা হিসাবে এবং খ) সামগ্রিক লিডারবোর্ড হিসাবে।

আপনার উত্তরটি প্রদর্শিত হয়েছে তা নিশ্চিত করার জন্য, দয়া করে নীচের মার্কডাউন টেমপ্লেটটি ব্যবহার করে আপনার উত্তরটি শিরোনাম দিয়ে শুরু করুন:

## 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

সম্পর্কিত: কোডগল্ফ.স্ট্যাকেক্সেঞ্জাওয়েশনস

— ৪৯৯

আপনি হ্যান্ডেল দ্বারা বোঝানো কি বলতে পারেন ?

— ডেনিস

@ ফ্লোয়ার আমি একমত নই - সমস্ত পার্টিশন সন্ধান করা কঠোর পার্টিশন খুঁজে পাওয়া থেকে আলাদা। যাইহোক, এটি এক একটি দ্বীপ লক্ষ্য হতে পারে।

— মেগো

আমি মনে করি আনর্ডারড পার্টিশনগুলির সন্ধান এবং অংশের সংখ্যা সীমাবদ্ধ না রেখে এটিকে যথেষ্ট আলাদা করে তোলে।

— xnor

বুটিন বলতে কী বোঝাতে চেয়েছ তা কি আপনি পরিষ্কার করতে পারেন ?

— ফাঁস নুন

Answer 1

পাইথ, 10 9 বাইট

{SMlMM./U

এটি প্রতারণামূলক না হলে খুব বেশি নিশ্চিত নয়, তবে নিয়মগুলি কেবল বলেছে যে কেউ পূর্ণসংখ্যার পার্টিশন ব্যবহার করতে পারে না (এটি নিজেই প্রশ্নটিতে স্পষ্টভাবে বলা হয়নি, তবে প্রশ্নে ওপি-র একটি মন্তব্য ইন্টিজার পার্টিশন বলেছে)। আমি স্ট্রিং তালিকার পার্টিশন ব্যবহার করছি , যা "মা" তালিকার সাথে তাল মিলিয়ে তালিকার টুকরো তৈরি করে list আমি বিশ্বাস করি স্ট্রিংয়ের পরিবর্তে তালিকাগুলি ব্যবহারের ধারণার জন্য আমাকে @ মাল্টেসেনকে ধন্যবাদ জানাতে হবে।

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 বাইটের জন্য যেতে পারেন: পাইথ.হেরোকুয়াপ.com

— code=

@ ল্যাকইনুন ওয়েল আমি আসলে চেষ্টা করেছি এবং এটি একটি বাইট সংরক্ষণ করতে পারেনি। আমি যখন আপনার মন্তব্যটি দেখেছি, আমি জানতে পেরেছিলাম যে আমার উত্তরটি আসলে 10 বাইট ছিল, তাই আমি আসলে ভুল অঙ্ক করেছি (ভুলে গেছি জেডিট ব্লকগুলি 1 থেকে শুরু হয়)।

— বুসুক্সুয়ান

@ মাল্টেসেন আপনাকে প্রতিটি উপ-তালিকা বাছাই করতে হবে এবং তারপরে নকল করতে হবে।

— বুসুক্সুয়ান

@ মাল্টেসেন আপনি ঠিক বলেছেন, তালিকাগুলি ব্যবহার করে এটি ছোট করা হবে। আপনি যে কোডটি সংযুক্ত করেছেন সেটিকে আমি সাজানোর এবং ডুপ্লিকেটটি যুক্ত করার চেষ্টা করেছি এবং এটি কোনও সহায়তা করেনি, তবে আপনারা সবাইকে ধন্যবাদ যে আমি ইউএন দিয়ে * এন প্রতিস্থাপনের ধারণা পেয়েছি ধন্যবাদ!

— বুসুক্সুয়ান

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

এমএটিএল , 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

জে, 49 42 36 35 32 বাইট

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

এটা এখন স্বাচ্ছন্দ্য!

1 থেকে n পর্যন্ত পূর্ণসংখ্যা পার্টিশন তৈরি করে n এর পূর্ণসংখ্যা পার্টিশন তৈরি করে । N এর জন্য ফলাফল গণনা করেমিলি সেকেন্ডে = 15 এর ।

প্রাথমিক ইন্টিজার পার্টিশন [[1]]যা এন = 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

ব্যাখ্যা

যেহেতু জে র‌্যাগড অ্যারে সমর্থন করে না, তাই প্রতিটি পার্টিশনটি বাক্সে রাখতে হবে যাতে তারা অন্য পার্টিশনে যুক্ত হয়ে শূন্য প্যাডযুক্ত হয় না।

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)]

এই ফাংশনটি একটি পার্টিশন সংগ্রহ করে এবং ফলাফলগুলিতে শাখা করে আউটপুটগুলি মুদ্রণ করে। পার্টিশনে কতজনকে রাখা উচিত, কতটি 2 এর ঠিক আছে তা স্থির করে। প্রতিটি মান জন্য i, এটি হয়

• আকারের একটি অংশ যুক্ত করে iএবং কমে nযায় n-i, বা
• এগিয়ে যায় i+1

যদি i>n, তবে আর কোনও অংশ তৈরি করা যায় না, তাই এটি বন্ধ হয়ে যায়। যদি nপড়ে যায় 0, পার্টিশনটি সফল এবং তাই মুদ্রিত হয়।

পাইথন 2

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);

অ minified

স্ট্রিংয়ের সাথে বাছাই করে এবং তুলনা করে অজানাগুলি খুঁজে পাওয়া বেশ হ্যাক, তবে সম্ভবত স্থানটি সঞ্চয় করে।

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এই সাইটটি সম্পর্কে ঠিক এটিই। : ডি

— ডিজেএমসিএমহেম

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।
• তাদের প্রত্যেকের জন্য, একটি ডামি দৈর্ঘ্য কেটে-n 1 টি বরাবর দৈর্ঘ্যের অ্যারে এবং প্রতিটি অংশের দৈর্ঘ্য ।
• দৈর্ঘ্য বাছাই করুন, এবং ফলাফল থেকে সদৃশ অ্যারেগুলি সরান।

স্পষ্টতই, লুইস মেন্ডোরও একই ধারণা ছিল।

কোডের ব্যাখ্যা:

[:~.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

;.আবার কেটে খুব সুন্দর ব্যবহার ।

— মাইল 23

Answer 13

ব্র্যাচল্যাগ , ৩৩ বাইট (প্রতিযোগী নয়)

: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]&

একটি পূর্ণসংখ্যা এর পার্টিশন এন জন্য সমাধানে পাওয়া যাবে এন (অ-নেতিবাচক পূর্ণসংখ্যার -tuples গ ₁ , গ ₂ , ..., গ _এন ) যেমন যে গ ₁ +2 গ ₂ + + ... এন গ _এন = এন । FrobeniusSolveএই সমীকরণের সমস্ত সমাধান সন্ধান করতে সক্ষম যা এন এর সমস্ত সংখ্যার পার্টিশন সনাক্ত করতে তাদের নিজ নিজ মানের অনেকগুলি অনুলিপি তৈরি করতে ব্যবহৃত হয় ।

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...)