Il principio del buco del piccione afferma che

Se N articoli vengono inseriti in caselle M , con N > M , almeno una casella deve contenere più di un articolo.

Per molti, questo principio ha uno status speciale rispetto ad altri enunciati matematici. Come ha scritto EW Dijkstra ,

È circondato da un po 'di mistica. Le prove che lo utilizzano sono spesso considerate qualcosa di speciale, qualcosa di particolarmente geniale.

La sfida

Lo scopo di questa sfida è di illustrare il principio del buco del piccione usando rappresentazioni d'arte ASCII. In particolare:

1. Prendi come input N(numero di elementi) e M(numero di caselle), con Nvalori non negativi e Mpositivi. Npuò essere inferiore a M(anche se il principio non si applica in quel caso).
2. Seleziona casualmente una delle possibili assegnazioni di elementi alle caselle. Ogni incarico dovrebbe avere una probabilità diversa da zero di essere scelto.

3. Produrre una rappresentazione in arte ASCII dell'incarico come segue:

   • Ci sono Mlinee, ognuna corrispondente a una casella.
   • Ogni riga inizia con un carattere non bianco, ad esempio |.
   • A seguire quel personaggio c'è un altro personaggio non bianco, come #, ripetuto tante volte quante sono le voci in quella casella.

Si consideri, per esempio N = 8, M = 5. Se l'assigment selezionato di elementi a scatole è 4, 1, 0, 3, 0, la rappresentazione è

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

Potrebbe dare una corsa diversa (risultante in una diversa assegnazione) dello stesso programma

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

C'è una certa flessibilità riguardo alla rappresentazione; vedi sotto.

Regole specifiche

Il codice dovrebbe teoricamente essere eseguito per qualsiasi valore di Ne M. In pratica, potrebbe essere limitato dalle dimensioni della memoria o dalle limitazioni del tipo di dati.

Dal momento che osservare l'output non è sufficiente per determinare se tutte le assegnazioni hanno probabilità diverse da zero , ogni invio dovrebbe spiegare come il codice lo raggiunge, se non ovvio.

Sono consentite le seguenti variazioni di rappresentazione :

• È possibile scegliere qualsiasi coppia di caratteri diversi da quelli non bianchi. Devono essere coerenti tra le esecuzioni del programma.
• Sono accettabili rotazioni di 90 gradi della rappresentazione. Ancora una volta, la scelta deve essere coerente.
• È consentito lo spazio bianco finale o iniziale.

Ad esempio con un diverso formato di rappresentazione, perché N = 15, M = 6i risultati di due esecuzioni del programma potrebbero essere

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

o

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

Analogamente, N = 5, M = 7potrebbe dare, utilizzando un'altra variante della rappresentazione,

  *
* * * *
UUUUUUU

o

 *** **
UUUUUUU

o

   *
*  *
*  * 
UUUUUUU

Nota come il principio non è applicabile in questo caso, perché N< M.

Regole generali

Programmi o funzioni sono consentiti, in qualsiasi linguaggio di programmazione . Sono vietate le scappatoie standard .

L'input può essere preso con qualsiasi mezzo ragionevole ; e con qualsiasi formato, come una matrice di due numeri o due stringhe diverse.

Anche i mezzi e il formato di output sono flessibili. Ad esempio, l'output può essere un elenco di stringhe o una stringa con newline; restituito come argomento di output della funzione o visualizzato in STDOUT. In quest'ultimo caso non è necessario preoccuparsi dell'avvolgimento della linea causato dalla larghezza del display limitata.

Vince il codice più breve in byte.

Gelatina , 9 8 byte

=þṗX¥S⁵*

Questo è un collegamento diadico che prende M come sinistra e N come argomento giusto. L'output è un array di numeri interi, dove 0 rappresenta i piccioni e 1 rappresenta i buchi.

Provalo online!

Come funziona

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

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

Una funzione senza nome che accetta due argomenti interi, il numero di caselle, seguito dal numero di elementi.

