Ich habe es genossen, diese Seite zu lesen. das ist meine erste frage Änderungen sind willkommen.

Berechnen Sie bei positiven Ganzzahlen n und m alle geordneten Partitionen von m in genau n Teile positive Ganzzahlenteile und drucken Sie sie durch Kommas und Zeilenumbrüche getrennt aus. Jede Bestellung ist in Ordnung, aber jede Partition muss genau einmal erscheinen.

Zum Beispiel sind bei m = 6 und n = 2 mögliche Partitionen Paare von positiven ganzen Zahlen, die sich zu 6 summieren:

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

Beachten Sie, dass [1,5] und [5,1] unterschiedlich angeordnete Partitionen sind. Die Ausgabe sollte genau das oben angegebene Format haben und optional einen Zeilenumbruch enthalten. (BEARBEITEN: Die genaue Reihenfolge der Partitionen spielt keine Rolle). Die Eingabe / Ausgabe ist über Standard - Code-Golf - I / O .

Eine weitere Beispielausgabe für 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

Der kleinste Code in Bytes nach 1 Woche gewinnt.

Auch hier bitte bei Bedarf nachbearbeiten.

Nachtrag:

@TimmyD fragte, welche Größe der Integer-Eingabe das Programm unterstützen soll. Es gibt kein hartes Minimum jenseits der Beispiele; Tatsächlich nimmt die Ausgabegröße exponentiell zu, grob modelliert durch: 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 Bytes

V^SQEIqsNQj\,N

Probieren Sie es online aus: Demo oder Test Suite

Erläuterung:

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 Bytes

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

Eine rekursive Funktion, die jede Ausgabezeichenfolge erstellt und druckt. Versucht jede mögliche erste Zahl, rekursiv, um eine Lösung mit der entsprechenden verringerten Summe nund einem Summanden weniger mund einem Zeichenfolgepräfix smit dieser Zahl zu finden. Wenn sowohl die erforderliche Summe als auch die Anzahl der Terme gleich 0 sind, haben wir die Marke erreicht und drucken das Ergebnis aus, wobei das Anfangskomma abgeschnitten wird. Dies wird als m|n0 (Falsey) geprüft .

79 Zeichen 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 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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 bis 18 Bytes

-2 Bytes von @Dennis!

jjL\,fqQlT{s.pM./E

Dies ist ndie erste und mdie zweite Eingabezeile .

Probieren Sie es hier aus .

Haskell, 68 Bytes

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

Anwendungsbeispiel:

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

So funktioniert es: sequence $ replicate n listErstellt alle Kombinationen von nElementen gezeichneter Form list. Wir nehmen alle solche xvon [1..m]wo das sumgleich m. unlinesund init$tail$showdas gewünschte Ausgabeformat erzeugen.

Dyalog APL , 33 Bytes

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

Nimmt mals linkes Argument, nals rechtes Argument.

Fast die Hälfte (zwischen {und ⍺) ist für die erforderliche Formatierung.

Mathematica, 65 Bytes

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

IntegerPartitionserledigt die Aufgabe. Der Rest ist nur die Tupel zu bestellen und das Ergebnis zu formatieren.

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)

Ich habe seit einiger Zeit keinen Einzeiler mehr geschafft. :)

Python 2.7, 174 170 152 Bytes

Fette Antwort. Zumindest ist es lesbar :)

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 Bytes

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

Dies ist eine Funktion, die zwei Ganzzahlargumente liest und die Ergebnisse mit einem einzelnen Zeilenvorschub nach STDOUT schreibt.

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 Bytes

Wenn die Ausgabe eine Liste von Listen sein könnte

{[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;

Wie es derzeit heißt, muss ich joindem Lambda einen hinzufügen .

{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