该鸽巢原理指出，

如果将N个项目放入M盒中，且N > M，则至少一个盒子必须包含一个以上的项目。

对于许多人来说，与其他数学运算相比，该原理具有特殊的地位。正如EW Dijkstra 写道，

它被一些神秘感所包围。使用它的证明通常被认为是特殊的东西，特别是巧妙的东西。

挑战

这项挑战的目的是使用ASCII艺术表示法来说明鸽洞原理。特别：

1. 以输入N（项目数）和M（框数）N为正和非负M。N可能小于M（即使该原则在这种情况下不适用）。
2. 随机选择可能的项目分配到框之一。每个分配都应具有非零的被选概率。

3. 生成分配的ASCII艺术作品表示，如下所示：

   • 有几M行，每行对应一个框。
   • 每行以非空白字符开头，例如|。
   • 在该字符之后是另一个非空白字符，例如#，与该框中的项目重复的次数很多。

例如考虑N = 8，M = 5。如果项盒中的所选赋值是4，1，0，3，0，表示是

|####
|#
|
|###
|

相同程序的不同运行（导致不同的分配）可能会导致

|#
|##
|#
|#
|###

表示有一些灵活性；见下文。

具体规则

该代码应理论上任何值运行的N和M。实际上，它可能受内存大小或数据类型限制的限制。

由于观察输出不足以确定所有赋值是否具有非零概率，因此每个提交都应说明代码如何实现（如果不是很明显）。

允许以下表示形式的变化：

• 可以选择任何一对不同的非空白字符。它们在程序执行之间必须保持一致。
• 表示形式可以旋转90度。同样，选择必须是一致的。
• 允许尾随空格或前导空格。

以具有不同表示形式的示例为例，对于N = 15，M = 6该程序两次执行的结果可能是

VVVVVV
@@@@@@
@@ @@@
 @  @@
    @

要么

VVVVV
@@@ @
@@@ @
@ @ @
@ @ @
@

同样，N = 5，M = 7可以给，使用这种表示的另一种变体，

  *
* * * *
UUUUUUU

要么

 *** **
UUUUUUU

要么

   *
*  *
*  * 
UUUUUUU

请注意该原理在这种情况下不适用，因为N< M。

一般规则

允许使用任何编程语言编写程序或功能。禁止出现标准漏洞。

可以通过任何合理的方式进行输入；并采用任何格式，例如两个数字或两个不同字符串的数组。

输出方式和格式也很灵活。例如，输出可以是字符串列表或带换行符的字符串。作为函数输出参数返回或显示在STDOUT中。在后一种情况下，不必担心由有限的显示宽度引起的换行。

以字节为单位的最短代码获胜。

果冻，9 8字节

=þṗX¥S⁵*

这是一条二元链接，将M作为左参数，将N作为右参数。输出是一个整数数组，其中0代表鸽子，而1代表孔。

在线尝试！

怎么运行的

=þṗX¥S⁵*  Main link. Left argument: m. Right argument: n

    ¥     Combine the two links to the left into a dyadic chain and call it
          with arguments m and n.
  ṗ        Compute the n-th Cartesian power of [1, ..., m], i.e., generate all
           vectors of length n that consist of elements of [1, ..., m].
   X       Pseudo-randomly choose one of those vectors with a uniform distribution.
=þ        Equal table; for each k in [1, ..., m] and each vector to the right,
          compare the elements of the vector with k. Group the results by the
          vectors, yielding a 2D Boolean matrix.
     R    Range; map 1 to [1], 0 to [].
      S   Take the sum of all columns.
       ⁵* Raise 10 to the resulting powers.

Mathematica，68个字节

