그 상황:

몇몇 ( M) 드워프들이 N금화와 함께 고블린의 가슴을 발견하고 그들을 나누어야합니다. 선배 순서에 따라 해적에게 전리품을 할당하는 고대 규칙으로 인해 가장 오래된 드워프는 다음으로 가장 오래된 드워프보다 하나의 동전을 더 많이 가져야합니다 M-1. 또한, 어떤 드워프도 어떤 동전으로도 던질 필요가 없습니다 (즉, 어떤 드워프에도 음의 동전이 없음)

드워프가 동전을 이런 식으로 나누도록 도와 주거나 불가능하다고 말하십시오.

우승자의 코드는 항상 올바르게 응답해야하며 (이 과제는 결정적 임) 일반적인 코드 골프 규칙을 따라야합니다.

입력

코인 수에는 정수 N (3 ≤ N ≤ 1000), 드워프 수에는 정수 M (3 ≤ M ≤ N) (공백으로 구분)이 제공됩니다.

산출

드워프가 원하는 방식으로 동전을 나눌 수 없다면, -1 (빼기 1)을 인쇄하십시오. 그렇지 않으면, 각 난쟁이가받을 가장 오래된 동전부터 가장 작은 동전의 수를 인쇄하십시오. 숫자를 공백으로 구분하십시오.

샘플 :

입력

3 3

산출

2 1 0

입력

9 3

산출

4 3 2

입력

7 3

산출

-1

입력

6 4

산출

3 2 1 0

J- 32 29 28 25

아니 다른 J 솔루션보다 짧습니다. 그러나 다른 생각을 사용합니다

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

최고 등급 그놈이 얻는 동전 수에 대한 대답은 단순히 N/M+(M-1)/2(정수인 경우), 이것의 음수를 구성합니다 -:@-.@]-%. 그런 다음 인수 와 i:같은 배열을 만들고 M 요소를 가져옵니다.2 1 0 _1 _2_2

J-30 자

골프에 매우 재미. 많은 일들이 깔끔하게 해결되었습니다.

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

설명:

• /-공백으로 구분 된 정수를 인수로 취하고 그 사이에 함수를 삽입하십시오. 즉, N은 대괄호 안의 함수에 대한 왼쪽 인수 (...)이고 M은 오른쪽 인수입니다.

• i.&--부정 ( -) 한 다음 정수 ( i.)를 사용하십시오. 일반적으로 i.5당신이 얻는 것과 같은 것을 할 때 0 1 2 3 4. i.그러나 음수를 수신 할 때마다 해당 출력 목록이 바뀝니다. 그래서 예를 들면 i._5줄 것이다 4 3 2 1 0.

• s=.+/&-각 인수에 대해 위의 작업을 수행 한 &다음 ( +/)이 배열 에서 추가 테이블 ( ) 을 만듭니다 . 이제 우리는 각 행이 M 드워프에게 가능한 동전 분배가 가능한 테이블을 가지고 있지만 N 개의 동전이있을 때는 그렇지 않습니다. 마지막으로,이 테이블 작성 동사는 매우 유용 s하여 나중에 다시 사용할 것입니다.

• +/@s~-이제 s다시 사용 하지만 ~인수 순서를 바꾸어 ( ) 테이블을 바꿉니다. 이것은 테이블을 만든 후 각 행의 합계를 취하는 골치 아픈 방법입니다 ( +/@). J가 다차원 목록을 합산하는 방식과 관련이 있습니다.

