Le principe du pigeonhole stipule que

Si N articles sont placés dans M cases, avec N > M , alors au moins une case doit contenir plus d'un article.

Pour beaucoup, ce principe a un statut spécial par rapport à d'autres propositions mathématiques. Comme l'a écrit EW Dijkstra ,

Il est entouré d'une mystique. Les preuves qui l'utilisent sont souvent considérées comme quelque chose de spécial, quelque chose de particulièrement ingénieux.

Le défi

Le but de ce défi est d'illustrer le principe du pigeonnier à l'aide de représentations artistiques ASCII. Plus précisément:

1. Prendre en entrée N(nombre d'articles) et M(nombre de cases), avec Nnon négatif et Mpositif. Npeut être inférieur à M(même si le principe ne s'applique pas dans ce cas).
2. Sélectionnez au hasard l'une des affectations possibles des éléments aux boîtes. Chaque affectation doit avoir une probabilité non nulle d'être sélectionnée.

3. Produisez une représentation artistique ASCII de l'affectation comme suit:

   • Il y a des Mlignes, chacune correspondant à une case.
   • Chaque ligne commence par un caractère non blanc, tel que |.
   • Après ce caractère se trouve un autre caractère non blanc, tel que #, répété autant de fois qu'il y a d'éléments dans cette case.

Considérons par exemple N = 8, M = 5. Si le assigment sélectionné des articles à des boîtes est 4, 1, 0, 3, 0, la représentation est

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

Une exécution différente (entraînant une affectation différente) du même programme pourrait donner

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

Il y a une certaine flexibilité concernant la représentation; voir ci-dessous.

Règles spécifiques

Le code devrait théoriquement s'exécuter pour toutes les valeurs de Net M. En pratique, il peut être limité par la taille de la mémoire ou les limitations du type de données.

Étant donné que l'observation du résultat n'est pas suffisante pour déterminer si toutes les affectations ont une probabilité non nulle , chaque soumission doit expliquer comment le code y parvient, si ce n'est évident.

Les variations de représentation suivantes sont autorisées:

• N'importe quelle paire de caractères différents non blancs peut être choisie. Ils doivent être cohérents d'une exécution à l'autre du programme.
• Les rotations de 90 degrés de la représentation sont acceptables. Encore une fois, le choix doit être cohérent.
• Les espaces de fin ou de début sont autorisés.

A titre d'exemple avec un format de représentation différent, car N = 15, M = 6les résultats de deux exécutions du programme pourraient être

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

ou

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

De même, N = 5, M = 7pourrait donner, en utilisant une autre variante de la représentation,

  *
* * * *
UUUUUUU

ou

 *** **
UUUUUUU

ou

   *
*  *
*  * 
UUUUUUU

Notez comment le principe n'est pas applicable dans ce cas, car N< M.

Règles générales

Les programmes ou fonctions sont autorisés, dans n'importe quel langage de programmation . Les failles standard sont interdites.

L'entrée peut être prise par tout moyen raisonnable ; et avec n'importe quel format, comme un tableau de deux nombres ou deux chaînes différentes.

Les moyens et le format de sortie sont également flexibles. Par exemple, la sortie peut être une liste de chaînes ou une chaîne avec des retours à la ligne; renvoyé comme argument de sortie de fonction ou affiché dans STDOUT. Dans ce dernier cas, il n'est pas nécessaire de s'inquiéter du retour à la ligne causé par une largeur d'affichage limitée.

Le code le plus court en octets gagne.

Gelée , 9 8 octets

=þṗX¥S⁵*

Il s'agit d'un lien dyadique qui prend M comme argument de gauche et N comme argument de droite. La sortie est un tableau d'entiers, où 0 représente les pigeons et 1 représente les trous.

Essayez-le en ligne!

Comment ça marche

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

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

Une fonction sans nom qui prend deux arguments entiers, le nombre de cases, suivi du nombre d'éléments.

