Die Situation:

Mehrere ( M) Zwerge haben eine Koboldkiste mit NGoldmünzen gefunden und müssen diese teilen. Aufgrund der alten Regeln, die die Zuteilung von Beute an Piraten in der Reihenfolge ihres Dienstalters regeln, sollte der älteste Zwerg eine Münze mehr als der nächstälteste Zwerg usw. erhalten, damit der jüngste Zwerg M-1weniger Münzen als der älteste Zwerg erhält . Außerdem muss kein Zwerg Münzen einwerfen (dh keine negativen Münzen für Zwerge)

Hilf den Zwergen, die Münzen auf diese Weise zu teilen, oder sag ihnen, dass dies unmöglich ist.

Der Code des Gewinners muss immer richtig antworten (diese Herausforderung ist deterministisch) und den allgemeinen Code-Golf- Regeln folgen .

Eingang

Sie erhalten eine ganze Zahl N (3 ≤ N ≤ 1000) für die Anzahl der Münzen und eine ganze Zahl M (3 ≤ M ≤ N) für die Anzahl der durch Leerzeichen getrennten Zwerge.

Ausgabe

Wenn es nicht möglich ist, die Münzen so zu teilen, wie es die Zwerge wollen, drucke -1 (minus eins). Andernfalls drucken Sie die Anzahl der Münzen, die jeder Zwerg erhält, vom ältesten bis zum jüngsten. Trennen Sie die Zahlen mit Leerzeichen.

Proben :

Eingang

3 3

Ausgabe

2 1 0

Eingang

9 3

Ausgabe

4 3 2

Eingang

7 3

Ausgabe

-1

Eingang

6 4

Ausgabe

3 2 1 0

J - 32 29 28 25

Nicht kürzer als andere J-Lösung, aber und verwendet eine andere Idee

(]{.[:i:-:@-.@]-%)/ ::_1:

Die Antwort für die Anzahl der Münzen, die der Gnom mit dem höchsten Rang erhält, ist einfach N/M+(M-1)/2(wenn es eine ganze Zahl ist), wir konstruieren das Negative davon -:@-.@]-%. Dann i:macht man ein Array wie dieses 2 1 0 _1 _2zum Argument _2und wir nehmen M Elemente daraus.

J - 30 Zeichen

Sehr viel Spaß beim Golfen. Vieles hat gut geklappt.