• i.[ -이 합계 목록에서 동사에 대한 왼쪽 인수, 즉 N을 검색합니다. N이 항목 인 경우 해당 인덱스를 얻습니다. 그렇지 않으면 목록의 길이를 얻습니다. 특히 유효하지 않은 인덱스입니다.

• { ::_1:-이제 인덱스를 사용하여 테이블에서 행을 가져옵니다 s. {색인이 유효하지 않은 경우 도메인 오류가 발생하므로이 경우 오류 ( ::)를 포착하고 -1 ( _1:)을 리턴 합니다. 이것은 모든 것을 처리합니다. i.&-이전에 사용 했으므로 코인 분배는 필요에 따라 내림차순으로 정렬됩니다.

용법:

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

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

언 골프 드 :

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)

해결책:

경우 M 왜성의 수, 후 지불 금의 순서는 두 개의 단일 시리즈로 분해 될 수있다. 먼저 0으로 끝나는 시리즈 : M-1, ..., 2, 1, 0 및 c, c, ..., c의 상수 시리즈. 첫 번째 계열의 합은 항상 M * (M-1) / 2입니다. 따라서 나머지 (x = N-M * (M-1) / 2)를 나머지없이 (모듈로 같음 0) 나눌 수있는 경우 각 드워프는 x / M + 감소 계열의 일부를 얻습니다.

용법:

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

골프를 치기위한 첫 번째 시도인데, 그것이 더 나을 수 있다는 것을 알고 있지만 여전히 :)

골프 :

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

언 골프 드 :

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

쉘에서 실행

기본 아이디어 :

다음 중 하나에 해당하면 다음 규칙에 따라 동전을 분리 할 수 ​​있습니다.

1. 드워프는 홀수이고, 코인은 잔존물이없는 드워프로 나눌 수 있습니다
2. 드워프는 짝수이며 코인 / 드워프를 나눈 후 남은 동전은 드워프 수의 절반과 같습니다

그렇다면, 우리는 왜소 당 평균 코인 (ACPD)을 기준으로합니다. 그러나 최고에서 시작하여 최저에 도달 할 때까지 출력해야합니다. 따라서 우리는 ACPD에서 시작하는 카운터 + 더 높은 드워프의 나머지 드워프 수를 시작으로 루프를 만들고 ACPD에 도달 할 때까지 계속 진행합니다-나머지 드워프의 아래쪽 끝입니다.

드워프가 홀수 인 경우 (즉, 5 개의 드워프-중간이 3 개이고 양쪽 끝에 2 개가 남아있는 경우) 기본적으로 동일하지만 짝수 인 경우는 아닙니다-우리가 바닥과 라운드에 의존하는 이유입니다.

지금까지 문제 : 동전 수가 너무 적 으면 일부 드워프가 적의 귀중한 수입을 빼앗길 수 있습니다. 그리고 이것은 슬프다. 아니면 적어도 난쟁이를 좋아한다면.

해결책 :

1. 가장 적은 양의 동전을 계산할 수있는 방법을 생각해 보면 먼지 속에서 드워프가 계산에 포함되지 않습니다.
2. 욕심쟁이 드워프를 디자인하십시오.

똑똑한 솔루션 :

동전은 금속입니다. 드워프가 모두 녹게 한 다음, 소량 / 대량의 동전으로 캐스트하십시오.

가장 똑똑한 솔루션 :

그들의 산을 훔치고, 스마우그로 이름을 바꾸고 자신을 위해 모든 것을 지키십시오. 결국 왜 심술쟁이 드워프를 귀찮게해야합니까?

파이썬 3 (100)

@Geobits 와 동일한 아이디어를 사용 하지만 입력 및 출력 요구 사항을 준수합니다.

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

파이썬 3 - 109 107 103 102 90 93

Evpok과 동일한 아이디어를 사용하지만 많은 개선 사항이 있습니다.

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

개선 사항은 다음과 같습니다.

1. ''앞뒤로 공백 제거 1 자
2. 공백 분할이 기본값이므로 split () 내부에서 ''를 제거합니다. 3 자
3. x를 1 씩 낮추면 divmod 내에서 -1을 +1로 변경 한 다음 범위의 역순 옵션을 사용하도록 범위 기능을 변경합니다. 3 자
4. 편집 : ... if ... else ...가 ... 및 ... 또는 ... 2 자로 변경되었습니다.
5. 편집 : Divmod를 명시 적으로 만들었고 r을 제거했습니다. 4 자
6. 편집 : x가 제거되고 m // n이 명시 적으로 사용됩니다. 1 자
7. 편집 : ''.join (map (str, ...)) 대신 별표 표시 식을 사용하고 print () 반복을 피하기 위해 x를 추가했습니다. 12 자
8. 편집 : 나는 드워프에게 음수의 동전을 줄 수 있다는 것을 깨달았습니다. 이것을 피하기 위해 코드를 변경했습니다.

파이썬 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

N-(M*(M-1)/2)로 균등하게 나눌 수 있는지 확인하여 작동합니다 M. 파이썬을 처음 사용하므로 모든 팁에 감사드립니다.

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

끔찍한 점수이지만 다른 접근법을 사용하여 사용했습니다 goto:)

