O princípio do pombo afirma que

Se N itens forem colocados em caixas M , com N > M , pelo menos uma caixa deverá conter mais de um item.

Para muitos, esse princípio tem um status especial em comparação com outros enunciados matemáticos. Como EW Dijkstra escreveu ,

Está cercado por alguma mística. As provas de usá-lo são frequentemente consideradas algo especial, algo particularmente engenhoso.

O desafio

O objetivo deste desafio é ilustrar o princípio do buraco de pombo usando representações de arte ASCII. Especificamente:

1. Tome como entrada N(número de itens) e M(número de caixas), com Nnão negativo e Mpositivo. Npode ser menor que M(mesmo que o princípio não se aplique nesse caso).
2. Selecione aleatoriamente uma das possíveis atribuições de itens para caixas. Cada tarefa deve ter uma probabilidade diferente de zero de ser escolhida.

3. Produza uma representação artística ASCII da tarefa da seguinte maneira:

   • Existem Mlinhas, cada uma correspondendo a uma caixa.
   • Cada linha começa com um caractere que não seja um espaço em branco, como |.
   • Após esse caractere, há outro caractere que não é de espaço em branco, como #, repetido quantas vezes houver itens nessa caixa.

Considere, por exemplo N = 8, M = 5. Se o assigment selecionado de itens para caixas é 4, 1, 0, 3, 0, a representação é

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

Uma execução diferente (resultando em uma atribuição diferente) do mesmo programa pode dar

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

Existe alguma flexibilidade em relação à representação; ver abaixo.

Regras específicas

O código deve teoricamente ser executado para quaisquer valores de Ne M. Na prática, pode ser restringido pelo tamanho da memória ou pelas limitações do tipo de dados.

Como a observação da saída não é suficiente para determinar se todas as atribuições têm probabilidade diferente de zero , cada envio deve explicar como o código alcança isso, se não óbvio.

As seguintes variações de representação são permitidas:

• Qualquer par de caracteres diferentes, que não sejam espaços em branco, pode ser escolhido. Eles devem ser consistentes nas execuções do programa.
• Rotações de 90 graus da representação são aceitáveis. Novamente, a escolha deve ser consistente.
• Espaço em branco à direita ou à direita é permitido.

Como exemplo com um formato de representação diferente, para N = 15, M = 6os resultados de duas execuções do programa podem ser

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

ou

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

Da mesma forma, N = 5, M = 7poderia dar, usando uma outra variação da representação,

  *
* * * *
UUUUUUU

ou

 *** **
UUUUUUU

ou

   *
*  *
*  * 
UUUUUUU

Observe como o princípio não é aplicável neste caso, porque N< M.

Regras gerais

Programas ou funções são permitidos, em qualquer linguagem de programação . As brechas padrão são proibidas.

A entrada pode ser obtida por qualquer meio razoável ; e com qualquer formato, como uma matriz de dois números ou duas seqüências diferentes.

Os meios e o formato de saída também são flexíveis. Por exemplo, a saída pode ser uma lista de cadeias ou uma cadeia com novas linhas; retornado como argumento de saída da função ou exibido em STDOUT. Neste último caso, não é necessário se preocupar com a quebra de linha causada pela largura limitada da exibição.

O menor código em bytes vence.

Geléia , 9 8 bytes

=þṗX¥S⁵*

Esse é um link diádico que toma M como à esquerda e N como seu argumento à direita. A saída é uma matriz de números inteiros, em que 0 representa pombos e 1 representa buracos.

Experimente online!

Como funciona

=þṗ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 bytes

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

Uma função sem nome que recebe dois argumentos inteiros, o número de caixas, seguido pelo número de itens.

Primeiro, calcula todas as partições possíveis N+Mem Mpartes exatamente positivas e subtrai 1de cada partição posteriormente. Isso nos dá todas as partições possíveis Nem Mpartes não negativas (que IntegerPartitionsnão seriam geradas de outra forma). Em seguida, escolha uma partição aleatória e embaralhe-a. Isso garante que todas as partições ordenadas possíveis com zeros sejam permitidas. Por fim, converta cada compartimento da partição em uma linha de saída aumentando 10 para a potência correspondente (de modo que cada linha fique 1000...com kzeros). Um exemplo de saída pode parecer com:

100
10000
1
10
10

Python 2, 77 86 bytes

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

Gera um número em [0, n], imprime muitos itens e o subtrai de n. Faz isso m vezes.

Isso torna muito improvável que algo chegue à última caixa, mas a pergunta apenas pedia que toda saída fosse possível , e não igualmente provável .

Lote, 164 bytes

@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%%

Eu acho que 7 %sinais consecutivos podem ser um novo melhor pessoal! Nota: isso produz uma saída ímpar, se alguma vez atribuir mais de 9 itens à mesma caixa; se isso é um problema, então para 180 bytes:

@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%%

Sim, são 28 %s no total na segunda linha.

C, 102 bytes

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

Aceita stdin, por exemplo:

echo "5 4" | ./pigeonhole

Não gera cada saída com igual probabilidade, mas é capaz de gerar todas as combinações possíveis.

Demolir:

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

Baseia-se na manipulação pelo GCC do comportamento indefinido de %0s- normalmente %0irá zerar um número inteiro ou flutuar, mas só pode ser preenchido (nunca truncar), portanto, não é possível imprimir um espaço em branco. Mas o comportamento das seqüências de caracteres não está definido, e o GCC decidiu torná-lo com zero pad da mesma maneira, de modo que este zero preenche uma sequência vazia para poder escrever zero ou mais 0s.

Python 2, 102 99 97 90 bytes