Il calcule d'abord toutes les partitions possibles de N+Men Mparties exactement positives, et soustrait ensuite 1de chaque partition. Cela nous donne toutes les partitions possibles de Nen Mparties non négatives (qui IntegerPartitionsne généreraient pas autrement). Choisissez ensuite une partition aléatoire et mélangez-la. Cela garantit que toutes les partitions ordonnées possibles avec des zéros sont autorisées. Enfin, convertissez chaque bac de la partition en une ligne de sortie en augmentant 10 à la puissance correspondante (de sorte que chaque ligne devient 1000...avec des kzéros). Un exemple de sortie pourrait ressembler à ceci:

100
10000
1
10
10

Python 2, 77 86 octets

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

Génère un nombre dans [0, n], imprime autant d'éléments et le soustrait de n. Il le fait m fois.

Cela rend très improbable que quelque chose arrive dans la dernière case, mais la question demandait seulement que chaque sortie soit possible , pas aussi probable .

Lot, 164 octets

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

Je pense que 7 %signes consécutifs pourraient être un nouveau record personnel! Remarque: cela produit une sortie étrange si jamais il affecte plus de 9 éléments à la même case; si c'est un problème, alors pour 180 octets:

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

Oui, c'est 28 %s au total sur la deuxième ligne.

C, 102 octets

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

Prend des informations sur stdin, par exemple:

echo "5 4" | ./pigeonhole

Ne génère pas chaque sortie avec une probabilité égale, mais est capable de générer toutes les combinaisons possibles.

Panne:

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

S'appuie sur la gestion par GCC du comportement indéfini de %0s- normalement %0va mettre à zéro un entier ou un flottant, mais il ne peut que remplir (jamais tronquer), donc il n'est pas possible d'imprimer un blanc. Mais le comportement pour les chaînes n'est pas défini, et GCC a décidé de le mettre à zéro de la même manière, donc ce zéro-pad est une chaîne vide pour pouvoir écrire zéro ou plusieurs 0s.

Python 2, 102 99 97 90 octets

m-1fois, choisissez un montant aléatoire xentre 0et n, inclus et soustrayez-le de n. Imprimez ensuite un 1et '0'*x.

Enfin, l'imprimé 1et le reste de l' 0art. Pas du tout des chances égales, mais toutes les configurations sont possibles.

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

(Code réutilisé de la réponse Python cassée.)

Haskell, 114 94 octets

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

Un peu d'une approche de force brute: génère une liste infinie de nombres aléatoires, prend n nombres du début de la liste, les résume et vérifie s'ils sont égaux à m. Sinon, retirez le premier élément de la liste et recommencez.

Essayez-le en ligne!

Remarque: 73 octets sans l'importation

EDIT: Sauvegardé quelques octets avec l'astuce 10 ^ ( Essayez la nouvelle version en ligne! )

REXX, 74 octets

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

Sortie (8 5):

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

Sortie (8 5):

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

C, 175 138 octets

Merci à @Dave pour avoir économisé 37 octets!

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

Essayez-le en ligne!

AHK, 66 octets

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

J'ai suivi le même principe que orlp en utilisant des nombres aléatoires de 0 à N, puis en le soustrayant de N. Malheureusement, je n'ai pas pu enregistrer d'octets en utilisant 10 ^ r en raison du fonctionnement de la fonction d'envoi. Hélas et alack. Voici quelques sorties pour n = 8, m = 5:

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

CJam, 30 31 21 octets

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

L'entrée est deux nombres n msur la pile. Utilise 1le caractère de colonne et 0le caractère répété.

Explication:

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

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

Essayez-le en ligne!

Cela crée un tableau de zéros et les incrémente à des endroits aléatoires.

PHP, 100 octets

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

Panne :

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

Sorties pour m=7et n=5:

Première exécution:

za
zaa
za
za
zaa

Deuxième exécution:

za
zaa
zaaa
z
za

Essayez-le en ligne!

JavaScript, 105 octets

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

Essayez-le en ligne!

En raison de la méthode d'attribution des lignes, cela aura tendance à se placer davantage vers le bas, bien qu'il y ait une petite chance que le haut en obtienne.

Rubis, 52 octets

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

