La situation:

Plusieurs ( M) nains ont trouvé un coffre de gobelin avec Ndes pièces d'or et doivent les diviser. En raison des anciennes règles régissant l'attribution du butin aux pirates par ordre d'ancienneté, le nain le plus âgé devrait obtenir une pièce de plus que le nain le plus ancien suivant, et ainsi de suite, de sorte que le plus jeune nain reçoive M-1moins de pièces que le plus vieux nain. De plus, aucun nain ne doit lancer de pièces (c.-à-d. Aucune pièce négative à aucun nain)

Aidez les nains à diviser les pièces de cette façon, ou dites-leur que c'est impossible.

Le code du gagnant doit toujours répondre correctement (ce défi est déterministe) et suivre les règles générales du code-golf .

Contribution

On vous donne un entier N (3 ≤ N ≤ 1000) pour le nombre de pièces et un entier M (3 ≤ M ≤ N) pour le nombre de nains, séparés par des espaces.

Sortie

S'il est impossible de diviser les pièces comme le veulent les nains, imprimez -1 (moins un). Sinon, imprimez le nombre de pièces que chaque nain recevra, du plus vieux au plus jeune. Séparez les nombres par des espaces.

Échantillons :

contribution

3 3

sortie

2 1 0

contribution

9 3

sortie

4 3 2

contribution

7 3

sortie

-1

contribution

6 4

sortie

3 2 1 0

J - 32 29 28 25

ne pas plus court que les autres solutions J, mais et utilise une idée différente

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

