Thách thức của bạn rất đơn giản: đưa ra một số nguyên N , ouput mỗi danh sách các số nguyên dương mà khoản tiền để tồn tại . Ví dụ: nếu đầu vào là 5, bạn nên xuất

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

Các danh sách này không phải là đầu ra theo bất kỳ thứ tự cụ thể nào, cũng như các số trong mỗi danh sách. Ví dụ: đây cũng sẽ là đầu ra chấp nhận được cho '5':

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

Bạn có thể giả định một cách an toàn rằng đầu vào sẽ là một số nguyên dương và bạn có thể lấy số này ở bất kỳ định dạng hợp lý nào.

Bạn không thể sử dụng bất kỳ hàm dựng sẵn nào thực hiện việc này.

Nếu chương trình của bạn thất bại hoặc mất quá nhiều thời gian cho N lớn thì điều này không sao, nhưng ít nhất bạn phải tạo ra đầu ra chính xác cho 15 đầu tiên.

Áp dụng sơ hở tiêu chuẩn và câu trả lời ngắn nhất tính bằng byte!

Kiểm tra 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]]

Trường hợp thử nghiệm siêu lớn: 15 nên xuất này

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

Mục lục

Đoạn trích Stack ở cuối bài đăng này tạo ra danh mục từ các câu trả lời a) dưới dạng danh sách các giải pháp ngắn nhất cho mỗi ngôn ngữ và b) dưới dạng bảng xếp hạng tổng thể.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

## Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

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

Bình thường, 10 9 byte