나중에 줄 이겠습니다.

자바 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 자

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

(M-1)에서 0으로 이동하는 벡터를 만들고 합이 더 이상 N보다 열등하지 않을 때까지 각 숫자에 1을 더합니다. 더 우수하면 -1을 출력하고 그렇지 않으면 벡터를 출력합니다.

들여 쓰기 및 약간 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
    )

사용법 예 :

> 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

줄리아, 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

약간의 대수학이 필요 이상으로 오래 걸렸습니다.

자바 스크립트-76

k + (k-1) + ... + (k-(M-1)) = M (k-(M-1) / 2)이 값을 N으로 설정하면 k = N / M + (M 가장 높은 금액은 -1) / 2입니다. 이것이 정수이면 k % 1 == 0이고 찾고있는 양은 k, k-1, ..., k-(M-1)입니다.

아마 다른 언어로 이것을 더 짧게 작성할 수 있었지만 아직 JS 솔루션이 없었으므로 여기에 있습니다 :

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

콘솔에서 실행하십시오.

입력 예 :

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

산출:

3
2
1 

입력:

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

산출:

3
2
1
0

입력:

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

출력 : -1

너무 나쁜 console.log는 철자가 너무 길다 :) 불행히도 선언 l=console.log.bind(console)하면 더 짧게 만들지 않으며 단지l=console.log 않고 작동하지 않습니다.

입력:

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

산출:

76

골프 스크립트, 35

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

작동 원리

다음 예제에서 입력은 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

델파이 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.

작동 방식

2 개의 정수, 동전 및 드워프를 읽습니다.
난쟁이 당 차이를 뺍니다.
나머지 모드가 0보다 작 으면 불가능합니다.
그렇지 않으면 dwarves-1에서 0까지의 루프에서 드워프 당 동일한 점유율을 얻고 dwarfIndex + equal share를 인쇄합니다.

언 골프

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.

매스 매 티카 65

이 함수 g는 길이 m의 0부터 n까지의 모든 증가하는 시퀀스를 생성하고 m의 합계인지 확인합니다. 성공하면 시퀀스가 ​​반환됩니다. 그렇지 않으면 -1이 반환됩니다.

Partition리스트 {0,1,2,3… m}를 n 개의 인접한 정수의 모든 가능한 서브리스트로 묶음 으로써 시퀀스가 ​​만들어집니다 .

물론 동일한 효과를 얻는 더 효율적인 방법이 있지만 내가 찾은 방법에는 더 많은 코드가 필요합니다.

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

예

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

언 골프

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

main에는 유형이 없으므로 경고와 함께 컴파일됩니다. 이것이 골프 규칙에서 유효하지 않은 경우 5자를 추가해야합니다.

코브라-198

코브라 웹 사이트

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

설명 :

class P
    def main

코드를 실행하는 데 필요

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

입력을 a받아b

        l=[]
        t=n=0

출력 목록 l을 초기화하고 t각 드워프 더미에 추가 할 총 필요한 돈 과 동전 수를 초기화합니다n

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

출력 중 하나 -1또는 l전체에 필요한 돈이 총 가용 돈 같은지 여부를 따라

Perl 5 , 78 + 1 (-n) = 79 바이트

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

온라인으로 사용해보십시오!

파이썬 ( 100 96 94) :

좋은 라운드 스코어 답변입니다. 더 이상은 아니지만 지금은 더 짧습니다.

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]

언 골프 드 :

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

산출:

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]