22

Su reto es simple: Dado un número entero N , ouput todas las listas de números enteros positivos que sumas a N . Por ejemplo, si la entrada fue 5, debe generar

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

Estas listas no tienen que salir en ningún orden en particular, ni los números dentro de cada lista. Por ejemplo, esto también sería un resultado aceptable para '5':

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

Puede asumir con seguridad que la entrada será un número entero positivo, y puede tomar este número en cualquier formato razonable.

Es posible que no se utilice ningún funciones incorporadas que hacen esto.

Si su programa falla o toma demasiado tiempo para N grande, está bien, pero al menos debe producir la salida correcta para los primeros 15.

Se aplican las lagunas estándar, ¡y gana la respuesta más corta en bytes!

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

Caso de prueba súper grande: 15 debería generar esto

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

Catalogar

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Mostrar fragmento de código

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

Expandir fragmento

— DJMcMayhem
fuente

1

Relacionado: codegolf.stackexchange.com/questions/46991/…

— DJMcMayhem

2

¿Podría aclarar qué quiere decir con mango ?

— Dennis

@flawr No estoy de acuerdo: encontrar todas las particiones es lo suficientemente diferente de encontrar particiones estrictas. Sin embargo, este podría ser un objetivo de engaño.

— Mego

Creo que buscar particiones desordenadas y no limitar el número de partes hace que esto sea lo suficientemente diferente.

— xnor

¿Puedes aclarar qué quieres decir con buitina ?

— Leaky Nun

6

Pyth, 10 9 bytes