Crée une fonction anonyme qui prend deux entiers comme arguments et renvoie un tableau de chaînes:

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

Python 2, 81 octets

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

Renvoie une liste de chaînes.

Javascript (ES7), 75 octets

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

Je pensais que j'étais intelligent pour avoir trouvé les pouvoirs de l'idée 10 seulement pour réaliser que la plupart des réponses utilisaient déjà cela.

AWK, 78 octets

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

Prend 2 arguments, d'abord le nombre d'éléments, puis le nombre de boîtes. Commence en amorçant le générateur de nombres aléatoires de sorte que chaque exécution est différente. Construit ensuite simplement des chaînes dans un tableau, Exemple d'utilisation:

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 octets

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)

Avec formatage

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

Exemple de sortie

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

Il y a des espaces blancs à la fin puisque chaque entrée de tableau est affichée avec un onglet entre eux, mais cela devrait être acceptable selon les spécifications.

Cela me semble être une implémentation très simpliste, donc je suis sûr que cela pourrait être amélioré.

Merci à @Luis Mendo pour ses suggestions.

Octave , 62 54 octets

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

Fonction anonyme qui prend deux nombres et génère un tableau 2D de caractères avec >des boîtes et *des objets. Tous les résultats sont également probables.

Essayez-le en ligne!

TI-Basic, 63 62 octets

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

Chaque affectation doit avoir une probabilité non nulle d'être sélectionnée.

Ces critères ont rendu ce programme beaucoup plus facile à écrire.

Exemple d'E / S:

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

Explication:

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 octets

Mise à jour # 3

J'ai besoin du tri, semble-t-il, car sinon j'obtiens des entiers négatifs. J'ai remplacé disp(sprintf(...))par fprintf(...)maintenant, cependant, donc la réponse reste 58 octets.

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

Mise à jour # 2:

J'ai réalisé que je n'avais pas besoin de trier le tableau, et en fait, le tri réduirait en fait la moyenne des nombres dans le tableau. J'ai donc supprimé la sort(...)partie. Notez que la sortie reste la même, donc je ne mets pas à jour la "sortie d'échantillon".

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

Enfin, en terminant sur la réponse Octave de Luis! :RÉ

Mise à jour # 1:

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

Au lieu de convertir en chaîne, j'affiche simplement les nombres directement. Je pourrais réduire à 58 octets, en supprimant le disp(...), mais ensuite j'obtiens le supplément ans =avec juste sprintf, et je ne sais pas si c'est acceptable.

Code initial:

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

Grâce à quelques suggestions de Luis , je me suis débarrassé de la boucle dans ma réponse précédente . Maintenant, je crée d'abord un tableau vertical de mnombres aléatoires totalisant n( diff([0;sort(randi(n,m-1,1));n])), puis les utilise comme exposants de 10, les convertis en chaîne, les justifie à gauche et les affiche.

Je pourrais techniquement me débarrasser de la disp (...) pour économiser encore 6 octets, mais ensuite un "ans" s'imprime ce qui peut violer les spécifications. Il peut également y avoir un moyen de les changer en chaîne et de justifier à gauche pour obtenir le format de fin souhaité, donc je suis ouvert aux suggestions.

Exemple de sortie:

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

Remarque : J'ai changé ma fonction en fonction anonyme ici, sur la base de suggestions. Dans l'exemple de sortie, j'ai attribué cela àaafin de démontrer. J'espère que cela ne viole pas les spécifications, mais si c'est le cas, faites-le moi savoir et je le changerai.

Empilé , 29 octets

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

Essayez-le en ligne!

Se comporte en construisant un tableau de Msingletons contenant '|', puis en ajoutant '#'à un tableau choisi au hasard N.

Python 2 , 80 95 89 88 octets

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

Essayez-le en ligne!

• Ajout de 15 octets: l'édition précédente était un peu défectueuse, certains piegons ont été omis.
• 6 octets enregistrés: remplacé si sinon par [n, x] [m> 1]
• 1 octet enregistré: importation *

Fusain , 19 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

  Ｎ                 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