A situação:

Vários ( M) anões encontraram o baú de um goblin com Nmoedas de ouro e precisam dividi-las. Devido às regras antigas que regem a alocação de pilhagem aos piratas em ordem de antiguidade, o anão mais velho deve receber uma moeda a mais que o próximo anão mais antigo, e assim por diante, para que o anão mais novo receba M-1menos moedas que o anão mais antigo. Além disso, nenhum anão precisa arremessar moedas (ou seja, nenhuma moeda negativa para anões)

Ajude os anões a dividir as moedas dessa maneira, ou diga a eles que isso é impossível.

O código do vencedor deve sempre responder corretamente (esse desafio é determinístico) e seguir as regras gerais do código-golfe .

Entrada

Você recebe um número inteiro N (3 ≤ N ≤ 1000) para o número de moedas e um número inteiro M (3 ≤ M ≤ N) para o número de anões, separados por espaço.

Saída

Se for impossível dividir as moedas da maneira que os anões querem, imprima -1 (menos uma). Caso contrário, imprima o número de moedas que cada anão receberá, do mais antigo para o mais novo. Separe os números com espaços.

Amostras :

entrada

3 3

saída

2 1 0

entrada

9 3

saída

4 3 2

entrada

7 3

saída

-1

entrada

6 4

saída

3 2 1 0

J - 32. 29 28. 25

Não mais curto que outra solução J, mas e usa uma ideia diferente

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

A resposta para o número de moedas que o gnomo mais alto está recebendo é simples N/M+(M-1)/2(se for um número inteiro), construímos o negativo disso -:@-.@]-%. Em seguida, i:cria um array como esse 2 1 0 _1 _2para o argumento _2e extraímos elementos M dele.

J - 30 caracteres

Muito divertido de golfe. Muitas coisas deram certo.

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

Explicação:

• /- Pegue os números inteiros separados por espaço como argumento e insira a função entre eles. Ou seja, considere N o argumento da esquerda para a função entre colchetes (...)e M o argumento da direita.

• i.&-- Negue ( -) e depois pegue números inteiros ( i.). Normalmente, quando você faz algo como i.5você recebe 0 1 2 3 4. Sempre que i.recebe um número negativo, no entanto, ele reverte essa lista de saída. Então, por exemplo, i._5vai dar 4 3 2 1 0.

• s=.+/&- Execute a ação acima em cada argumento ( &) e faça uma tabela de adição ( +/) com essas matrizes. Agora temos uma tabela em que cada linha é uma possível distribuição de moedas para M anões, embora talvez não quando haja N moedas. Finalmente, esse verbo de criação de tabela é tão útil que vamos chamá-lo se usá-lo novamente mais tarde.

• +/@s~- Agora, usamos snovamente, mas trocamos ( ~) a ordem dos argumentos, para que possamos transpor a tabela. Esta é uma maneira prática de obter a soma de cada linha após criar a tabela ( +/@), relacionada à maneira como J soma listas multidimensionais.