Print/@(10^RandomSample@RandomChoice[IntegerPartitions[+##,{#}]-1])&

一个带两个整数参数（框数，后跟项目数）的未命名函数。

它首先将的所有可能分区划分N+M为M正部分，然后1从每个分区中减去。这给我们的所有可能划分N成M非负部分（这IntegerPartitions本来不会产生）。然后选择一个随机分区并将其随机播放。这保证了允许所有可能的零分区。最后，通过提高10到相应的功率分区的每个区间转换成输出线路（以使得每个线变得1000...与k零）。输出示例如下：

100
10000
1
10
10

Python 2，77 86字节

from random import*
n,m=input()
exec'c=randint(0,n);n-=c;print 10**c;'*~-m
print 10**n

在[0，n]中生成一个数字，打印出很多项目并从n中减去它。它执行了m次。

这使得几乎不可能使任何内容进入最后一个框，但是问题只要求每个输出都是可能的，而不是相等的可能性。

批处理，164字节

@for /l %%i in (1,1,%1)do @set h%%i=1
@for /l %%j in (1,1,%2)do @call set/ab=%%random%%%%%%%1+1&call set/ah%%b%%*=10
@for /l %%i in (1,1,%1)do @call echo %%h%%i%%

我认为连续7个%征兆可能是个人最佳成绩！注意：如果将9个以上的项目分配给同一框，则会产生奇数输出；如果这是一个问题，则为180个字节：

@for /l %%i in (1,1,%1)do @set h%%i=1
@for /l %%j in (1,1,%2)do @call set/ab=%%random%%%%%%%1+1&call call set h%%b%%=%%%%h%%b%%%%%%0
@for /l %%i in (1,1,%1)do @call echo %%h%%i%%

是的，%第二行总计28 s。

C，102字节

n,m;main(x){srand(time(0));for(scanf("%d %d",&n,&m);m--;n-=x)printf("|%0*s\n",x=m?rand()%(n+1):n,"");}

在stdin上接受输入，例如：

echo "5 4" | ./pigeonhole

不会以相等的概率生成每个输出，但是能够生成所有可能的组合。

分解：

n,m;
main(x){
    srand(time(0));             // Seed random number generator
    for(scanf("%d %d",&n,&m);   // Parse input values into n and m
        m--;                    // Loop through each bucket (count down)
        n-=x)                   // Subtract number assigned to bucket from total
        printf(                 // Output a formatted string using padding
            "|%0*s\n",          // (turns out %0s will actually zero-pad a string!)
            x=m?rand()%(n+1):n, // Calculate a number of items for this bucket
            "");
}

依赖于GCC对undefined行为的处理%0s—通常%0会将整数或浮点数零填充，但只能填充（绝不截断），因此无法打印空白。但是没有定义字符串的行为，GCC决定以相同的方式将其零填充，因此将空字符串零填充以能够写入零个或多个0s。

Python 2，102 99 97 90字节

m-1次，请选择x介于0和之间的一个随机数n，并将其从n中减去。然后打印一个1和'0'*x。

最后，打印1和的其余部分0。并非完全一样，但是所有配置都是可能的。

from random import*
n,m=input()
exec'x=randrange(n+1);n-=x;print 10**x;'*(m-1)
print 10**n

（重用的Python答案中重复使用的代码。）

Haskell，114 94字节

import System.Random
n#m=map(10^).take m.until((==n).sum.take m)tail.randomRs(0,m)<$>newStdGen

有点蛮力的方法：生成一个无限的随机数列表，从列表的开头取n个数字，将它们加起来，然后检查它们是否等于m。如果不是，请从列表中删除第一个元素并重复。

在线尝试！

注意：73个字节不带导入

编辑：用10 ^技巧保存了一些字节（在线尝试新版本！）

REXX，74个字节

arg n m
m=m-1
o.=@
do n
  a=random(m)
  o.a=o.a||#
  end
do a=0 to m
  say o.a
  end

输出（8 5）：

@#
@###
@
@#
@###

输出（8 5）：

@#
@#
@
@####
@##

C，175个 138字节

感谢@Dave节省了37个字节！

i;f(n,m){char**l=calloc(m,8);for(i=0;i<m;)l[i]=calloc(n+1,1),*l[i++]=124;for(i=n+1;--i;)*strchr(l[rand()%m],0)=35;for(;i<m;)puts(l[i++]);}

在线尝试！

AHK，66字节

2-=1
Loop,%2%{
Random,r,0,%1%
Send,|{# %r%}`n
1-=r
}
Send,|{# %1%}

我遵循了orlp使用从0到N的随机数，然后从N减去它的相同原理。不幸的是，由于Send函数的工作方式，我无法通过使用10 ^ r来保存字节。las和懈怠。这是n = 8，m = 5的一些输出：

|##     |#####    |##       |##     |#      |##   
|##     |#        |#####    |       |###    |#    
|#      |##       |         |###    |###    |     
|###    |         |         |       |#      |     
|       |         |#        |###    |       |#####

CJam，30 31 21字节

:B1a*:C\{CBmrAt.*}*N*

输入是n m堆栈上的两个数字。用途1为列的性格和0对重复字符。

说明：

:B          e# Store m in B (without deleting it from the stack)
1a          e# Push 1 and wrap it in an array: [1]
*           e# Repeat the array m times
:C          e# Store this array in C (without deleting)
\{          e# Do n times:
  CBmrAt    e#   Create an array of 1s with a random element replaced with 10.
  .*        e#   Vectorized multiplication: multiply the respective elements in the arrays.
            e#   Effectively, we multiply a random value in the array by 10 (and add a 0 to the end).
}*          e# End loop.
N*          e# Join with newlines.

Röda，79个字节

f n,m{a=[0]*m
i=0{{n--
a[i%m]++}if randomBoolean
i++}while[n>0]
a|[`|`.."#"*_]}

在线尝试！

这将创建一个零数组并在随机位置递增它们。

PHP，100字节

list($z,$m,$n)=$argv;$a=array_fill(0,$n,z);while($m>0){$a[rand(0,$n-1)].=a;$m--;}echo join("\n",$a);

分解 ：

list($z,$m,$n)=$argv;     // assigns the input vars to $m and $n
$a=array_fill(0,$n,z);    // creates an array $a of $n elements containing 'z'
while($m>0){              // randomly populate array $a
    $a[rand(0,$n-1)].=a;  //
    $m--;                 //
}                         //
echo join("\n",$a);       // output $a contents separated by a new line

m=7和的输出n=5：

第一次执行：

za
zaa
za
za
zaa

第二次执行：

za
zaa
zaaa
z
za

在线尝试！

JavaScript，105个字节

x=>y=>{s=[];for(;x>1;y-=t)s[--x]="|"+"#".repeat(t=Math.random()*(y+1)|0);s[0]="|"+"#".repeat(y);return s}

在线尝试！

由于采用了分配行的方法，尽管顶部很小会有一些机会，但是这倾向于将更多的位置放在底部。

Ruby，52个字节

->(n,m){r=Array.new(m){?|};n.times{r[rand m]+=?#};r}

创建一个匿名函数，该函数将两个整数作为参数并返回一个字符串数组：

>> puts ->(n,m){r=Array.new(m){?|};n.times{r[rand m]+=?#};r}.call 7,5
|#
|#
|##
|##
|#

Python 2，81个字节

from random import*
def f(n,m):l=['#']*m;exec('l[randrange(m)]+="o";'*n);return l

返回字符串列表。

Javascript（ES7），75个字节

(N,M)=>{for(r='';M;M--,N-=x=~~(Math.random()*(N+1)),r+=10**x+`
`);return r}

我以为自己想出了10点子的想法很聪明，只是意识到大多数答案已经在使用它了。

AWK，78个字节

{srand();for(;n++;)c[k]=c[k=int($2*rand())]"#"}END{for(;j<$2;)print"|"c[j++]}

接受2个参数，首先是项目数，然后是盒子数。首先，播种随机数生成器，以便每次运行都不同。然后简单地在数组中建立字符串，示例用法：

awk '{srand();for(;n++;)c[k]=c[k=int($2*rand())]"#"}END{for(;j<$2;)print"|"c[j++]}' <<< "12 5"

Example output:
|##
|###
|##
|##
|###

MATLAB，103 94字节

function a(m,n)
d=@(p)disp(char([1,~(1:p)]+48));for i=1:m-1;p=randi([0,n]);d(p);n=n-p;end;d(n)

带格式

function a(m,n)
for i=1:m-1 
    d=@(p)disp(char([1,~(1:p)]+48));  % inline function for displaying
    p=randi([0,n]);              % picking a random number b/w 0 and n
    d(p);                        % '1' represents the box/pigeonhole, with '0's denoting entries
    n=n-p;
end
d(n);                            % writing the remaining entries/zeros

样本输出

>> a(4,7)
10
10000
10
10

由于每个数组条目之间都有一个制表符，因此存在尾随空格，但是根据规范，这应该是可以接受的。

对我来说，这似乎是一个非常简单的实现，所以我相信可以改进这一点。

感谢@Luis Mendo的建议。

八度，62 54字节

@(n,m)strcat(62,(sum(randi(m,1,n)==(1:m)',2)>=1:n)*42)

匿名函数，它接受两个数字，并输出2D字符数组，其中包含>用于框和 *对象的字符。所有结果均可能。

在线尝试！

TI-基本，63 62字节

Prompt N,M
For(A,1,M
N→B
If M-A
randInt(0,N→B
":→Str0
For(C,1,B
Ans+"X→Str0
End
Disp Ans
N-B→N
End

每个分配都应具有非零的被选概率。

此标准使该程序更易于编写。

I / O示例：

prgmPIDGEON
N=?5
M=?2
:XXXX
:X

说明：

Prompt N,M     # 5 bytes, input number of items, number of boxes
For(A,1,M      # 7 bytes, for each box
N→B            # 4 bytes, on last box, make sure the sum is met by adding N items
If M-A         # 5 bytes, if not last box
randInt(0,N→B  # 8 bytes, add random number of items from 0 to N to box A
":→Str0        # 6 bytes, first character
For(C,1,B      # 7 bytes, add B items to the box
Ans+"X→Str0    # 8 bytes
End            # 2 bytes
Disp Ans       # 3 bytes, print this box
N-B→N          # 6 bytes, subtract the items used in this box
End            # 1 byte, move on to next box

MATLAB，73 64 58字节

更新＃3

看来，我确实需要排序，因为否则我会得到负整数。不过，我确实disp(sprintf(...))用fprintf(...)现在替换了，所以答案仍然是58个字节。

@(m,n)fprintf('%i\n',10.^diff([0;sort(randi(n,m-1,1));n]))

更新＃2：

我意识到我不需要对数组进行排序，实际上排序实际上会减少数组中数字的平均值。因此，我删除了该sort(...)部分。请注意，输出保持不变，因此我不会更新“样本输出”。

@(m,n)disp(sprintf('%i\n',10.^diff([0;randi(n,m-1,1);n])))

最终，路易斯回答了八度音阶！：D

更新＃1：

@(m,n)disp(sprintf('%i\n',10.^diff([0;sort(randi(n,m-1,1));n])))

我没有直接转换为字符串，而是直接显示数字。通过删除disp(...)，我可以减少到58个字节，但是我ans =只用sprintf就得到了额外的字节，不知道这是否可以接受。

初始代码：

@(m,n)disp(strjust(num2str(10.^diff([0;sort(randi(n,m-1,1));n])),'left'))

由于路易斯的一些建议，我摆脱了之前的回答。现在，我首先创建一个垂直的m随机数数组，其总数为n（diff([0;sort(randi(n,m-1,1));n])），然后将其用作10的指数，将其转换为字符串，左对齐并显示它们。

从技术上讲，我可以摆脱disp（...）来节省另外6个字节，但随后会打印出“ ans”，这可能会违反规范。可能还有一种方法可以将它们更改为字符串并左对齐以获取所需的最终格式，因此我欢迎您提出建议。

样本输出：

>> a=@(m,n)disp(strjust(num2str(10.^diff([0;sort(randi(n,m-1,1));n])),'left'));
>> a(4,6)
1000
10  
100 
1   

注意：根据建议，我已在此处将函数更改为匿名函数。在示例输出中，我已将其分配给a进行演示。我希望这不会违反规范，但是如果确实如此，请告诉我，我将对其进行更改。

堆叠，29字节

('|')\rep\[:randin'#'push@.]*

在线尝试！

通过构造一个包含的M单例数组的行为'|'，然后将其'#'加到随机选择的数组N时间上。

Python 2中，80个95 89 88字节

from random import*
n,m=input()
while m:x=randint(0,n);print'1'+'0'*[n,x][m>1];m-=1;n-=x

在线尝试！

• 增加了15个字节：先前的编辑有些瑕疵，遗漏了一些矩形。
• 已保存6个字节：如果用[n，x] [m> 1]替换
• 保存1个字节：导入*

木炭，19字节

≔ＥＮ⟦⟧θＦＮ⊞‽θ#Ｅθ⁺|⪫ιω

在线尝试！链接是详细版本的代码。说明：

  Ｎ                 Input `M`
 Ｅ                  Map over implicit range
   ⟦⟧               Empty array
≔    θ              Assign resulting nested array to `q`

       Ｎ            Input `N`
      Ｆ             Loop over implicit range
          θ         Nested array `q`
         ‽          Random element
           #        Literal string
        ⊞           Append to array

             θ      Nested array `q`
            Ｅ       Map over array
                 ι  Current element
                  ω Empty string
                ⪫   Join
               |    Literal string
              ⁺     Concatenate
                    Implicitly print on separate lines