m-1vezes, escolha uma quantidade aleatória xentre 0e n, inclusive e subtraia-a de n. Depois imprima um 1e '0'*x.

Por fim, imprima 1e o restante de 0s. Sem chances iguais, mas todas as configurações são possíveis.

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

(Código reutilizado da resposta Python quebrada.)

Haskell, 114 94 bytes

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

Um pouco de abordagem de força bruta: gera uma lista infinita de números aleatórios, pega n números do início da lista, resume-os e verifica se são iguais a m. Caso contrário, retire o primeiro elemento da lista e repita.

Experimente online!

Nota: 73 bytes sem a importação

EDIT: salvou alguns bytes com o truque 10 ^ ( Experimente a nova versão online! )

REXX, 74 bytes

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

Saída (8 5):

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

Saída (8 5):

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

C, 175 138 bytes

Obrigado a @Dave por salvar 37 bytes!

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

Experimente online!

AHK, 66 bytes

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

Segui o mesmo princípio que o orlp usava números aleatórios de 0 a N e subtraí-o de N. Infelizmente, não pude salvar bytes usando 10 ^ r devido à maneira como a função Send funciona. Infelizmente e de novo. Aqui estão algumas saídas para n = 8, m = 5:

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

CJam, 30 31 21 bytes

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

A entrada tem dois números n mna pilha. Usa 1para o caractere da coluna e 0para o caractere repetido.

Explicação:

: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 bytes

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

Experimente online!

Isso cria uma matriz de zeros e os incrementa em locais aleatórios.

PHP, 100 bytes

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

Demolir :

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

Saídas para m=7e n=5:

Primeira execução:

za
zaa
za
za
zaa

Segunda execução:

za
zaa
zaaa
z
za

Experimente online!

JavaScript, 105 bytes

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

Experimente online!

Devido ao método de atribuir as linhas, isso tenderá a colocar mais na parte inferior, embora exista uma pequena chance de que a parte superior obtenha algumas.

Ruby, 52 bytes

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

Cria uma função anônima que recebe dois números inteiros como argumentos e retorna uma matriz de Strings:

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

Python 2, 81 bytes

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

Retorna uma lista de strings.

Javascript (ES7), 75 bytes

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

Eu pensei que era inteligente por ter os poderes da ideia 10 apenas para perceber que a maioria das respostas já estava usando isso.

AWK, 78 bytes

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

Leva 2 argumentos, primeiro o número de itens, depois o número de caixas. Inicia semeando o gerador de números aleatórios para que cada execução seja diferente. Em seguida, basta criar seqüências de caracteres em uma matriz, Exemplo de uso:

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 bytes

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)

Com formatação

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

Saída de amostra

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

Existem espaços em branco à direita, pois cada entrada da matriz é exibida com uma guia entre eles, mas isso deve ser aceitável conforme as especificações.

Isso me parece uma implementação muito simplista, por isso tenho certeza de que isso poderia ser melhorado.

Obrigado a @Luis Mendo por sugestões.

Oitava , 62 54 bytes

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

Função anônima que recebe dois números e gera uma matriz 2D de caracteres >para caixas e *objetos. Todos os resultados são igualmente prováveis.

Experimente online!

TI-Basic, 63 62 bytes

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

Cada tarefa deve ter uma probabilidade diferente de zero de ser escolhida.

Este critério tornou este programa muito mais fácil de escrever.

Exemplo de E / S:

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

Explicação:

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 bytes

Atualização # 3

Eu preciso da classificação, ao que parece, pois, caso contrário, recebo números inteiros negativos. I fez substituir disp(sprintf(...))com fprintf(...)agora, porém, assim que a resposta continua a ser 58 bytes.

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

Atualização # 2:

Percebi que não precisava classificar a matriz e, na verdade, a classificação reduziria a média de números na matriz. Então eu apaguei a sort(...)parte. Observe que a saída permanece a mesma, portanto, não estou atualizando a "saída de amostra".

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

Finalmente, fechando a resposta de oitava de Luis! : D

Atualização # 1:

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

Em vez de converter para string, apenas mostro números diretamente. Eu poderia reduzir para 58 bytes, removendo o disp(...), mas depois recebo o extra ans =com apenas sprintf e não sei se isso é aceitável.

Código inicial:

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

Graças a algumas sugestões de Luis , me livrei do loop na minha resposta anterior . Agora, primeiro crio uma matriz vertical de mnúmeros aleatórios que somam n( diff([0;sort(randi(n,m-1,1));n])), depois os uso como expoentes de 10, os converto em uma string, justificamos à esquerda e os exibimos.

Eu poderia tecnicamente me livrar do disp (...) para salvar outros 6 bytes, mas um "ans" é impresso, o que pode violar as especificações. Também pode haver uma maneira de alterá-los para string e justificar à esquerda para obter o formato final desejado, por isso estou aberto a sugestões.

Saída de amostra:

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

Nota : Alterei minha função para uma função anônima aqui, com base em sugestões. Na saída de amostra, designei issoapara demonstrar. Espero que isso não viole as especificações, mas se isso acontecer, por favor me avise e eu vou alterá-lo.

Empilhados , 29 bytes

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

Experimente online!

Comporta-se construindo uma matriz de Msingletons contendo '|'e adicionando '#'a uma matriz escolhida aleatoriamente N.

Python 2 , 80 95 89 88 bytes

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

Experimente online!

• Adicionado 15 bytes: a edição anterior foi um pouco falha, alguns piegons foram deixados de fora.
• 6 bytes salvos: substituído caso contrário por [n, x] [m> 1]
• 1 Byte salvo: importação *

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

  Ｎ                 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