Có lẽ là một thử thách mã golf đơn giản. Cho 2 số nguyên dương mvà n, lập danh sách các ngiá trị là số nguyên dương có tổng bằng số m. Tất cả các giá trị trong đầu ra là cùng một giá trị hoặc chênh lệch là chính xác 1.

Ví dụ

Ví dụ

• m=6và n=3sẽ trở thành2, 2, 2
• m=7và n=3sẽ trở thành 2, 2, 3hoặc 2, 3, 2hoặc 3, 2, 2
• m=7và n=2sẽ trở thành 3, 4hoặc4, 3
• m=7và n=1sẽ trở thành7
• m=7và n=8sẽ tạo ra lỗi vì tổng 8 số nguyên dương không thể là 7.
• m=10và n=4sẽ trở thành 3, 3, 2, 2hoặc bất kỳ hoán vị khác

Quy tắc

• Cả đầu vào và đầu ra chỉ là về số nguyên dương.
• Tất cả các giá trị trong đầu ra là cùng một giá trị hoặc chênh lệch là chính xác 1.
• Thứ tự của các giá trị trong danh sách không quan trọng.
• Tổng các giá trị trong danh sách bằng m.
• Khi không thể giải quyết được, hãy tạo ra lỗi hoặc giá trị sai (ví dụ trong trường hợp m = 7 và n = 8).
• Là kết quả của các quy tắc khác m=8và n=3sẽ tạo ra bất kỳ hoán vị của 3, 3, 2(không 2, 2, 4)

Người chiến thắng

Đây là môn đánh gôn, vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

Gaia , 4 byte

…÷l¦

Gần như chỉ có một tích hợp cho ...

Giải trình

…     Get the range [0 .. m-1].
 ÷    Split into n roughly even length chunks. Throws an error if the number of chunks if 
       more than the list's length.
  l¦  Get the length of each chunk.

Python 2 , 48 43 byte

Trả 0về lỗi.

lambda m,n:m/n and[m/n]*(n-m%n)+m%n*[m/n+1]

Hãy thử trực tuyến!

41 byte (với thủ thuật @ xnor)

Ném NameErrorvào lỗi.

lambda m,n:[m/n or _]*(n-m%n)+m%n*[m/n+1]

Hãy thử trực tuyến!

Toán học, 33 byte

#>#2&&Last@IntegerPartitions@##1&

đầu vào

[63, 11]

đầu ra

{6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5}

đầu ra Sai khi không thể giải được

MATL , 7 byte

:gie!Xs

Khi không có giải pháp, đầu ra là một mảng chứa ít nhất một số 0, đó là sai lệch trong MATL.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào m = 10và n = 4.

:      % Implicitly input m. Push [1 2 ... m]
       % STACK: [1 2 3 4 5 6 7 8 9 10]
g      % Logical: convert nonzeros to 1
       % STACK: [1 1 1 1 1 1 1 1 1 1]
i      % Input n
       % STACK: [1 1 1 1 1 1 1 1 1 1], 4
e      % Reshape into matrix with n rows, padding with zeros
       % STACK: [1 1 1;
                 1 1 1;
                 1 1 0;
                 1 1 0]
!      % Transpose
       % STACK: [1 1 1 1;
                 1 1 1 1;
                 1 1 0 0]
Xs     % Sum of each column. Implicitly display
       % STACK: [3 3 2 2]

Haskell , 30 byte

m%n|m>=n=map(`div`n)[m..m+n-1]

Hãy thử trực tuyến!

Than , 15 byte sau khi áp dụng NDD ¹

¿÷ＮＮＩＥＩη÷⁺ＩθιＩη

Hãy thử trực tuyến!

Đầu ra không có gì nếu không có giải pháp. Liên kết đến phiên bản dài dòng .

¹ NDD = Phát triển dựa trên Neil.

Câu trả lời trước của tôi:

Than , 32 27 24 20 byte

ＮμＮν¿÷μνＩＥν⁺÷μν‹ι﹪μν

Hãy thử trực tuyến!

Đầu ra không có gì nếu không có giải pháp. Liên kết đến phiên bản dài dòng .

Tất nhiên, tôi không thể đánh gôn mà không có sự giúp đỡ của Neil.

R , 33 byte

function(m,n)diff(trunc(0:n*m/n))

Một câu trả lời Octave của Luis Mendo . Khá buồn vì điều này ngắn hơn gần 50% so với câu trả lời trước đây của tôi.

Hãy thử trực tuyến!

