Mi è piaciuto leggere questo sito; questa è la mia prima domanda Le modifiche sono benvenute.

Dati interi positivi n e m , calcola tutte le partizioni ordinate di m in n esattamente parti intere positive e stampale delimitate da virgole e newline. Qualsiasi ordine va bene, ma ogni partizione deve apparire esattamente una volta.

Ad esempio, dati m = 6 e n = 2, le partizioni possibili sono coppie di numeri interi positivi che si sommano a 6:

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

Si noti che [1,5] e [5,1] sono partizioni ordinate diverse. L'output dovrebbe essere esattamente nel formato sopra, con una nuova riga finale facoltativa. (EDIT: l'ordine esatto delle partizioni non ha importanza). L'ingresso / uscita avviene tramite I / O di codice golf standard .

Un altro esempio di output per m = 7, n = 3:

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

Vince il codice più piccolo in byte dopo 1 settimana.

Ancora una volta, si prega di modificare se necessario.

Addendum:

@TimmyD ha chiesto quale dimensione di input intero deve supportare il programma. Non esiste un minimo minimo oltre gli esempi; in effetti, la dimensione dell'output aumenta in modo esponenziale, approssimativamente modellato da: lines = e ^ (0.6282 n - 1.8273).

n | m | lines of output
2 | 1 | 1
4 | 2 | 2
6 | 3 | 6
8 | 4 | 20
10 | 5 | 70
12 | 6 | 252
14 | 7 | 924
16 | 8 | 3432
18 | 9 | 12870
20 | 10 | 48620
22 | 11 | 184756
24 | 12 | 705432

Pyth, 14 byte

V^SQEIqsNQj\,N

Provalo online: dimostrazione o Test Suite

Spiegazione:

V^SQEIqsNQj\,N   implicit: Q = first input number
  SQ             create the list [1, 2, ..., Q]
    E            read another number
 ^               cartesian product of the list
                 this creates all tuples of length E using the numbers in SQ
V                for each N in ^:
     IqsNQ          if sum(N) == Q:
          j\,N         join N by "," and print

Python 3, 77 byte

def f(n,m,s=''):[f(i,m-1,',%d'%(n-i)+s)for i in range(n)];m|n or print(s[1:])

Una funzione ricorsiva che crea ogni stringa di output e la stampa. Cerca ogni possibile primo numero, ricorrendo verso il basso per trovare una soluzione con la somma ridotta corrispondente ne un summand in meno me un prefisso di stringa scon quel numero. Se sia la somma richiesta che il numero di termini sono uguali a 0, abbiamo raggiunto il segno, quindi stampiamo il risultato, tagliando la virgola iniziale. Questo è controllato come m|n0 (Falsey).

79 caratteri in Python 2:

def f(n,m,s=''):
 if m|n==0:print s[1:]
 for i in range(n):f(i,m-1,','+`n-i`+s)

CJam, 22 byte

q~:I,:)m*{:+I=},',f*N*

Provalo online nell'interprete CJam .

Come funziona

q~                      Read and evaluate all input. Pushes n and m.
  :I                    Save m in I.
    ,:)                 Turn it into [1 ... I].
       m*               Push all vectors of {1 ... I}^n.
         {    },        Filter; for each vector:
          :+I=            Check if the sum of its elements equals I.
                        Keep the vector if it does.
                ',f*    Join all vectors, separating by commas.
                    N*  Join the array of vectors, separating by linefeeds.

Pyth, 20 18 byte

-2 byte di @Dennis!

jjL\,fqQlT{s.pM./E

Questo prende ncome prima riga di input e mcome seconda.

Provalo qui .

Haskell, 68 byte

n#m=unlines[init$tail$show x|x<-sequence$replicate n[1..m],sum x==m]

Esempio di utilizzo:

*Main> putStr $ 2#6
1,5
2,4
3,3
4,2
5,1

Come funziona: sequence $ replicate n listcrea tutte le combinazioni di nelementi disegnati sotto forma list. Prendiamo tutto questo xda [1..m]dove è sumuguale m. unlinese init$tail$showproduce il formato di output richiesto.

Dyalog APL , 33 byte

{↑1↓¨,/',',¨⍕¨↑⍺{⍵/⍨⍺=+/¨⍵},⍳⍵/⍺}

Prende mcome argomento di sinistra, ncome argomento di destra.

Quasi la metà (tra {e ⍺) è per la formattazione richiesta.

Mathematica, 65 byte

StringRiffle[Permutations/@#~IntegerPartitions~{#2},"
","
",","]&

IntegerPartitionsfa il compito. Il resto è solo per ordinare le tuple e formattare il risultato.

Python 3, 112

from itertools import*
lambda m,n:'\n'.join(','.join(map(str,x))for x in product(range(m),repeat=n)if sum(x)==m)

Non gestisco 1 linea da un po '. :)

Python 2.7, 174 170 152 byte

Risposta grassa. Almeno è leggibile :)

import sys,itertools
m=int(sys.argv[1])
for k in itertools.product(range(1,m),repeat=int(sys.argv[2])):
    if sum(k)==m:print str(k)[1:-1].replace(" ","")

Julia, 105 byte

f(m,n)=for u=∪(reduce(vcat,map(i->collect(permutations(i)),partitions(m,n)))) println("$u"[2:end-1])end

Questa è una funzione che legge due argomenti interi e scrive i risultati su STDOUT con un singolo feed di riga finale.

Ungolfed:

function f(m::Integer, n::Integer)
    # Get the integer partitions of m of length n
    p = partitions(m, n)

    # Construct an array of all permutations
    c = reduce(vcat, map(i -> collect(permutations(i)), p))

    # Loop over the unique elements
    for u in unique(c)
        # Print the array representation with no brackets
        println("$u"[2:end-1])
    end
end

Perl 6 , 54 byte

Se l'output potrebbe essere un elenco di elenchi

{[X] (1..$^m)xx$^n .grep: $m==*.sum} # 36 bytes

my &code = {[X] (1..$^m)xx$^n .grep: $m==*.sum}
say .join(',') for code 7,3;

Il modo in cui è attualmente formulato devo aggiungere a joinlambda.

{say .join(',')for [X] (1..$^m)xx$^n .grep: $m==*.sum} # 54 bytes

{...}( 7,3 );

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