Calcola innanzitutto tutte le possibili partizioni N+Min Mparti esattamente positive e successivamente sottrae 1da ciascuna partizione. Questo ci dà tutte le possibili partizioni Nin Mparti non negative (che IntegerPartitionsaltrimenti non genererebbero). Quindi scegli una partizione casuale e mescolala. Ciò garantisce che sono consentite tutte le possibili partizioni ordinate con zeri. Infine, convertire ogni bidone della partizione da una linea di uscita 10 aumentando la potenza corrispondente (tale che ogni linea diventa 1000...con kzeri). Un output di esempio potrebbe apparire come:

100
10000
1
10
10

Python 2, 77 86 byte

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

Genera un numero in [0, n], stampa quel numero di elementi e lo sottrae da n. Lo fa m volte.

Questo rende molto improbabile che qualcosa arrivi all'ultima casella, ma la domanda chiedeva solo che ogni output fosse possibile , non altrettanto probabile .

Lotto, 164 byte

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

Penso che 7 %segni consecutivi potrebbero essere un nuovo migliore personale! Nota: questo produce output dispari se dovesse mai assegnare più di 9 elementi alla stessa casella; se questo è un problema, quindi per 180 byte:

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

Sì, sono 28 %secondi in totale sulla seconda riga.

C, 102 byte

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

Accetta input su stdin, ad esempio:

echo "5 4" | ./pigeonhole

Non genererà ogni output con uguale probabilità, ma è in grado di generare tutte le possibili combinazioni.

Abbattersi:

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

Si affida alla gestione da parte di GCC del comportamento indefinito di %0s- normalmente %0bloccherà a zero un numero intero o float, ma può solo pad (mai troncare), quindi non è possibile stampare uno spazio vuoto. Ma il comportamento per le stringhe non è definito e GCC ha deciso di renderlo zero pad allo stesso modo, quindi questo zero pad una stringa vuota per poter scrivere zero o più 0s.

Python 2, 102 99 97 90 byte

m-1volte, scegli un importo casuale xtra 0e n, inclusivo e sottralo da n. Quindi stampare un 1e '0'*x.

Infine, stampa 1e il resto di 0s. Per niente uguali, ma tutte le configurazioni sono possibili.

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

(Codice riutilizzato dalla risposta Python non funzionante.)

Haskell, 114 94 byte

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

Un approccio un po 'bruto: genera un elenco infinito di numeri casuali, prende n numeri dell'inizio dell'elenco, li somma e verifica se sono uguali a m. In caso contrario, togli il primo elemento dall'elenco e ripeti.

Provalo online!

Nota: 73 byte senza importazione

EDIT: salvato alcuni byte con il trucco 10 ^ ( Prova la nuova versione online! )

REXX, 74 byte

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

Uscita (8 5):

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

Uscita (8 5):

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

C, 175 138 byte

Grazie a @Dave per aver salvato 37 byte!

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

Provalo online!

AHK, 66 byte

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

Ho seguito lo stesso principio che orlp ha fatto usando numeri casuali da 0 a N e poi sottraendolo da N. Sfortunatamente, non sono riuscito a salvare byte usando 10 ^ r a causa del modo in cui funziona la funzione Invia. Ahimè e molto. Ecco alcune uscite per n = 8, m = 5:

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

CJam, 30 31 21 byte

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

L'input è di due numeri n mnello stack. Utilizza 1per il carattere colonna e 0per il carattere ripetuto.

Spiegazione:

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

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

Provalo online!

Questo crea una matrice di zero e li incrementa in punti casuali.

PHP, 100 byte

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

Abbattersi :

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

Uscite per m=7e n=5:

Prima esecuzione:

za
zaa
za
za
zaa

Seconda esecuzione:

za
zaa
zaaa
z
za

Provalo online!

JavaScript, 105 byte

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

Provalo online!

A causa del metodo di assegnazione delle righe, questo tenderà a posizionarsi più verso il basso, anche se c'è una piccola possibilità che la parte superiore ne ottenga alcune.

