Wahrscheinlich eine einfache Code-Golf-Herausforderung. Wenn 2 positive Ganzzahlen mund gegeben sind n, erstellen Sie eine Liste mit nWerten, die positive Ganzzahlen sind und deren Summe der Zahl entspricht m. Entweder sind alle Werte in der Ausgabe gleich oder die Differenz ist genau 1.

Beispiele

Beispielsweise

• m=6und n=3würde werden2, 2, 2
• m=7und n=3würde 2, 2, 3oder 2, 3, 2oder werden 3, 2, 2
• m=7und n=2würde 3, 4oder werden4, 3
• m=7und n=1würde werden7
• m=7und n=8würde einen Fehler erzeugen, da die Summe von 8 positiven ganzen Zahlen nicht 7 sein kann.
• m=10und n=4würde 3, 3, 2, 2oder jede andere Permutation werden

Regeln

• Sowohl bei der Eingabe als auch bei der Ausgabe handelt es sich nur um positive ganze Zahlen.
• Entweder sind alle Werte in der Ausgabe gleich oder die Differenz ist genau 1.
• Die Reihenfolge der Werte in der Liste ist nicht wichtig.
• Die Summe der Werte in der Liste ist gleich m.
• Wenn es nicht lösbar ist, generieren Sie einen Fehler oder einen falschen Wert (im Fall von m = 7 und n = 8 zum Beispiel).
• Als Ergebnis der anderen Regeln m=8und n=3würde eine der Permutationen von 3, 3, 2(nicht 2, 2, 4) erzeugen

Der Gewinner

Das ist Code-Golf, also gewinnt die kürzeste gültige Antwort - gemessen in Bytes.

Gaia , 4 Bytes

…÷l¦

Es gibt fast nur eine eingebaute für diese ...

Erläuterung

…     Get the range [0 .. m-1].
 ÷    Split into n roughly even length chunks. Throws an error if the number of chunks if 
       more than the list's length.
  l¦  Get the length of each chunk.

Python 2 , 48 43 Bytes

Gibt 0bei einem Fehler zurück.

lambda m,n:m/n and[m/n]*(n-m%n)+m%n*[m/n+1]

Probieren Sie es online!

41 Bytes (mit @ xnors Trick)

Wirft NameErrorauf Fehler.

lambda m,n:[m/n or _]*(n-m%n)+m%n*[m/n+1]

Probieren Sie es online!

Mathematica, 33 Bytes

#>#2&&Last@IntegerPartitions@##1&

Eingang

[63, 11]

Ausgabe

{6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5}

gibt False aus, wenn es nicht lösbar ist

MATL , 7 Bytes

:gie!Xs

Wenn es keine Lösung gibt, ist die Ausgabe ein Array mit mindestens einer Null, was in MATL falsch ist.

Probieren Sie es online!

Erläuterung

Betrachten Sie Eingaben m = 10und n = 4.

:      % Implicitly input m. Push [1 2 ... m]
       % STACK: [1 2 3 4 5 6 7 8 9 10]
g      % Logical: convert nonzeros to 1
       % STACK: [1 1 1 1 1 1 1 1 1 1]
i      % Input n
       % STACK: [1 1 1 1 1 1 1 1 1 1], 4
e      % Reshape into matrix with n rows, padding with zeros
       % STACK: [1 1 1;
                 1 1 1;
                 1 1 0;
                 1 1 0]
!      % Transpose
       % STACK: [1 1 1 1;
                 1 1 1 1;
                 1 1 0 0]
Xs     % Sum of each column. Implicitly display
       % STACK: [3 3 2 2]

Haskell , 30 Bytes

m%n|m>=n=map(`div`n)[m..m+n-1]

Probieren Sie es online!

Kohle , 15 Bytes nach dem Anwenden von NDD ¹

¿÷ＮＮＩＥＩη÷⁺ＩθιＩη

Probieren Sie es online!

Gibt nichts aus, wenn es keine Lösung gibt. Link zur ausführlichen Version .

¹ NDD = Neil-Driven Development.

Meine vorherige Antwort:

Holzkohle , 32 27 24 20 Bytes

ＮμＮν¿÷μνＩＥν⁺÷μν‹ι﹪μν

Probieren Sie es online!

Gibt nichts aus, wenn es keine Lösung gibt. Link zur ausführlichen Version .

Natürlich hätte ich es nicht ohne Neils Hilfe spielen können.

R , 33 Bytes

function(m,n)diff(trunc(0:n*m/n))

