Sytuacja:

Kilka ( M) krasnoludów znalazło skrzynię goblina ze Nzłotymi monetami i muszą je podzielić. Ze względu na starożytne zasady rządzące przydzielaniem łupów piratom w kolejności starszeństwa, najstarszy krasnolud powinien dostać jedną monetę więcej niż następny najstarszy krasnolud itd., Aby najmłodszy krasnolud otrzymał M-1mniej monet niż najstarszy krasnolud. Ponadto żaden krasnolud nie musi rzucać monetą (tzn. Żadnych monet ujemnych do żadnych krasnoludów)

Pomóż krasnoludom podzielić monety w ten sposób lub powiedz im, że jest to niemożliwe.

Kod zwycięzcy musi zawsze odpowiadać poprawnie (wyzwanie jest deterministyczne) i przestrzegać ogólnych zasad gry w golfa .

Wkład

Otrzymujesz liczbę całkowitą N (3 ≤ N ≤ 1000) dla liczby monet i liczbę całkowitą M (3 ≤ M ≤ N) dla liczby krasnoludów, oddzielonych spacją.

Wydajność

Jeśli nie można podzielić monet w sposób, jaki chcą krasnoludy, wydrukuj -1 (minus jeden). W przeciwnym razie wydrukuj liczbę monet, które otrzyma każdy karzeł, od najstarszych do najmłodszych. Oddziel liczby spacjami.

Próbki :

wkład

3 3

wydajność

2 1 0

wkład

9 3

wydajność

4 3 2

wkład

7 3

wydajność

-1

wkład

6 4

wydajność

3 2 1 0

J - 32 29 28 25

Nie krótszy niż inne rozwiązanie J, ale i używa innego pomysłu

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

Odpowiedź na liczbę monet, które otrzymuje gnom o najwyższej randze, to po prostu N/M+(M-1)/2(jeśli jest to liczba całkowita), konstruujemy negatywną wartość tego -:@-.@]-%. Następnie i:tworzy taką tablicę 2 1 0 _1 _2dla argumentu _2i bierzemy z niej elementy M.

J - 30 znaków

Bardzo fajnie gra w golfa. Wiele rzeczy wyszło dobrze.

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

Wyjaśnienie:

• /- Weź liczby całkowite rozdzielone spacjami jako argument i przesuń funkcję między nimi. To znaczy, rozważ N lewy argument funkcji w nawiasach, (...)a M prawy argument.

• i.&-- Negate ( -), a następnie weź liczby całkowite ( i.). Zwykle, gdy robisz coś takiego i.5, jak dostajesz 0 1 2 3 4. Ilekroć i.otrzymuje liczbę ujemną, jednak odwraca tę listę wyjściową. Tak np . i._5Da 4 3 2 1 0.

• s=.+/&- Wykonaj powyższą akcję dla każdego argumentu ( &), a następnie utwórz tabelę dodatków ( +/) z tych tablic. Mamy teraz tabelę, w której każdy rząd jest możliwą dystrybucją monet do M krasnoludów, choć może nie, gdy jest N monet. Wreszcie, ten czasownik tworzący tabelę jest tak przydatny, że nazwiemy go si użyjemy go później.

• +/@s~- Teraz używamy sponownie, ale zamieniamy ( ~) kolejność argumentów, aby transponować tabelę. Jest to golfowy sposób pobierania sumy każdego wiersza po utworzeniu tabeli ( +/@), związany ze sposobem, w jaki J sumuje listy wielowymiarowe.

