可能是一个简单的代码挑战。给定2个正整数m和n，给出一个n值列表，这些值是总和等于数字的正整数m。输出中的所有值都是相同的值，或者差值恰好是1。

例子

例如

• m=6并n=3成为2, 2, 2
• m=7并且n=3将成为2, 2, 3或2, 3, 2或 3, 2, 2
• m=7并n=2成为3, 4或4, 3
• m=7并n=1成为7
• m=7并n=8会产生错误，因为8个正整数之和不能为7。
• m=10并且n=4将成为3, 3, 2, 2或任何其他排列

规则

• 输入和输出都仅是正整数。
• 输出中的所有值都是相同的值，或者差值恰好是1。
• 列表中值的顺序并不重要。
• 列表中值的总和等于m。
• 如果无法解决，则生成错误或错误值（例如，在m = 7和n = 8的情况下）。
• 由于其他规则，m=8并且n=3会生成3, 3, 2（not 2, 2, 4）的任何排列

获胜者，冠军

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

盖亚，4 个字节

…÷l¦

几乎只有一个内置的...

说明

…     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个字节

返回0错误。

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

在线尝试！

41个字节（使用@xnor的技巧）

抛出NameError错误。

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

在线尝试！

Mathematica，33个字节

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

输入

[63，11]

输出

{6，6，6，6，6，6，6，6，5，5，5}

无法解决时输出False

MATL，7个字节

:gie!Xs

如果没有解，则输出是一个包含至少一个零的数组，这在MATL 中是错误的。

在线尝试！

说明

考虑输入m = 10和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个字节

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

在线尝试！

木炭，应用NDD ¹后的15个字节

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

在线尝试！

如果没有解决方案，则不输出任何内容。链接到详细版本。

¹ NDD =尼尔驱动的发展。

我以前的回答：

木炭，32 27 24 20字节

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

在线尝试！

如果没有解决方案，则不输出任何内容。链接到详细版本。

当然，没有尼尔的帮助，我无法打高尔夫球。

R，33个字节

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

路易斯·门多（Luis Mendo）的Octave答案的港口。很遗憾，这比我以前的答案短了近50％。

在线尝试！

先前的答案，63个字节：

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

带有两个（强制性）参数m和的匿名函数n，以及两个用于高尔夫目的的可选参数。以升序返回向量。对于失败，第一个值将是0，在R中为false，因为if仅使用向量的第一个值（带有警告）。

它实质上等效于以下功能：

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

在线尝试！

果冻，7 6字节

:ȧœsL€

在线尝试！不输出任何虚假信息。

怎么运行的

:ȧœ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基本（23字节）

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

错误时返回ERR：DIVIDE BY 0

八度，24字节

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

该代码定义了一个匿名函数。输出是数字数组（行向量）。如果不存在，则此数组至少包含一个零，这在八度中是虚假的。

在线尝试！

说明

0:m/n:mn+1从step 0到from 生成一个值数组。将每个条目四舍五入mm/nfix0和diff舍计算连续的差值。

作为一个例子，这里是所有中间结果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字节

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

在线尝试！

说明

这里的主要功能是e。 e会列出一个清单，并从左到右沿着它滚动。虽然列表中有一个元素比右边的元素大，但我们将其右移。

现在，我们要做的就是为该函数提供一个不平衡的列表，并使其发挥作用。我们将选择的列表m紧随其后n-1零。由于这很容易做到。

我们需要做的最后一件事是确保处理错误情况。为此我们只要抛出一个Non-exhaustive patterns in function错误就可以了m>n。

C＃（.NET Core），86 82 71字节

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

为无效输入引发错误。

在线尝试！

-4个字节，感谢TheLethalCoder

-11字节归功于OlivierGrégoire

Haskell，48个字节

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

从n零列表开始。重复m次数：取第一个元素，添加一个并将其放在列表的末尾。

如果出现模式匹配错误，则失败n < m。

在线尝试！

Braingolf，30个字节

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

在线尝试！

以相反的顺序进行n输入（是第一个输入，m第二个）

划分m由n，复制的结果n次，然后通过和增量循环逐个m % n倍

批处理，71个字节

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

cmd/cset/a不输出任何分隔符，所以我必须使用echo(（(避免打印ECHO is on.）。

PHP> = 7.1，62字节

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

PHP沙盒在线

Python 2，41个字节

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

在线尝试！

NameError 当不可能的时候。

Python 2，43个字节

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

在线尝试！

ValueError 当不可能的时候。

Javascript（ES6），57 56 53 41字节

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

现在，答案包括创建值的更智能的方法。谢谢@尼尔

用法

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]

历史

第一矿

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

然后添加了传播运算符和@Arnauld提示的currying语法

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

Java（OpenJDK 8），80 73 63 61 59字节

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

在线尝试！

请注意，出于煽动目的，m并且n被颠倒了。

Pyth，11个字节

efqlTeQ./hQ

在线尝试！

Pyth，13个字节

KE?>KQ0lMcK*d

在线尝试！0错误输出。

作弊，6个字节

lMcE*d

在线尝试！该数组包含一个0on错误。可悲的是，这在Pyth中并不虚假。

说明

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字节

{_2$>/,/z:,}

在线尝试！

这是一个匿名块，将输入作为 n m堆栈上的内容。这本来是一个很好的答案，但是错误处理要求完全杀死了它。

无法解决时的除以零的错误。

说明

{   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]
}

如果提高了错误处理要求，则可以将其缩短为7个字节，减少了40％以上：

{,/z:,}