Ein Port von Luis Mendos Oktavantwort . Ziemlich traurig, dass dies fast 50% kürzer ist als meine vorherige Antwort.

Probieren Sie es online!

vorherige Antwort, 63 Bytes:

function(m,n,o=rep(m%/%n,n),d=m-sum(o))o+c(rep(0,n-d),rep(1,d))

Eine anonyme Funktion , die zwei (obligatorisch) Argumente nimmt mund nund zwei optional diejenigen , die für den Golfsport gedacht sind. Gibt einen Vektor in aufsteigender Reihenfolge zurück. Für Fehler ist der erste Wert 0, der in R falsch ist, da ifnur der erste Wert des Vektors verwendet wird (mit einer Warnung).

Es entspricht im Wesentlichen der folgenden Funktion:

function(m,n){o=rep(m%/%n,n)
d=m-sum(o)
o+c(rep(0,n-d),rep(1,d))}

Probieren Sie es online!

Gelee , 7 6 Bytes

:ȧœsL€

Probieren Sie es online! Gibt nichts für falsch aus.

Wie es funktioniert

:ȧœsL€    Main link. Arguments: m (integer), n (integer)
:         Integer division. Yields 0 if m < n; a positive integer otherwise.
 ȧ        Logical AND. Yields 0 if m < n; m otherwise.
  œs      Split into n roughly equal groups. Since the left argument is an integer,
          this implicitly converts it to [1..m] (or [] for 0) before splitting.
    L€    Length of €ach. If the inputs were 7 and 3, the previous result would be
          [[1,2,3],[4,5],[6,7]], so this would give [3,2,2].

TI-Basic, 23 Bytes