• i.[ - Na tej liście sum szukamy lewego argumentu czasownika, tj. N. Jeśli N jest pozycją, otrzymujemy ten indeks: w przeciwnym razie otrzymujemy długość listy, która w szczególności jest niepoprawnym indeksem.

• { ::_1:- Teraz próbujemy użyć indeksu, aby wyciągnąć wiersz z tabeli w s. {wyrzuci błąd domeny, jeśli indeks był nieprawidłowy, więc w takim przypadku łapiemy błąd ( ::) i zwracamy -1 ( _1:). To obsługuje wszystko. Ponieważ używamy i.&-wcześniej, dystrybucja monet będzie w kolejności malejącej, zgodnie z wymaganiami.

Stosowanie:

   ((+/@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 znaków

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

Nie golfowany:

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)

Rozwiązanie:

Jeśli M liczba krasnoludów, sekwencję płatnego złota można rozłożyć na dwie osobliwe serie. Najpierw szereg kończący się na zero: M-1, ..., 2, 1, 0 i stała seria c, c, ..., c. Suma pierwszej serii to zawsze M * (M-1) / 2. Więc jeśli resztę (x = N - M * (M-1) / 2) można podzielić bez reszty (moduł równy 0), każdy karzeł otrzymuje x / M plus część malejącej serii.

Stosowanie:

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

To moja pierwsza próba gry w golfa i wiem, że może być lepiej, ale nadal :)

Gra w golfa:

<?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');}?>

Nie golfowany:

<?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');
}
?>

Wykonaj w powłoce

Podstawowy pomysł:

Monety można oddzielić według tych reguł, jeśli jedna z nich jest prawdziwa:

1. Krasnoludy mają nieparzystą liczbę, a monety są podzielne przez krasnoludy bez pozostałości
2. Krasnoludy mają parzystą liczbę, a monety pozostałe po podzieleniu monet / krasnoludów są równe połowie liczby krasnoludów

Jeśli tak, przyjmujemy za podstawę średnie monety na karła (ACPD). Ale musimy zacząć od najwyższej mocy wyjściowej, aż osiągniemy najniższą. Tworzymy więc pętlę z licznikiem, zaczynając od ACPD + liczba pozostałych krasnoludów w kierunku wyższego końca, i kontynuujemy aż do osiągnięcia ACPD - liczba pozostałych krasnoludów w kierunku dolnego końca.

Zasadniczo jest tak samo, jeśli krasnoludy są nieparzyste (tj. 5 krasnoludów - środkowy ma 3, a na obu końcach pozostają 2), ale nie, jeśli są parzyste - dlatego polegamy na podłodze ORAZ okrągłej.

Dotychczasowe problemy: działa ze zbyt niską liczbą monet, co oznacza, że ​​niektóre krasnoludy zostaną rozbite i pozbawione cennych zarobków. I to jest smutne A przynajmniej jeśli lubisz krasnoludy.

Rozwiązanie :

1. Pomyśl o sposobie obliczenia najmniejszej liczby monet, aby obliczenia nie kończyły się na krasnoludach w pyle.
2. Projektuj niezbyt chciwych krasnoludów.

Inteligentniejsze rozwiązanie :

Monety są metalowe. Spraw, by krasnoludy stopiły je wszystkie, a następnie rzuciły je w mniejszą / większą liczbę monet, tak aby można je było podzielić.

Najmądrzejsze rozwiązanie :

Ukradnij ich górę, zmień nazwę na Smaug i zachowaj to wszystko dla siebie. W końcu po co zawracać sobie głowę zrzędliwymi krasnoludami?

Python 3 (100)

Korzystanie z tego samego pomysłu co @Geobits, ale zgodne z wymaganiami wejściowymi i wyjściowymi.

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

Korzystając z tego samego pomysłu co Evpok, ale z kilkoma ulepszeniami.

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

Ulepszenia to:

1. Eliminowanie przestrzeni po sobie i przed ''. 1 znak
2. Eliminowanie „” wewnątrz podziału (), ponieważ podział na spacje jest domyślny. 3 znaki
3. Obniżenie x o 1, zmieniając -1 na +1 w divmod, a następnie zmieniając funkcję zasięgu, aby użyć opcji odwrotnej kolejności zakresu. 3 znaki.
4. EDYCJA: ... jeśli ... jeszcze ... zmieniono na ... i ... lub ... 2 znaki.
5. EDYCJA: Divmod jawnie, r usunięte. 4 znaki.
6. EDYCJA: x usunięte, m // n użyte jawnie. 1 znak
7. EDYCJA: użyto wyrażeń oznaczonych gwiazdką zamiast '' .join (mapa (str, ...)), dodano x, aby uniknąć powtarzania print (). 12 znaków.
8. EDYCJA: Zrozumiałem, że pozwalam krasnoludom podać ujemną liczbę monet. Zmieniłem kod, aby tego uniknąć.

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

Działa poprzez sprawdzenie, czy N-(M*(M-1)/2)można go równomiernie podzielić M. Nowy w Pythonie, więc wszelkie wskazówki są mile widziane.

Przykład Ideone.com

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

Okropny wynik, ale wybrałem inne podejście i skorzystałem z niego goto:)

Skrócę to później.

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 znaków

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

Utwórz wektor, przechodząc od (M-1) do 0 i dodaje 1 do każdej liczby, aż suma nie będzie już gorsza od N. Jeśli jest wyższa, wyprowadzaj -1 w innym przypadku, wypisz wektor.

Wcięte i lekko pozbawione golfa:

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
    )