((+/@s~i.[){ ::_1:s=.+/&i.&-)/

Erläuterung:

• /- Nehmen Sie die durch Leerzeichen getrennten ganzen Zahlen als Argument und verteilen Sie die Funktion zwischen ihnen. Das heißt, man betrachte N als linkes Argument für die Funktion in Klammern (...)und M als rechtes Argument.

• i.&-- Negiere ( -) und nimm dann ganze Zahlen ( i.). Normalerweise, wenn Sie so etwas tun wie i.5Sie bekommen 0 1 2 3 4. Wenn i.jedoch eine negative Zahl empfangen wird, wird diese Ausgabeliste umgekehrt. So wird zB i._5geben 4 3 2 1 0.

• s=.+/&- Führen Sie die obige Aktion für jedes Argument ( &) aus und erstellen Sie +/aus diesen Arrays eine Additionstabelle ( ). Wir haben jetzt eine Tabelle, in der jede Zeile eine mögliche Verteilung von Münzen an M Zwerge darstellt, obwohl dies vielleicht nicht der Fall ist, wenn es N Münzen gibt. Schließlich ist dieses Verb zur Tabellenerstellung so nützlich, dass wir ses später erneut aufrufen und verwenden werden.

• +/@s~- Jetzt verwenden wir swieder, vertauschen ( ~) aber die Reihenfolge der Argumente, damit wir die Tabelle transponieren. Dies ist eine einfache Methode, um die Summe jeder Zeile nach dem Erstellen der Tabelle ( +/@) zu berechnen. Dies hängt damit zusammen, wie J mehrdimensionale Listen summiert.

• i.[ - In dieser Summenliste suchen wir nach dem linken Argument des Verbs, dh N. Wenn N ein Element ist, erhalten wir diesen Index. Andernfalls erhalten wir die Länge der Liste, die insbesondere ein ungültiger Index ist.

• { ::_1:- Jetzt versuchen wir, mit dem Index eine Zeile aus der Tabelle herauszuholen s. {wird einen Domänenfehler auslösen, wenn der Index ungültig war. In diesem Fall wird der Fehler abgefangen ( ::) und -1 ( _1:) zurückgegeben. Das erledigt alles. Da wir i.&-zuvor verwendet haben, erfolgt die Verteilung der Münzen in absteigender Reihenfolge, wie erforderlich.

Verwendung:

   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 9 3
4 3 2
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 7 3
_1
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 6 4
3 2 1 0
   ((+/@s~i.[){ ::_1:s=.+/&i.&-)/ 204 17
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4

R - 71 70 67 66 65 Zeichen

s=scan();m=s[2];x=s[1]-sum(1:m);cat(if(x%%m|-m>x)-1 else x/m+m:1)

Ungolfed:

s = scan()    # Reads N and M by stdin.
m = s[2]
x = s[1] - m*(m-1)/2
cat(if (x %% m | x < -m) -1 else x/m + m:1)

Lösung:

Wenn M die Anzahl der Zwerge ist, kann die Folge des bezahlten Goldes in zwei singuläre Reihen zerlegt werden. Zuerst eine mit Null endende Reihe: M-1, ..., 2, 1, 0 und eine konstante Reihe von c, c, ..., c. Die Summe der ersten Reihe ist immer M * (M-1) / 2. Wenn also der Rest (x = N - M * (M-1) / 2) ohne Rest geteilt werden könnte (Modulo gleich 0), erhält jeder Zwerg x / M plus den Teil der abnehmenden Reihe.

Verwendung:

> s=scan()
1: 10 4
3: 
Read 2 items
> m=s[2]
> x = s[1] - m*(m-1)/2
> cat(if (x %% m || x<0) -1 else x/m + (m-1):0)
4 3 2 1

PHP (187)

Es ist mein erster Versuch, Golf zu spielen, und ich weiß, es könnte besser sein, aber trotzdem :)

Golf gespielt:

<?php
$b=fgets(STDIN);list($c,$d)=explode(' ',$b);if((($d&1)AND($c%$d==0))OR($c%$d==$d/2)){for($e=floor($c/$d)+floor($d/2);$e>floor($c/$d)-round($d/2);$e--){echo"$e ";}}else{die('-1');}?>

Ungolfed:

<?php
$a = fgets(STDIN);
list($coins, $dwarves) = explode(' ', $a);
if ((($dwarves & 1) AND ($coins % $dwarves == 0)) OR ($coins % $dwarves == $dwarves / 2)) {
    for (
        $i = floor($coins / $dwarves) + floor($dwarves / 2);
        $i > floor($coins / $dwarves) - round($dwarves / 2);
        $i--
    ) {
        echo "$i ";
    }
}
else { 
  die('-1');
}
?>

In einer Shell ausführen

Grundidee:

Münzen können durch diese Regeln getrennt werden, wenn eine der folgenden Bedingungen erfüllt ist:

1. Die Zwerge haben eine ungerade Zahl und die Münzen sind durch die Zwerge ohne Überreste teilbar
2. Die Zwerge sind gerade Zahlen, und die Münzen, die nach dem Teilen der Münzen / Zwerge übrig bleiben, entsprechen der Hälfte der Zwergenzahl

Wenn ja, nehmen wir als Basis die durchschnittlichen Münzen pro Zwerg (ACPD). Wir müssen jedoch von der höchsten zur niedrigsten Leistung gehen. Also machen wir eine Schleife mit einem Zähler, der von ACPD + der Zählung der übrigen Zwerge zum oberen Ende beginnt, und fahren fort, bis wir die ACPD erreichen - die Zählung der übrigen Zwerge zum unteren Ende.

Grundsätzlich ist es dasselbe, wenn die Zwerge ungerade sind (dh 5 Zwerge - der mittlere ist 3 und an beiden Enden verbleiben 2), aber nicht, wenn sie gerade sind - weshalb wir uns auf Boden UND Runde verlassen.

Bisherige Probleme: Funktioniert mit einer zu niedrigen Münzzahl, was bedeutet, dass einige Zwerge geschlagen und ihrer kostbaren Einnahmen beraubt werden. Und das ist traurig. Oder zumindest, wenn Sie Zwerge mögen.

Lösung :

1. Überlegen Sie sich, wie Sie die geringste Menge an Münzen berechnen können, damit die Berechnung nicht zu Zwergen im Staub führt.
2. Entwirf nicht so gierige Zwerge.

Intelligentere Lösung :

Münzen sind Metall. Lass die Zwerge sie alle zum Schmelzen bringen und wirf sie dann in kleinere / größere Mengen Münzen, damit sie auf jeden Fall teilbar sind.

Intelligenteste Lösung :

Stehlen Sie ihren Berg, benennen Sie sich in Smaug um und behalten Sie alles für sich. Warum musst du dich schließlich mit mürrischen Zwergen herumschlagen?

Python 3 (100)

Verwenden der gleichen Idee wie @Geobits, jedoch gemäß den Anforderungen für Eingabe und Ausgabe.

n,m=map(int,input().split())
κ,ρ=divmod(n-m*(m-1)//2,m)
x=[-1]if ρ else range(κ,κ+m)[::-1]
print(*x)

Python 3 - 109 107 103 102 90 93

Verwendung der gleichen Idee wie Evpok, jedoch mit einer Reihe von Verbesserungen.

n,m=map(int,input().split())
k=n/m+m/2
a=int(k)
print(*(range(a,a-m,-1),[-1])[k-a-.5or~a>-m])

Die Verbesserungen sind:

1. Leerzeichen nach sonst und vor '' entfernen. 1 Zeichen
2. Eliminieren Sie das '' in split (), da das Aufteilen auf Leerzeichen eine Standardeinstellung ist. 3 Zeichen
3. Verringern Sie x um 1, indem Sie -1 in +1 in divmod ändern, und ändern Sie dann die Bereichsfunktion, um die Option für die umgekehrte Reihenfolge des Bereichs zu verwenden. 3 Zeichen.
4. EDIT: ... wenn ... sonst ... geändert in ... und ... oder ... 2 Zeichen.
5. EDIT: Divmod explizit gemacht, r entfernt. 4 Zeichen.
6. EDIT: x entfernt, m // n explizit verwendet. 1 Zeichen
7. BEARBEITEN: Verwenden Sie markierte Ausdrücke anstelle von '' .join (map (str, ...)), und fügen Sie x hinzu, um zu vermeiden, dass print () wiederholt wird. 12 Zeichen.
8. EDIT: Mir wurde klar, dass ich erlaubte, dass die Zwerge eine negative Anzahl von Münzen erhielten. Ich habe den Code geändert, um dies zu vermeiden.

Python 3 - 114

n,m=map(int,input().split(' '))
r=range(m);n-=sum(r)
if n%m<1:
 for x in r:print(m-x+n//m-1,end=' ')
else:print -1

Funktioniert, indem geprüft wird, ob durch N-(M*(M-1)/2)gleichmässig teilbar ist M. Neu in Python, also alle Tipps geschätzt.

Ideone.com Beispiel

Input:
735 30
Output:
39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10

C # - 322

using System;using System.Linq;namespace D{class P{static void Main(string[]args){int n=Convert.ToInt16(args[0]);int m=Convert.ToInt16(args[1]);bool b=false;int q=n/2+1;g:b=!b;int[]z=new int[m];for(int i=0;i<m;i++){z[i]=q-i;}if(z.Sum()==n)foreach(int p in z)Console.Write(p+" ");else{q--;if(b)goto g;Console.Write(-1);}}}}

Schreckliche Punktzahl, aber ich habe einen anderen Ansatz gewählt und verwendet goto:)

Ich werde es später verkürzen.

Java 210

class A { public static void main(String[] a){int d=Integer.parseInt(a[0]),c=Integer.parseInt(a[1]);if (2*c%d==0) for (int i=0;i<d;i++) System.out.print((((1+(2*c/d)-d)/2)+i)+" "); else System.out.print(-1);}}

R: 77 73 70 Zeichen

a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))

Erstellen Sie einen Vektor von (M-1) bis 0 und addieren Sie 1 zu jeder Zahl, bis die Summe nicht mehr unter N liegt. Wenn sie überlegen ist, geben Sie -1 aus, andernfalls geben Sie den Vektor aus.

Eingerückt und leicht ungolfed:

a=scan()   #Reads in stdin (by default numeric, space-separated)
r=a[2]:1-1 #Creates vector (M-1) to 0
while(sum(r)<a[1])r=r+1 #Increments all member of vector by 1 until sum is not inferior to N
cat( #Outputs to stdout
    `if`(sum(r)>a[1], -1, r) #If superior to N: impossible, returns -1
    )

Anwendungsbeispiel:

> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 9 3
3: 
Read 2 items
4 3 2
> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 7 3
3: 
Read 2 items
-1
> a=scan();r=a[2]:1-1;while((n=sum(r))<a[1])r=r+1;cat(`if`(n>a[1],-1,r))
1: 204 17
3: 
Read 2 items
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4

Julia, 45 Jahre alt

f(n,m)=(x=n/m-m/2+1/2;x%1==0?[x+m-1:-1:x]:-1)
julia> f(6,4)'
1x4 Array{Float64,2}:
 3.0  2.0  1.0  0.0

Nur ein bisschen Algebra, ich habe viel länger gebraucht, als ich sollte.

JavaScript - 76

Man beachte, dass k + (k - 1) + ... + (k - (M - 1)) = M (k - (M - 1) / 2) Wenn dies gleich N ist, ergibt sich k = N / M + (M -1) / 2 für den höchsten Betrag. Wenn dies eine Ganzzahl ist, dann ist k% 1 == 0 und die gesuchten Beträge sind k, k - 1, ..., k - (M - 1).

Ich hätte das wahrscheinlich in einer anderen Sprache kürzer schreiben können, aber es gab noch keine JS-Lösung.

N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

Führen Sie in der Konsole aus.

Beispiel Eingabe:

N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

Ausgabe:

3
2
1 

Eingang:

N=6;M=4;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

Ausgabe:

3
2
1
0

Eingang:

N=7;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)

Ausgabe: -1

Schade, console.log ist so lange zu buchstabieren :) Leider macht das Deklarieren l=console.log.bind(console)es nicht kürzer und l=console.logfunktioniert einfach nicht.

Eingang:

"N=3;M=3;if((r=N/M+(M-1)/2)%1)console.log(-1);else while(M--)console.log(r--)".length

Ausgabe:

76

Golfscript, 35

~:M.(*2/-.M%{;-1}{M/M+,-1%M<' '*}if

Wie es funktioniert

Im folgenden Beispiel lautet die Eingabe 9 3.

          # STACK: "9 3"
~         # Interpret the input string.
          # STACK: 9 3
:M        # Store the top of the stack (number of dwarves) in variable `M'.
.         # Duplicate the top of the stack.
          # STACK: 9 3 3
(         # Decrement the top of the stack.
          # STACK: 9 3 2
*         # Multiply the topmost elements of the stack.
          # STACK: 9 6
2/        # Divide the top of the stack by `2'.
          # STACK: 9 3
          # So far, we've transformed `M' into `M*(M-1)/2', which is the minimum amount of
          # coins all dwarves together will get. This number comes from the fact that the
          # youngest dwarf will get at least 0 coins, the next at least 1 coin, etc., and
          # 0 + 1 + ... + (M - 1) = M*(M-1)/2.
-         # Subtract the topmost elements of the stack.
          # STACK: 6
          # The remaining coins have to get reparted evenly to all dwarves.
.         # Duplicate the top of the stack.
          # STACK: 6 6
M%        # Calculate the top of the stack modulus `M'.
          # STACK: 6 0
{         # If the modulus is positive, the remaining coins cannot get reparted evenly.
    ;-1   # Replace the top of the stack by `-1'.
}
{         # If the modulus is zero, the remaining coins can get reparted evenly.
    M/    # Divide the top of the stack by `M'.
          # STACK: 2
          # This is the number of coins all dwarves will get after giving 1 to the second
          # youngest, etc.
    M+    # Add `M' to the top of the stack.
          # STACK: 5
    ,     # Replace the top of the stack by an array of that many elements.
          # STACK: [ 0 1 2 3 4 ]
          # The rightmost element is the number of coins the oldest dwarf will get.
    -1%   # Reverse the array.
          # STACK: [ 4 3 2 1 0 ]
    M<    # Keep the leftmost `M' elements.
          # STACK: [ 4 3 2 ]
          # There are only `M' dwarves.
    ' '*  # Join the array, separating by spaces.
          # STACK: "4 3 2"
}if

Delphi XE3 (176)

uses SysUtils;var d,c,i:integer;begin read(c,d);for I:=1to d-1do c:=c-i;if c mod d>0then writeln(-1)else begin c:=c div d;for I:=d-1downto 0do write(IntToStr(i+c)+' ');end;end.

Wie es funktioniert.

Liest 2 Ganzzahlen, Münzen und Zwerge.
Subtrahiert die Differenz pro Zwerg.
Wenn der Rest Mod Zwerge> 0 ist es unmöglich.
Andernfalls erhalten Sie den gleichen Anteil pro Zwerg in einer Zwergenschleife von 1 bis 0 und drucken den Zwergenindex + den gleichen Anteil

Ungolfed

uses SysUtils;
var
  d,c,i:integer;
begin
  read(c,d);
  for I:=1to d-1do
    c:=c-i;
  if c mod d>0then
    writeln(-1)
  else
  begin
    c:=c div d;
    for I:=d-1downto 0do
      write(IntToStr(i+c)+' ');
  end;
end.

Mathematica 65

Die Funktion gerzeugt alle um eins ansteigenden Folgen der Länge m von 0 bis n und prüft, ob eine von ihnen zu m summiert. Bei Erfolg wird die Sequenz zurückgegeben. Andernfalls wird -1 zurückgegeben.

Die Folgen ergeben sich aus Partitionder Liste {0,1,2,3… m} in alle möglichen Unterlisten von n zusammenhängenden ganzen Zahlen.

Es gibt natürlich effizientere Möglichkeiten, um den gleichen Effekt zu erzielen, aber die, die ich gefunden habe, erfordern mehr Code.

n_~g~m_:=If[(s=Select[Partition[0~Range~n,m,1],Tr@#==n&])=={},-1,s]

Beispiele

g[9, 3]

{{2, 3, 4}}

g[3, 3]

{{0, 1, 2}}

g[7, 3]

-1

g[705, 3]

{{234, 235, 236}}

g[840, 16]

{{45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60}}

g[839, 16]

-1

C 131

#include <edk.h>
main(int a,char **v){int j=atoi(*++v),k=atoi(*++v)-j*(j-1)/2;k<0||k%j?j=1,k=-1:k/=j;while(j--)printf("%d ",k+j);}

Ungolfed

#include <edk.h> //Shortest standard header including stdio.h and stdlib.h
main(int a,char **v)
{
    int j=atoi(*++v),k=atoi(*++v)-j*(j-1)/2;

    k<0||k%j?j=1,k=-1:k/=j;  // If youngest dwarf gets < 0 or amount not equally divisible then set values such that ...

    while(j--)printf("%d ",k+j); // ... loop prints out correct values
}

Dies wird mit einer Warnung kompiliert, da main keinen Typ hat. Wenn dies nicht in den Golfregeln gültig ist, müsste ich fünf Zeichen hinzufügen.

Cobra - 198

Cobra Website

class P
    def main
        x,y=Console.readLine.split
        a,b=x to int,y to int
        l=[]
        t=n=0
        for i in b,t+=i
        while (t+=b)<=a,n+=1
        for i in b,l.insert(0,i+n)
        print if(t-b<>a,-1,l.join(" "))

Erklärt:

class P
    def main

Erforderlich, damit der Code ausgeführt werden kann

        x,y=Console.readLine.split
        a,b=x to int,y to int

Nimmt Eingaben und speichert sie als aundb

        l=[]
        t=n=0

Initialisiert die Ausgabeliste lund initialisiert das erforderliche Geld tund die Anzahl der Münzen, die jedem Zwergenstapel hinzugefügt werden sollenn

        for i in b,t+=i

Findet den niedrigstmöglichen Geldwert, der dazu führt, dass alle Zwerge eine zulässige Anzahl von Münzen auf ihrem Stapel haben

        while (t+=b)<=a,n+=1

Legt fest, wie viele Münzen zu jedem Stapel hinzugefügt werden sollen, sodass das erforderliche Gesamtgeld> = dem insgesamt verfügbaren Geld entspricht

        for i in b,l.insert(0,i+n)

Füllt die Liste mit den unterschiedlich großen Geldhaufen

        print if(t-b<>a,-1,l.join(" "))

Gibt entweder -1oder labhängig davon aus, ob das insgesamt benötigte Geld dem insgesamt verfügbaren Geld entspricht

Perl 5 , 78 + 1 (-n) = 79 Bytes

($d)=/ (.*)/;$,=$";say(($b=$_-($d**2-$d)/2)%$d?-1:map$_+$b/$d,reverse 0..$d-1)

Probieren Sie es online!

Python ( 100 96 94):

Eine schöne, runde Antwort. Nicht mehr, aber es ist jetzt kürzer.

def f(n,m):a=range(m)[::-1];b=n-sum(a);c=b/m;d=[i+c for i in a];return(d,-1)[-1in d or c*m!=b]

Ungolfed:

def f(n,m):
 a = range(m)[::-1]
 b = sum(a)
 c = (n-b)/m
 if c * m != n-b: return -1
 d = [i+c for i in a]
 return (d,-1)[-1 in d or c!=n-b]
 if -d in d or c*m!=n-b:
  return -1
 return d

Ausgabe:

def f(n,m):a=range(m)[::-1];b=sum(a);c=(n-b)/m;d=[i+c for i in a];return (d,-1)[-1 in d or c*m!=n-b]

f(3,3)
Out[2]: [2, 1, 0]

f(9,3)
Out[3]: [4, 3, 2]

f(7,3)
Out[4]: -1

f(6,4)
Out[5]: [3, 2, 1, 0]