câu trả lời trước, 63 byte:

function(m,n,o=rep(m%/%n,n),d=m-sum(o))o+c(rep(0,n-d),rep(1,d))

Một chức năng vô danh mà phải mất hai đối số (bắt buộc) mvà n, và hai tùy chọn mà là dành cho mục đích chơi golf. Trả về một vectơ theo thứ tự tăng dần. Đối với thất bại, giá trị đầu tiên sẽ là 0, falsey trong R, vìif chỉ sử dụng giá trị đầu tiên của vectơ (có cảnh báo).

Nó cơ bản tương đương với chức năng sau:

function(m,n){o=rep(m%/%n,n)
d=m-sum(o)
o+c(rep(0,n-d),rep(1,d))}

Hãy thử trực tuyến!

Thạch , 7 6 byte

:ȧœsL€

Hãy thử trực tuyến! Đầu ra không có gì cho giả.

Làm thế nào nó hoạt động

:ȧœsL€    Main link. Arguments: m (integer), n (integer)
:         Integer division. Yields 0 if m < n; a positive integer otherwise.
 ȧ        Logical AND. Yields 0 if m < n; m otherwise.
  œs      Split into n roughly equal groups. Since the left argument is an integer,
          this implicitly converts it to [1..m] (or [] for 0) before splitting.
    L€    Length of €ach. If the inputs were 7 and 3, the previous result would be
          [[1,2,3],[4,5],[6,7]], so this would give [3,2,2].

TI-Basic, 23 byte