Przykładowe użycie:

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

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

Odrobina algebry zajęła mi znacznie więcej czasu, niż powinna.

JavaScript - 76

Zauważ, że k + (k - 1) + ... + (k - (M - 1)) = M (k - (M - 1) / 2) Ustawienie tej wartości na N daje k = N / M + (M -1) / 2 dla najwyższej kwoty. Jeśli jest to liczba całkowita, to k% 1 == 0, a szukane kwoty to k, k - 1, ..., k - (M - 1).

Prawdopodobnie mógłbym napisać to krócej w innym języku, ale nie było jeszcze rozwiązania JS, więc oto:

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

Uruchom w konsoli.

Przykładowe dane wejściowe:

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

Wydajność:

3
2
1 

Wkład:

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

Wydajność:

3
2
1
0

Wkład:

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

Wyjście: -1

Szkoda, że ​​konsola.log jest tak długa, by przeliterować :) Niestety deklaracja l=console.log.bind(console)nie skraca jej i po prostu l=console.lognie działa.

Wkład:

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

Wydajność:

76

Golfscript, 35

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

Jak to działa

W poniższym przykładzie dane wejściowe to 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.

Jak to działa.

Odczytuje 2 liczby całkowite, monety i krasnoludy.
Odejmuje różnicę na krasnoluda.
Jeśli reszta modów krasnoludków> 0 to niemożliwe.
W przeciwnym razie uzyskaj równy udział na krasnoluda w pętli krasnoludków od 1 do 0 i drukuje dwarfIndex + równy udział

Bez golfa

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

Funkcja ggeneruje wszystkie sekwencje rosnące o jeden o długości m od 0 do n i sprawdza, czy którakolwiek z nich sumuje się do m. Jeśli się powiedzie, sekwencja jest zwracana; w przeciwnym razie zwracane jest -1.

Sekwencje są tworzone przez Partitionumieszczenie listy {0,1,2,3… m} we wszystkich możliwych podlistach n ciągłych liczb całkowitych.

Istnieją oczywiście bardziej wydajne sposoby osiągnięcia tego samego efektu, ale te, które znalazłem, wymagają więcej kodu.

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

Przykłady

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

Bez golfa

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

Kompiluje się to z ostrzeżeniem, ponieważ main nie ma typu. Jeśli nie jest to ważne w zasadach golfa, musiałbym dodać pięć znaków.

Kobra - 198

Witryna Cobra

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(" "))

Wyjaśnił:

class P
    def main

Wymagane do uruchomienia kodu

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

Pobiera dane wejściowe i zapisuje je jako aib

        l=[]
        t=n=0

Inicjuje listę wyników li inicjalizuje całkowitą ilość pieniędzy ti liczbę monet, które należy dodać do każdego stosu krasnoludówn

        for i in b,t+=i

Znajduje najniższą możliwą wartość pieniężną, która spowoduje, że wszystkie krasnoludy będą miały na stosie dopuszczalną liczbę monet

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

Określa, ile monet należy dodać do każdego stosu, tak aby suma wymaganych pieniędzy wynosiła> = do całkowitej dostępnej kwoty

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

Wypełnia listę stosami pieniędzy o różnych rozmiarach

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

Wyjścia znakami -1lub lzależnie czy całkowita wymagana pieniędzy jest równa całkowitej dostępnej pieniędzy

Perl 5 , 78 + 1 (-n) = 79 bajtów

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

Wypróbuj online!

Python ( 100 96 94):

Ładna, punktowana odpowiedź. Już nie, ale teraz jest krótszy.

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]

Nie golfowany:

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

Wydajność:

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]