Rubino, 52 byte

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

Crea una funzione anonima che accetta due numeri interi come argomenti e restituisce una matrice di stringhe:

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

Python 2, 81 byte

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

Restituisce un elenco di stringhe.

Javascript (ES7), 75 byte

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

Ho pensato di essere intelligente per avere i poteri dell'idea 10 solo per rendermi conto che la maggior parte delle risposte lo utilizzavano già.

AWK, 78 byte

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

Accetta 2 argomenti, prima il numero di elementi, quindi il numero di caselle. Inizia seminando il generatore di numeri casuali in modo che ogni corsa sia diversa. Quindi crea semplicemente stringhe in un array, Esempio di utilizzo:

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 byte

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)

Con Formattazione

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

Uscita campione

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

Ci sono spazi bianchi finali poiché ogni voce dell'array viene visualizzata con una scheda tra loro, ma questo dovrebbe essere accettabile secondo le specifiche.

Mi sembra un'implementazione molto semplicistica, quindi sono sicuro che potrebbe essere migliorato.

Grazie a @Luis Mendo per i suggerimenti.

Ottava , 62 54 byte

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

Funzione anonima che accetta due numeri e genera un array 2D di caratteri con >per le caselle e *per gli oggetti. Tutti i risultati sono ugualmente probabili.

Provalo online!

TI-Basic, 63 62 byte

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

Ogni incarico dovrebbe avere una probabilità diversa da zero di essere scelto.

Questo criterio ha reso questo programma molto più facile da scrivere.

Esempio I / O:

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

Spiegazione:

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 byte

Aggiornamento 3 #

Ho bisogno dell'ordinamento, a quanto pare, poiché altrimenti ottengo numeri interi negativi. Ora ho sostituito disp(sprintf(...))con fprintf(...), quindi la risposta rimane 58 byte.

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

Aggiornamento # 2:

Mi sono reso conto che non avevo bisogno di ordinare l'array e in effetti l'ordinamento avrebbe effettivamente ridotto la media dei numeri nell'array. Quindi ho eliminato la sort(...)parte. Si noti che l'output rimane lo stesso, quindi non sto aggiornando "output di esempio".

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

Infine, chiudendo sulla risposta Octave di Luis! : D

Aggiornamento # 1:

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

Invece di convertire in stringa, visualizzo solo i numeri direttamente. Potrei ridurre a 58 byte, rimuovendo il disp(...), ma poi ottengo il extra ans =con solo sprintf e non so se questo è accettabile.

Codice iniziale:

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

Grazie ad alcuni suggerimenti di Luis , mi sono liberato del ciclo nella mia risposta precedente . Ora prima creo un array verticale di mnumeri casuali aggiungendo fino a n( diff([0;sort(randi(n,m-1,1));n])), quindi li uso come esponenti di 10, li converto in una stringa, li giustifico a sinistra e li visualizzo.

Potrei tecnicamente sbarazzarmi del disp (...) per salvare altri 6 byte, ma poi viene stampato un "ans" che può violare le specifiche. Potrebbe anche esserci un modo per cambiarli in stringa e giustificare a sinistra per ottenere il formato finale desiderato, quindi sono aperto ai suggerimenti.

Uscita campione:

>> 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 : ho cambiato la mia funzione in una funzione anonima qui, sulla base di suggerimenti. Nell'output di esempio, l'ho assegnato aaper dimostrare. Spero che questo non violi le specifiche, ma se lo fa fammi sapere e lo cambierò.

Impilato , 29 byte

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

Provalo online!

Si comporta costruendo un array di Msingleton contenenti '|', quindi aggiungendo '#'a un array scelto a caso N.

Python 2 , 80 95 89 88 byte

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

Provalo online!

• Aggiunti 15 byte: la modifica precedente era un po 'imperfetta, alcuni piegati erano stati esclusi.
• 6 byte salvati: sostituito se altro da [n, x] [m> 1]
• Salvato 1 byte: importazione *

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

  Ｎ                 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