:Prompt M,N
:N(M≥N
:int(Ans⁻¹randIntNoRep(M,M+N-1

Gibt im Fehlerfall ERR: DIVIDE BY 0 zurück

Oktave , 24 Bytes

@(m,n)diff(fix(0:m/n:m))

Der Code definiert eine anonyme Funktion. Die Ausgabe ist ein numerisches Array (Zeilenvektor). Wenn es keine gibt, enthält dieses Array mindestens eine Null, was in Octave falsch ist .

Probieren Sie es online!

Erläuterung

0:m/n:mErzeugt ein Array von n+1Werten von 0bis mmit step m/n. fixRundet jeden Eintrag auf 0und diffberechnet aufeinanderfolgende Differenzen.

Als Beispiel sind hier alle Zwischenergebnisse für m = 7, n = 3:

>> 0:m/n:m
ans =
         0    2.3333    4.6667    7.0000

>> fix(0:m/n:m)
ans =
     0     2     4     7

>> diff(fix(0:m/n:m))
ans =
     2     2     3

Haskell , 93 89 88 87 86 71 Bytes

m!n|n<=m=e$m:(0<$[2..n])
e(a:b:x)|b<a=e$a-1:e(b+1:x)
e(a:x)=a:e x
e x=x

Probieren Sie es online!

Erläuterung

Die Hauptfunktion ist hier e. ewird eine Liste nehmen und im Wesentlichen einen Nudelholz entlang von links nach rechts laufen. Während es ein Element in der Liste gibt, das größer ist als sein Nachbar rechts, werden wir eines von ihm nach rechts verschieben.

Jetzt müssen wir dieser Funktion nur noch eine ausreichend einseitige Liste zuführen und sie die Magie ausführen lassen. Auf die Liste, die wir auswählen, mfolgen nur n-1Nullen. Da ist das einfach zu machen.

Als letztes müssen wir sicherstellen, dass der Fehlerfall behandelt wird. Dafür werfen wir nur einen Non-exhaustive patterns in functionFehler, solange m>n.

C # (.NET Core) , 86 82 71 Bytes

using System.Linq;a=>b=>new int[b].Select((x,i)=>(i<a%b?1:0/(a/b))+a/b)

Löst einen Fehler für ungültige Eingaben aus.

Probieren Sie es online!

-4 Bytes dank TheLethalCoder

-11 Bytes dank OlivierGrégoire

Haskell, 48 Bytes

m#n|m>=n=iterate(\(a:b)->b++[a+1])(0<$[1..n])!!m

Beginnen Sie mit einer Liste von nNullen. Wiederholen Sie die mZeiten: Nehmen Sie das erste Element, fügen Sie eines hinzu und setzen Sie es an das Ende der Liste.

Schlägt mit einem Mustervergleichsfehler fehl, wenn n < m.

Probieren Sie es online!

Braingolf , 30 Bytes

.M>.M/v.mR>[.]$_v%!?[R1+>v]|R=

Probieren Sie es online!

Nimmt Eingaben in umgekehrter Reihenfolge vor ( nist erste Eingabe, mist zweite)

Dividiert mdurch n, dupliziert die Ergebnis - nmal, dann in einer Schleife durch und Inkremente nacheinander m % nmal

Batch, 71 Bytes

@if %1 geq %2 for /l %%i in (1,1,%2)do @cmd/cset/an=(%1+%%i-1)/%2&echo(

cmd/cset/aGibt kein Trennzeichen aus, muss also verwendet werden echo(( (vermeidet das Drucken ECHO is on.).

PHP> = 7.1, 62 Bytes

for([,$s,$n]=$argv;$n;)$s-=$r[]=$s/$n--^0;$r[0]?print_r($r):0;

PHP Sandbox Online

Python 2 , 41 Bytes

lambda m,n:(m%n*[m/n+1]+[m/n or _]*n)[:n]

Probieren Sie es online!

NameError wenn es unmöglich ist.

Python 2 , 43 Bytes

lambda m,n:[c/n for c in range(m,m+n,m>=n)]

Probieren Sie es online!

ValueError wenn es unmöglich ist.

Javascript (ES6), 57 56 53 41 Bytes

m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

Die Antwort umfasst jetzt eine intelligentere Methode zur Erstellung der Werte. Danke @Neil

Verwendung

f=m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

f(6)(3) // [2, 2, 2]
f(7)(3) // [3, 2, 2]
f(7)(2) // [4, 3]
f(7)(1) // [7]
f(7)(8) // false
f(8)(3) // [3, 3, 2]

Geschichte

Zuerst meins

(m,n)=>m>=n&&Array(n).fill(~~(m/n)).map((v,i)=>v+(i<m%n))

(m,n)=>m>=n&&Array(n).fill().map((v,i)=>~~(m/n)+(i<m%n))

Anschließend wurde der Spread-Operator und die von @Arnauld eingegebene Currying-Syntax hinzugefügt

m=>n=>m>=n&&[...Array(n)].map((v,i)=>~~(m/n)+(i<m%n))

Java (OpenJDK 8) , 80 73 63 61 59 Bytes

n->m->{for(int i=n;i-->0/(m/n);)System.out.println(m++/n);}

Probieren Sie es online!

Beachten Sie, für Currying Zwecke, mund nsind umgekehrt.

Pyth , 11 Bytes

efqlTeQ./hQ

Probieren Sie es online!

Pyth , 13 Bytes

KE?>KQ0lMcK*d

Probieren Sie es online! Ausgabe 0bei Fehler.

Schummeln, 6 Bytes

lMcE*d

Probieren Sie es online! Das Array enthält einen Ein- 0Fehler. Leider ist das in Pyth nicht falsch .

Erläuterung

KE?>KQ0lMcK*dQ    # Implicit input Q for m
KE                # Store n in K
           *d     # Generate a string of length Q containing only spaces
         cK       # Chop this string in K pieces of equal sizes, initial piece longer if necessary
       lM         # For each string, compute the length. Here we already have our result. However if the array contain a zero, we must output a falsy value
  ?>KQ            # If K > Q...
      0           # Then display zero, otherwise display the array

CJam , 13 12 Bytes

{_2$>/,/z:,}

Probieren Sie es online!

Dies ist ein anonymer Block, der die Eingabe wie n mauf dem Stapel nimmt. Es wäre eine gute Antwort gewesen, aber das Erfordernis der Fehlerbehandlung hat es völlig zunichte gemacht.

Fehler mit einer Division durch Null, wenn es nicht möglich ist, sie zu lösen.

Erläuterung

{   e# Stack:                | 3 10
 _  e# Duplicate:            | 3 10 10
 2$ e# Copy from back:       | 3 10 10 3
 >  e# Greater than:         | 3 10 1 (true)
 /  e# Divide:               | 3 10
    e# This will cause an error on invalid input.
 ,  e# Range:                | 3 [0 1 2 3 4 5 6 7 8 9]
 /  e# Split on nth element: | [[0 1 2] [3 4 5] [6 7 8] [9]]
 z  e# Transpose array:      | [[0 3 4 9] [1 4 7] [2 5 8]]
 :, e# Length of each:       | [4 3 3]
}

Wenn die Fehlerbehandlungsanforderung aufgehoben wird, kann dies auf 7 Byte verkürzt werden, was einer Verringerung von über 40% entspricht:

{,/z:,}