La réponse pour le nombre de pièces que le gnome de rang le plus élevé obtient est simplement N/M+(M-1)/2(si c'est un entier), nous construisons le négatif de cela -:@-.@]-%. Fait ensuite i:un tableau comme celui-ci 2 1 0 _1 _2pour l'argument _2et nous en prenons M éléments.

J - 30 caractères

Très amusant au golf. Beaucoup de choses ont bien fonctionné.

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

Explication:

• /- Prenez les entiers séparés par des espaces comme argument et glissez la fonction entre eux. C'est-à-dire, considérons N l'argument gauche de la fonction entre parenthèses (...)et M l'argument droit.

• i.&-- Negate ( -) puis prenez des entiers ( i.). Normalement, lorsque vous faites quelque chose comme i.5vous0 1 2 3 4 . Chaque fois qu'il i.reçoit un nombre négatif, cependant, il inverse cette liste de sortie. Donc, par exemple i._5, donnera 4 3 2 1 0.

• s=.+/& - Effectuez l'action ci-dessus sur chaque argument (& ) puis créez une table d'addition ( +/) à partir de ces tableaux. Nous avons maintenant une table où chaque ligne est une distribution possible de pièces aux M nains, mais peut-être pas quand il y a N pièces. Enfin, ce verbe de création de table est si utile que nous allons l'appeler set le réutiliser plus tard.

• +/@s~ - Maintenant, nous utilisons s nouveau, mais nous échangeons ( ~) l'ordre des arguments, afin de transposer le tableau. C'est une façon golfique de prendre la somme de chaque ligne après avoir créé la table ( +/@), en rapport avec la façon dont J additionne les listes multidimensionnelles.

• i.[ - Dans cette liste de sommes, on cherche l'argument gauche du verbe, c'est-à-dire N. Si N est un item, on obtient cet index: sinon on obtient la longueur de la liste, qui est notamment un index invalide.

• { ::_1:- Maintenant, nous essayons d'utiliser l'index pour extraire une ligne du tableau s. {va lancer une erreur de domaine si l'index n'était pas valide, donc dans ce cas, nous interceptons l'erreur ( ::) et retournons -1 ( _1:). Cela gère tout. Puisque nous utilisons i.&-précédemment, la distribution des pièces sera dans l'ordre décroissant, comme cela était nécessaire.

Usage:

   ((+/@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 caractères

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)

Solution:

Si M le nombre de nains, alors la séquence d'or payé peut être décomposée en deux séries singulières. D'abord une série se terminant par zéro: M-1, ..., 2, 1, 0 et une série constante de c, c, ..., c. La somme de la première série est toujours M * (M-1) / 2. Donc, si le reste (x = N - M * (M-1) / 2) pouvait être divisé sans reste (modulo égal à 0), chaque nain obtient x / M plus la partie de la série décroissante.

Usage:

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

C'est ma première tentative de golf, et je sais que ça pourrait être mieux, mais quand même :)

Golfé:

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

Exécuter dans un shell

Idée basique:

Les pièces peuvent être séparées par ces règles, si l'une d'entre elles est vraie:

1. Les nains sont des nombres impairs, et les pièces sont divisibles par les nains sans restes
2. Les nains sont des nombres pairs, et les pièces restantes après la division des pièces / nains sont égales à la moitié du nombre de nains

Si c'est le cas, nous prenons pour base la moyenne des pièces par nain (ACPD). Mais nous devons partir du plus haut et produire jusqu'à ce que nous atteignions le plus bas. Nous faisons donc une boucle avec un compteur à partir de ACPD + le décompte des autres nains vers l'extrémité supérieure, et continuons jusqu'à ce que nous atteignions l'ACPD - le décompte des autres nains vers l'extrémité inférieure.

C'est fondamentalement la même chose si les nains sont impairs (c'est-à-dire 5 nains - celui du milieu est 3, et aux deux extrémités il en reste 2), mais pas s'ils sont pairs - c'est pourquoi nous comptons sur le sol ET rond.

Problèmes jusqu'à présent: fonctionne avec un nombre de pièces trop faible, ce qui signifie que certains nains seront frappés et volés de leurs précieux gains. Et c'est triste. Ou du moins si vous aimez les nains.

Solution :

1. Pensez à un moyen de calculer le plus petit nombre de pièces pour que le calcul ne se termine pas avec des nains dans la poussière.
2. Concevez des nains pas si gourmands.

Solution plus intelligente :

Les pièces sont en métal. Faites fondre tous les nains, puis jetez-les dans une quantité de pièces plus petite / plus grande, afin qu'ils soient divisibles dans tous les cas.

Solution la plus intelligente :

Volez leur montagne, renommez-vous Smaug et gardez tout pour vous. Après tout, pourquoi devez-vous vous embêter avec des nains grincheux?

Python 3 (100)

En utilisant la même idée que @Geobits mais en se conformant aux exigences d'entrée et de sortie.

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 102 90 93

En utilisant la même idée que Evpok, mais avec un certain nombre d'améliorations.

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

Les améliorations sont les suivantes:

1. Éliminer l'espace après et avant ''. 1 caractère
2. Éliminer le '' inside split (), car le fractionnement sur les espaces est un défaut. 3 personnages
3. Réduire x de 1 en changeant le -1 en +1 à l'intérieur du divmod, puis en changeant la fonction de plage pour utiliser l'option d'ordre inversé de la plage. 3 caractères.
4. EDIT: ... si ... sinon ... changé en ... et ... ou ... 2 caractères.
5. EDIT: Divmod rendu explicite, r supprimé. 4 caractères.
6. EDIT: x supprimé, m // n utilisé explicitement. 1 caractère
7. EDIT: utilisé des expressions suivies au lieu de '' .join (map (str, ...)), ajouté x pour éviter de répéter print (). 12 caractères.
8. EDIT: J'ai réalisé que je permettais aux Nains de donner un nombre négatif de pièces. J'ai changé le code pour éviter cela.

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

Fonctionne en vérifiant si N-(M*(M-1)/2)est également divisible par M. Nouveau sur python, donc tous les conseils sont appréciés.

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

Score horrible mais j'ai adopté une approche différente et j'ai pu utiliser goto:)

Je le raccourcirai plus tard.

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 caractères

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

Créez un vecteur allant de (M-1) à 0 et ajoutez 1 à chaque nombre jusqu'à ce que la somme ne soit plus inférieure à N. Si elle est supérieure, sortez -1 sinon sortez le vecteur.

Indenté et légèrement non golfé:

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
    )

Exemple d'utilisation:

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

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

Juste un peu d'algèbre, ça m'a pris beaucoup plus de temps que prévu.

JavaScript - 76

Observez que k + (k - 1) + ... + (k - (M - 1)) = M (k - (M - 1) / 2) Régler cette valeur sur N donne k = N / M + (M -1) / 2 pour le montant le plus élevé. S'il s'agit d'un entier, alors k% 1 == 0 et les montants que nous recherchons sont k, k - 1, ..., k - (M - 1).

J'aurais probablement pu écrire cela plus court dans une autre langue, mais il n'y avait pas encore de solution JS alors voici:

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

Exécutez dans la console.

Exemple d'entrée:

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

Sortie:

3
2
1 

Contribution:

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

Sortie:

3
2
1
0

Contribution:

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

Sortie: -1

Dommage que console.log soit si long à épeler :) Malheureusement, la déclaration l=console.log.bind(console)ne la raccourcit pas et l=console.logne fonctionne tout simplement pas.

Contribution:

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

Sortie:

76

Golfscript, 35

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

Comment ça marche

Dans l'exemple suivant, l'entrée est 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.

Comment ça marche.

Lit 2 entiers, pièces et nains.
Soustrait la différence par nain.
Si le mod restant nains> 0, c'est impossible.
Sinon, obtenez une part égale par nain dans une boucle de nains-1 à 0 et affiche dwarfIndex + part égale

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

La fonction g,, génère toutes les séquences croissant par un, de longueur m, de 0 à n et vérifie si l'une d'elles se résume à m. En cas de succès, la séquence est renvoyée; sinon, -1 est retourné.

Les séquences sont faites par Partition insérant la liste {0,1,2,3… m} dans toutes les sous-listes possibles de n entiers contigus.

Il existe bien sûr des moyens plus efficaces pour obtenir le même effet, mais ceux que j'ai trouvés nécessitent plus de code.

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

Exemples

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
}

Cela se compile avec un avertissement car main n'a pas de type. Si ce n'est pas valable dans les règles du golf, je devrais ajouter cinq caractères.

Cobra - 198

Site Web de 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(" "))

A expliqué:

class P
    def main

Requis pour que le code s'exécute

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

Prend l'entrée et la stocke comme aetb

        l=[]
        t=n=0

Initialise la liste de sortie let initialise l'argent total requis tet le nombre de pièces à ajouter à chaque pile de nainsn

        for i in b,t+=i

Trouve la valeur monétaire la plus basse possible qui fera en sorte que tous les nains auront un nombre de pièces autorisé dans leur pile

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

Détermine le nombre de pièces à ajouter à chaque pile afin que l'argent total requis soit> = à l'argent total disponible

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

Remplit la liste avec les piles d'argent de différentes tailles

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

Sorties soit -1ou lselon que le montant total requis est égal au total disponible

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

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

Essayez-le en ligne!

Python ( 100 96 94):

Une belle réponse ronde. Plus maintenant, mais c'est plus court maintenant.

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

Sortie:

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]