:Prompt M,N
:N(M≥N
:int(Ans⁻¹randIntNoRep(M,M+N-1

Trả về ERR: DIVIDE BY 0 khi có lỗi

Octave , 24 byte

@(m,n)diff(fix(0:m/n:m))

Mã xác định một chức năng ẩn danh. Đầu ra là một mảng số (vector hàng). Khi không có mảng này chứa ít nhất một số 0, đó là sai lệch trong Octave.

Hãy thử trực tuyến!

Giải trình

0:m/n:mtạo ra một mảng các n+1giá trị từ 0đến mbước m/n. fixlàm tròn mỗi mục hướng tới 0, và difftính toán sự khác biệt liên tiếp.

Ví dụ, đây là tất cả các kết quả trung gian cho m = 7, n = 3:

>> 0:m/n:m
ans =
         0    2.3333    4.6667    7.0000

>> fix(0:m/n:m)
ans =
     0     2     4     7

>> diff(fix(0:m/n:m))
ans =
     2     2     3

Haskell , 93 89 88 87 86 71 byte

m!n|n<=m=e$m:(0<$[2..n])
e(a:b:x)|b<a=e$a-1:e(b+1:x)
e(a:x)=a:e x
e x=x

Hãy thử trực tuyến!

Giải trình

Chức năng chính ở đây là e. esẽ lấy một danh sách và về cơ bản chạy một chiếc ghim dọc theo nó từ trái sang phải. Trong khi có một yếu tố trong danh sách lớn hơn hàng xóm của nó ở bên phải, chúng ta sẽ di chuyển một yếu tố từ nó sang bên phải.

Bây giờ tất cả những gì chúng ta phải làm là cung cấp cho chức năng này một danh sách đủ nhỏ và cho phép nó thực hiện phép thuật. Danh sách chúng tôi sẽ chọn chỉ mlà n-1số không theo sau . Vì đó là dễ dàng để thực hiện.

Điều cuối cùng chúng ta cần làm là đảm bảo rằng trường hợp lỗi được xử lý. Đối với điều này, chúng tôi chỉ cần ném một Non-exhaustive patterns in functionlỗi miễn là m>n.

C # (.NET Core) , 86 82 71 byte

using System.Linq;a=>b=>new int[b].Select((x,i)=>(i<a%b?1:0/(a/b))+a/b)

ném một lỗi cho đầu vào không hợp lệ.

Hãy thử trực tuyến!

-4 byte nhờ TheLethalCoder

-11 byte nhờ OlivierGrégoire

Haskell, 48 byte

m#n|m>=n=iterate(\(a:b)->b++[a+1])(0<$[1..n])!!m

Bắt đầu với một danh sách các nsố không. Nói lạim thời gian: lấy phần tử đầu tiên, thêm một phần và đặt nó ở cuối danh sách.

Thất bại với một lỗi khớp mẫu nếu n < m.

Hãy thử trực tuyến!

Braingolf , 30 byte

.M>.M/v.mR>[.]$_v%!?[R1+>v]|R=

Hãy thử trực tuyến!

Đưa đầu vào theo thứ tự ngược lại ( nlà đầu vào đầu tiên,m là thứ hai)

Chia mcho n, nhân đôi số nlần kết quả , sau đó lặp lại và tăng từng m % nlần một

Mẻ, 71 byte

@if %1 geq %2 for /l %%i in (1,1,%2)do @cmd/cset/an=(%1+%%i-1)/%2&echo(

cmd/cset/akhông xuất bất kỳ dấu phân cách nào, vì vậy tôi phải sử dụng echo(( (tránh in ECHO is on.).

PHP> = 7.1, 62 byte

for([,$s,$n]=$argv;$n;)$s-=$r[]=$s/$n--^0;$r[0]?print_r($r):0;

PHP Sandbox trực tuyến

Python 2 , 41 byte

lambda m,n:(m%n*[m/n+1]+[m/n or _]*n)[:n]

Hãy thử trực tuyến!

NameError khi không thể

Python 2 , 43 byte

lambda m,n:[c/n for c in range(m,m+n,m>=n)]

Hãy thử trực tuyến!

ValueError khi không thể

Javascript (ES6), 57 56 53 41 byte

m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

Trả lời bây giờ bao gồm cách thông minh hơn để tạo ra các giá trị. Cảm ơn @Neil

Sử dụng

f=m=>n=>m>=n&&[...Array(n)].map(_=>m++/n|0)

f(6)(3) // [2, 2, 2]
f(7)(3) // [3, 2, 2]
f(7)(2) // [4, 3]
f(7)(1) // [7]
f(7)(8) // false
f(8)(3) // [3, 3, 2]

Lịch sử

Của tôi đầu tiên

(m,n)=>m>=n&&Array(n).fill(~~(m/n)).map((v,i)=>v+(i<m%n))

(m,n)=>m>=n&&Array(n).fill().map((v,i)=>~~(m/n)+(i<m%n))

Sau đó, thêm toán tử lây lan và cú pháp currying được tip bởi @Arnauld

m=>n=>m>=n&&[...Array(n)].map((v,i)=>~~(m/n)+(i<m%n))

Java (OpenJDK 8) , 80 73 63 61 59 byte

n->m->{for(int i=n;i-->0/(m/n);)System.out.println(m++/n);}

Hãy thử trực tuyến!

Lưu ý, cho mục đích cà ri, mvà nđược đảo ngược.

Bình thường , 11 byte

efqlTeQ./hQ

Hãy thử trực tuyến!

Bình thường , 13 byte

KE?>KQ0lMcK*d

Hãy thử trực tuyến! Đầu ra bị 0lỗi.

Gian lận, 6 byte

lMcE*d

Hãy thử trực tuyến! Các mảng chứa một 0lỗi trên. Đáng buồn thay, đây không phải là giả mạo trong Pyth .

Giải trình

KE?>KQ0lMcK*dQ    # Implicit input Q for m
KE                # Store n in K
           *d     # Generate a string of length Q containing only spaces
         cK       # Chop this string in K pieces of equal sizes, initial piece longer if necessary
       lM         # For each string, compute the length. Here we already have our result. However if the array contain a zero, we must output a falsy value
  ?>KQ            # If K > Q...
      0           # Then display zero, otherwise display the array

CJam , 13 12 byte

{_2$>/,/z:,}

Hãy thử trực tuyến!

Đây là một khối ẩn danh nhận đầu vào là n m trên ngăn xếp. Nó sẽ là một câu trả lời tốt, nhưng yêu cầu xử lý lỗi hoàn toàn giết chết nó.

Lỗi với số chia cho 0 khi không thể giải quyết.

Giải trình

{   e# Stack:                | 3 10
 _  e# Duplicate:            | 3 10 10
 2$ e# Copy from back:       | 3 10 10 3
 >  e# Greater than:         | 3 10 1 (true)
 /  e# Divide:               | 3 10
    e# This will cause an error on invalid input.
 ,  e# Range:                | 3 [0 1 2 3 4 5 6 7 8 9]
 /  e# Split on nth element: | [[0 1 2] [3 4 5] [6 7 8] [9]]
 z  e# Transpose array:      | [[0 3 4 9] [1 4 7] [2 5 8]]
 :, e# Length of each:       | [4 3 3]
}

Nếu yêu cầu xử lý lỗi được nâng lên, điều này có thể rút ngắn xuống còn 7 byte, tức là giảm hơn 40%:

{,/z:,}