• i.[ - Nesta lista de somas, procuramos o argumento esquerdo do verbo, ou seja, N. Se N é um item, obtemos o índice: caso contrário, obtemos o comprimento da lista, que é notavelmente um índice inválido.

• { ::_1:- Agora tentamos usar o índice para extrair uma linha da tabela s. {lançará um erro de domínio se o índice for inválido; nesse caso, capturamos o erro ( ::) e retornamos -1 ( _1:). Isso lida com tudo. Como usamos i.&-anteriormente, a distribuição das moedas estará em ordem decrescente, conforme necessário.

Uso:

   ((+/@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 caracteres

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)

Solução:

Se M o número de anões, a sequência de ouro pago pode ser decomposta em duas séries singulares. Primeiro, uma série que termina em zero: M-1, ..., 2, 1, 0 e uma série constante de c, c, ..., c. A soma da primeira série é sempre M * (M-1) / 2. Portanto, se o restante (x = N - M * (M-1) / 2) puder ser dividido sem o restante (módulo igual a 0), cada anão recebe x / M mais a parte da série decrescente.

Uso:

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

É a minha primeira tentativa de jogar golfe, e sei que poderia ser melhor, mas ainda assim :)

Golfe:

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

Executar em um shell

Ideia básica:

As moedas podem ser separadas por essas regras, se uma delas for verdadeira:

1. Os anões são números ímpares, e as moedas são divisíveis pelos anões sem restos
2. Os anões são números pares e as moedas restantes após a divisão de moedas / anões é igual à metade do número dos anões

Nesse caso, tomamos como base as moedas médias por anão (ACPD). Mas temos que começar do mais alto e produzir até chegarmos ao mais baixo. Então, fazemos um loop com um contador que começa em ACPD + a contagem do resto dos anões no final mais alto e continuamos até chegarmos ao ACPD - a contagem do restante dos anões no final mais baixo.

É basicamente o mesmo se os anões forem ímpares (ou seja, 5 anões - o do meio é 3, e em ambas as extremidades permanecem 2), mas não se forem pares - é por isso que confiamos no chão E na volta.

Problemas até agora: funciona com número de moedas muito baixo, o que significa que alguns anões serão derrubados e roubados de seus ganhos preciosos. E isso é triste. Ou pelo menos se você gosta de anões.

Solução :

1. Pense em uma maneira de calcular a menor quantidade de moedas para que o cálculo não acabe com os anões na poeira.
2. Crie anões não tão gananciosos.

Solução mais inteligente :

Moedas são de metal. Faça os anões derreterem todos e depois jogue-os em uma quantidade menor / maior de moedas, para que sejam divisíveis em qualquer caso.

Solução mais inteligente :

Roube a montanha deles, mude o nome para Smaug e guarde tudo por si. Afinal, por que você tem que se preocupar com anões rabugentos?

Python 3 (100)

Usando a mesma idéia que o @Geobits, mas em conformidade com os requisitos de entrada e saída.

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

Usando a mesma idéia que o Evpok, mas com várias melhorias.

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

As melhorias são:

1. Eliminando o espaço depois e depois ''. 1 caractere
2. Eliminar o '' dentro de split (), porque a divisão em espaços é o padrão. 3 caracteres
3. Reduzir x por 1 alterando -1 para +1 dentro do divmod e, em seguida, alterando a função range para usar a opção de ordem inversa do range. 3 caracteres.
4. EDIT: ... se ... else ... alterado para ... e ... ou ... 2 caracteres.
5. EDIT: Divmod explicitado, r removido. 4 caracteres.
6. EDIT: x removido, m // n usado explicitamente. 1 caractere
7. EDIT: usou expressões estreladas em vez de '' .join (map (str, ...)), adicionou x para evitar repetir print (). 12 caracteres.
8. EDIT: Eu percebi que estava permitindo que números negativos de moedas fossem dados aos anões. Mudei o código para evitar isso.

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

Funciona verificando se N-(M*(M-1)/2)é igualmente divisível por M. Novo no python, então qualquer dica é apreciada.

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

Pontuação horrível, mas tomei uma abordagem diferente e comecei a usar goto:)

Vou encurtá-lo mais tarde.

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 caracteres

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

Crie um vetor que vai de (M-1) a 0 e adiciona 1 a cada número até que a soma não seja mais inferior a N. Se for superior, a saída -1 ou outra saída gera o vetor.

Recuado e levemente sem golfe:

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
    )

Exemplo de uso:

> 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

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

Apenas um pouco de álgebra, me levou muito mais tempo do que deveria.

JavaScript - 76

Observe que k + (k - 1) + ... + (k - (M - 1)) = M (k - (M - 1) / 2) Ajustando isso igual a N, dá k = N / M + (M -1) / 2 para a quantidade mais alta. Se este for um número inteiro, então k% 1 == 0 e os valores que estamos procurando são k, k - 1, ..., k - (M - 1).

Provavelmente eu poderia ter escrito isso mais curto em outro idioma, mas ainda não havia uma solução JS, então aqui está:

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

Execute no console.

Exemplo de entrada:

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

Saída:

3
2
1 

Entrada:

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

Saída:

3
2
1
0

Entrada:

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

Saída: -1

Pena que o console.log demora tanto para escrever :) Infelizmente, declarar l=console.log.bind(console)não o torna mais curto e simplesmente l=console.lognão funciona.

Entrada:

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

Saída:

76

Golfscript, 35

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

Como funciona

No exemplo a seguir, a entrada é 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.

Como funciona.

Lê 2 números inteiros, moedas e anões.
Subtrai a diferença por anão.
Se o resto do mod anões> 0 é impossível.
Caso contrário, obtenha compartilhamento igual por anão em um loop de anões-1 a 0 e imprime dwarfIndex + compartilhamento igual

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

A função, ggera todas as seqüências de aumento por uma, de comprimento m, de 0 a n e verifica se alguma delas soma m. Se for bem-sucedida, a sequência será retornada; caso contrário, -1 é retornado.

As sequências são feitas por Partition inserindo a lista {0,1,2,3… m} em todas as sublistas possíveis de n números inteiros contíguos.

É claro que existem maneiras mais eficientes de obter o mesmo efeito, mas as que encontrei exigem mais código.

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

Exemplos

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
}

Isso é compilado com um aviso porque main não tem tipo. Se isso não for válido nas regras do golfe, eu teria que adicionar cinco caracteres.

Cobra - 198

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

Explicado:

class P
    def main

Necessário para a execução do código

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

Recebe e armazena como aeb

        l=[]
        t=n=0

Inicializa a lista de saída le inicializa o dinheiro total necessário te o número de moedas para adicionar a cada pilha de anõesn

        for i in b,t+=i

Encontra o menor valor monetário possível que resultará em todos os anões com um número permitido de moedas em sua pilha

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

Determina quantas moedas serão adicionadas a cada pilha para que o dinheiro total necessário seja> = ao dinheiro total disponível

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

Preenche a lista com as pilhas de dinheiro de diferentes tamanhos

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

Gera -1ou ldepende se o dinheiro total necessário é igual ao dinheiro total disponível

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

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

Experimente online!

Python ( 100 96 94):

Uma boa resposta com pontuação. Não é mais, mas é mais curto agora.

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

Saída:

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]