{SMlMM./U

Không quá chắc chắn nếu điều này không gian lận, nhưng các quy tắc chỉ nói rằng người ta không thể sử dụng phân vùng số nguyên (nó không được nêu rõ trong chính câu hỏi, nhưng một nhận xét của OP trong câu hỏi cho biết phân vùng số nguyên). Tôi đang sử dụng phân vùng danh sách chuỗi , làm cho các lát của danh sách nối với danh sách "mẹ". Tôi tin rằng tôi phải cảm ơn @Maltysen vì ý tưởng sử dụng danh sách thay vì chuỗi.

n = 15 mất ít hơn một giây trên máy của tôi.

Trong mã giả dataflow:

              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

Hãy thử trực tuyến tại đây.

Bình thường, 18 byte

L?b{SM+R-bsdsyMb]Y

Hãy thử trực tuyến! ( yCuối cùng được sử dụng để gọi hàm)

Điều này khá nhanh chóng.

Điều này sử dụng đệ quy. Nếu đầu vào là b, phương thức của tôi sẽ tạo các phân vùng từ 0đến b-1, và sau đó tạo các phân vùng chính xác từ mỗi phân vùng.

Ví dụ b=4: khi :

• b=0 cho [[]]
• b=1 cho [[1]]
• b=2 cho [[2], [1, 1]]
• b=3 cho [[3], [1, 2], [1, 1, 1]]

Sau đó, đến từng phân vùng trong b=0, nối thêm 4(để tạo tổng 4); vào mỗi phân vùng trong b=1, nối thêm 3(để tạo tổng4 ); v.v.

Đây chủ yếu là cách nó hoạt động.

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 [[]].

MATL , 20 byte

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

Hãy thử trực tuyến!

Đối với đầu vào 15, mất khoảng 2 giây trong trình biên dịch trực tuyến.

Giải trình

Điều này hoạt động bằng cách tạo các điểm phân vùng và sau đó chuyển đổi sang độ dài phân vùng . Ý tôi là gì đây là như sau. Cho đầu vào N = 5, một phân vùng có thể là [2 2 1]. Điều này được thể hiện bằng các điểm phân vùng [0 2 4 5], sao cho sự khác biệt liên tiếp (hoặc độ dài) của các điểm phân vùng đưa ra phân vùng kết quả của số đầu vào.

Tất cả các mảng của các điểm phân vùng bắt đầu với 0 và kết thúc bằng N . Số k của các điểm trung gian thay đổi từ 0 đến N -1. Dành cho N và k đã cho, các điểm trung gian có thể được tạo dưới dạng kết hợp của các số [1, 2, ..., N -1] lấy k tại một thời điểm.

Một số mảng của các điểm phân vùng có thể dẫn đến cùng một kết quả theo một thứ tự khác nhau. Ví dụ: các điểm phân vùng [0 1 3 5] sẽ cho độ dài phân vùng [1 2 2], tức là giống như [2 2 1] trước đó chỉ theo một thứ tự khác. Điều này phải được tính đến bằng cách sắp xếp từng mảng độ dài phân vùng và loại bỏ trùng lặp .

:        % 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

Haskell, 53 byte

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

J, 49 42 36 35 32 byte

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

Bây giờ là ngầm!

Xây dựng phân vùng số nguyên của n bằng cách xây dựng các phân vùng số nguyên từ 1 đến n . Tính kết quả cho n = 15 trong một phần nghìn giây.

Bắt đầu với phân vùng số nguyên ban đầu [[1]]tương ứng với n = 1, xây dựng phân vùng số nguyên tiếp theo bằng cách nối các kết quả từ hai thao tác: nối thêm 1 vào mỗi phân vùng; tăng giá trị nhỏ nhất lên 1 trong mỗi phân vùng. Tất nhiên, các phân vùng trùng lặp sẽ được gỡ bỏ. Để có được phân vùng số nguyên n = 2 trở đi,

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

Sử dụng

   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

Giải trình

Vì J không hỗ trợ các mảng bị rách, nên mỗi phân vùng phải được đóng hộp để chúng sẽ không được đệm khi gắn vào các phân vùng khác.

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

Python, 65 byte

Con trăn 3

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

Hàm này tích lũy một phân vùng và in các đầu ra, phân nhánh trên các lựa chọn. Nó quyết định đặt bao nhiêu 1 trong phân vùng, bao nhiêu 2, v.v. Đối với mỗi giá trị i, nó hoặc

• Thêm một phần của kích thước i, và giảm ntới n-i, hoặc
• Chuyển sang i+1

Nếu i>n, sau đó không có nhiều phần có thể được thực hiện, vì vậy nó dừng lại. Nếu nrơi vào 0, phân vùng thành công và do đó được in.

Con trăn 2

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

Một phương thức đệ quy đưa ra một danh sách các phân vùng. Như với mã Python 3, nó đếm kích thước phần ivà quyết định ở mỗi bước có thêm phần kích thước khác khôngi hay dừng lại.

Cả hai điều này làm n=15gần như ngay lập tức.

Javascript, 194 byte

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

Không khai thác

Việc tìm kiếm sự khác biệt bằng cách sắp xếp và so sánh với một chuỗi khá khó khăn, nhưng có lẽ sẽ tiết kiệm không gian.

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

Python 3.5, 82 72 byte

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

Trả về một bộ dữ liệu. n = 15 kết thúc ngay lập tức.

Thử nghiệm nó trên repl.it .

Haskell, 44 byte

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

Hàm phụ trợ n%mcung cấp cho các phân vùng nthành các phần ≥m, với chức năng chính sử dụng m=1. Nó phân nhánh của mỗi mục đầu tiên jvới m≤j≤n, đệ quy trên phân vùng còn lại n-jthành các phần ít nhất j. Các trường hợp cơ sở n==0chỉ cung cấp cho các phân vùng trống.

Bình thường, 17 byte

L|{SMs+LVrb0yMb]Y

Xác định một hàm có tên y. Hãy thử trực tuyến .

Thạch , 9 byte

b1ŒṖḅ1Ṣ€Q

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

J, 39 byte

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

Đây là một động từ đơn âm lấy một số nguyên và trả về một mảng các mảng được đóng hộp. Hãy thử nó ở đây. Sử dụng:

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

Ở đầu vào 15, nó chạy khoảng một giây trên máy của tôi.

Giải trình

Thử thách này ngay lập tức trông giống như một công việc cho Catalog ( {) và Cut ( ;.). Các phác thảo của thuật toán là:

• Tạo ra tất cả các mảng 0-1 chiều dài n .
• Đối với mỗi người trong số họ, cắt một chiều dài giả-n mảng chiều dài dọc theo số 1 và liệt kê độ dài của mỗi phần.
• Sắp xếp độ dài và loại bỏ các mảng trùng lặp khỏi kết quả.

Rõ ràng, Luis Mendo cũng có ý tưởng tương tự .

Giải thích về mã:

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

Brachylog , 33 byte (Không cạnh tranh)

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

Điều này là không cạnh tranh vì sửa lỗi.

Điều này mất khoảng 1 giây cho 15máy của tôi. Cho 20và lớn hơn sự cố này với mộtOut of global stack ngoại lệ.

Giải trình

Điều này không sử dụng phân vùng tích hợp dưới bất kỳ hình thức nào, và thay vào đó sử dụng thực tế +hoạt động cả hai cách thông qua việc truyền bá ràng buộc.

• Vị ngữ chính:

  :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
  

• Vị ngữ 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
  

Toán học, 62 54 byte

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

Có thể tìm thấy các phân vùng của một số nguyên n bằng cách giải cho n -tuples các số nguyên không âm ( c ₁ , c ₂ , ..., c _n ) sao cho c ₁ + 2 c ₂ + ... + n c _n = n . FrobeniusSolvecó thể tìm tất cả các giải pháp cho phương trình này được sử dụng để tạo ra nhiều bản sao của các giá trị tương ứng của chúng để tìm tất cả các phân vùng nguyên của n .

JavaScript (Firefox 30-57) 79 ES6, 65 byte

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

Cổng giải pháp Python của @ xnor. (Nếu tôi nhận thấy rằng bạn có thể tái diễn mcũng như n...)