{SMlMM./U

No estoy muy seguro si esto no es trampa, pero las reglas solo dicen que uno no puede usar la partición entera (no se establece claramente en la pregunta en sí, pero un comentario de OP en la pregunta dice partición entera). Estoy usando la partición de la lista de ~~cadenas~~ , que hace cortes de la lista que se concatenan con la lista "madre". Creo que tengo que agradecer a @Maltysen por la idea de usar listas en lugar de cadenas.

n = 15 toma menos de un segundo en mi máquina.

En el seudocódigo de flujo de datos:

              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

Pruébelo en línea aquí.

— busukxuan
fuente

{mSlMd./*Nguarda un byte

— Leaky Nun

Puede utilizar 7 bytes si utiliza la partición de listas en lugar de la partición de cadenas: pyth.herokuapp.com/?code=sMM.%2Fm1&input=5&debug=0

— Maltysen

@LeakyNun Bueno, en realidad lo intenté y no guardó un byte. Cuando vi tu comentario, descubrí que mi respuesta en realidad era de 10 bytes, por lo que realmente conté mal (olvidé que los bloques gedit comienzan desde 1).

— busukxuan

@Maltysen Debe ordenar cada sublista y luego deduplicar.

— busukxuan

@Maltysen Tenías razón, usar listas lo acorta. Intenté agregar ordenar y deduplicar al código al que se vinculó y no sirvió de nada, pero es gracias a usted que tuve la idea de reemplazar * N con U. ¡Gracias!

— busukxuan

6

Pyth, 18 bytes

L?b{SM+R-bsdsyMb]Y

Pruébalo en línea! (Al yfinal se usa para llamar a la función)

Esto es bastante rápido

Esto usa la recursividad. Si la entrada es b, mi método generará las particiones de 0a b-1, y luego generará las particiones correctas de cada uno.

Por ejemplo, cuando b=4:

b=0 da [[]]
b=1 da [[1]]
b=2 da [[2], [1, 1]]
b=3 da [[3], [1, 2], [1, 1, 1]]

Luego, a cada partición b=0, agregue 4(para hacer la suma 4); a cada partición en b=1, agregar 3(para hacer la suma 4); etc.

Así es principalmente como funciona.

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

— Monja permeable
fuente

5

MATL , 20 bytes

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

Pruébalo en línea!

Para la entrada 15, tarda unos 2 segundos en el compilador en línea.

Explicación

Esto funciona generando puntos de partición y luego convirtiéndolos a longitudes de partición . Lo que quiero decir con esto es lo siguiente. Dada la entrada N = 5, una posible partición es [2 2 1]. Esto se representa mediante puntos de partición [0 2 4 5], de modo que las diferencias consecutivas (o longitudes) de los puntos de partición dan la partición resultante del número de entrada.

Todos los conjuntos de puntos de partición empiezan con 0 puntos y terminan con N . El número k de puntos intermedios varía de 0 a N -1. Para N y k dados, los puntos intermedios se pueden generar como una combinación de los números [1, 2, ..., N -1] tomados k a la vez.

Varios conjuntos de puntos de partición pueden dar lugar al mismo resultado en un orden diferente. Por ejemplo, los puntos de partición [0 1 3 5] darían las longitudes de partición [1 2 2], es decir, las mismas que las anteriores [2 2 1] solo en un orden diferente. Esto debe tenerse en cuenta ordenando cada matriz de longitudes de partición y eliminando duplicados .

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

— Luis Mendo
fuente

1

Agradable, el concepto de puntos de partición es una forma muy inteligente de resolver esto.

— Nick

@ Nick Gracias! ¡Y bienvenido a (estar activo en) este sitio! :-)

— Luis Mendo

5

Haskell, 53 bytes

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

— Anders Kaseorg
fuente

5

J, 49 42 36 35 32 bytes

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

¡Es tácito ahora!

Construye la partición entera de n construyendo las particiones enteras de 1 a n . Calcula el resultado para n = 15 en un milisegundo.

Comenzando con la partición entera inicial [[1]]que corresponde a n = 1, construya la siguiente partición entera uniendo los resultados de dos operaciones: agregando un 1 a cada partición; incrementando el valor más pequeño en 1 en cada partición. Por supuesto, se eliminarán las particiones duplicadas. Para obtener la partición entera n = 2 y en adelante,

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

Uso

   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

Explicación

Como J no admite matrices irregulares, cada partición debe estar encuadrada para que no se rellenen con ceros cuando se agreguen a otras particiones.

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

— millas
fuente

4

Python, 65 bytes

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

Esta función acumula una partición e imprime las salidas, ramificando las opciones. Decide cuántos 1 colocar en la partición, cuántos 2, etc. Para cada valor i, ya sea

Agrega una parte del tamaño iy disminuye na n-i, o
Se mueve a i+1

Si i>n, entonces no se pueden hacer más partes, por lo que se detiene. Si ncae 0, la partición se realiza correctamente y, por lo tanto, se imprime.

Python 2

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

Un método recursivo que genera una lista de particiones. Al igual que con el código Python 3, cuenta el tamaño de la parte iy decide en cada paso si agregar otra parte de tamaño io detener.

Ambos lo hacen n=15casi al instante.

— xnor
fuente

3

Javascript, 194 bytes

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

No minificado

Encontrar elementos únicos clasificando y comparando con una cadena es un gran truco, pero probablemente ahorra espacio.

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

— Mella
fuente

44

Quite a hack but saves spaceDe eso se trata exactamente este sitio. : D

— DJMcMayhem

2

Python 3.5, 82 72 bytes

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

Devuelve un conjunto de tuplas. n = 15 termina al instante.

Probarlo en repl.it .

— Dennis
fuente

2

Haskell, 44 bytes

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

La función auxiliar n%mda las particiones de nen partes ≥m, con la función principal usando m=1. Se ramifica de cada primera entrada jcon m≤j≤n, recurriendo en la partición restante de n-jen partes que son al menos j. El caso base n==0da solo la partición vacía.

— xnor
fuente

1

Pyth, 17 bytes

L|{SMs+LVrb0yMb]Y

Define una función llamada y. Pruébalo en línea .

— Anders Kaseorg
fuente

1

Jalea , 9 bytes

b1ŒṖḅ1Ṣ€Q

Pruébalo en línea!

Cómo funciona

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.

— Dennis
fuente

1

J, 39 bytes

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

Este es un verbo monádico que toma un número entero y devuelve una matriz de matrices en caja. Pruébalo aquí. Uso:

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

En la entrada 15, se ejecuta durante aproximadamente un segundo en mi máquina.

Explicación

Este desafío inmediatamente parecía un trabajo para Catalog ( {) y Cut ( ;.). El esquema del algoritmo es:

Produce todas las matrices 0-1 de longitud n.
Para cada uno de ellos, corte una nmatriz de longitud ficticia a lo largo de los 1s y enumere las longitudes de cada parte.
Ordene las longitudes y elimine matrices duplicadas del resultado.

Aparentemente, Luis Mendo también tuvo la misma idea .

Explicación del código:

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

— Zgarb
fuente

Muy buen uso de corte de ;.nuevo.

— millas

1

Brachylog , 33 bytes (no competidor)

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

Esto no es competitivo debido a una corrección de errores.

Esto toma aproximadamente 1 segundo 15en mi máquina. Para 20y más, esto se bloquea con una Out of global stackexcepción.

Explicación

Esto no utiliza particiones integradas de ningún tipo, y en su lugar utiliza el hecho de que +funciona en ambos sentidos a través de la propagación de restricciones.

Predicado principal:

: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

Predicado 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

— Fatalizar
fuente

1

Mathematica, 62 54 bytes

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

Las particiones de un número entero n se pueden encontrar resolviendo n -tuplas de números enteros no negativos ( c ₁ , c ₂ , ..., c _n ) de modo que c ₁ + 2 c ₂ + ... + n c _n = n . FrobeniusSolvees capaz de encontrar todas las soluciones a esta ecuación que se utilizan para crear tantas copias de sus respectivos valores con el fin de encontrar todas las particiones enteras de n .

— millas
fuente

... y ¿cómo no es esto incorporado?

— Leaky Nun

@LeakyNun FrobeniusSolveno encuentra particiones enteras, encuentra todas las soluciones de enteros no negativos x1 ... xN a las ecuaciones de la forma a1 x1 + a2 x2 + ... aN xN = bdada a1 ... aNy b.

— millas

0

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

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

Puerto de la solución Python de @ xnor. (Si tan solo me hubiera dado cuenta de que podrías volver a aparecer my n...)

— Neil
fuente

Calcular las particiones de N

Prueba IO

Catalogar

Pyth, 10 9 bytes

Pyth, 18 bytes

MATL , 20 bytes

Explicación

Haskell, 53 bytes

J, 49 42 36 35 32 bytes

Uso

Explicación

Python, 65 bytes

Javascript, 194 bytes

Python 3.5, 82 72 bytes

Haskell, 44 bytes

Pyth, 17 bytes

Jalea , 9 bytes

Cómo funciona

J, 39 bytes

Explicación

Brachylog , 33 bytes (no competidor)

Explicación

Mathematica, 62 54 bytes

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