Pigeonhole Principe & Code Golf

26

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.

Luis Mendo
la source
11
En fait, il m'a fallu jusqu'à présent pour obtenir le titre ...
Martin Ender
@MartinEnder Est-ce que le "principe du pigeonhole" a plus de caractères que le "code golf", ou y a-t-il une autre blague?
user8397947
5
@dorukayhan Dans un navigateur standard, regardez le texte légèrement au-dessus du titre de la question ...
Luis Mendo

Réponses:

2

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.
Dennis
la source
10

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
Martin Ender
la source
Je pense que PadRightje ne remplirais pas les Mzéros si N< M.
LegionMammal978
1
@ LegionMammal978 Merci, j'ai réussi à le réparer avec le même nombre d'octets.
Martin Ender
... Je suis honnêtement impressionné. J'étais sur le point de faire une solution similaire, mais PadRightla non-listabilité le rendrait beaucoup plus long.
LegionMammal978
@ LegionMammal978 Une autre façon d'éviter PadRightserait IntegerPartitions[#,{#2},0~Range~#].
Martin Ender
1
Pas de buitltine? Je suis surpris ...: D Mais belle réponse. Je dois juste comprendre comment cela fonctionne en premier: P
HyperNeutrino
9

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 .

orlp
la source
7

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.

Neil
la source
5

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.

Dave
la source
2
Puisque les fonctions sont autorisées, vous pouvez couper quelques caractères en utilisant a(b,c){...}au lieu de mainet scanf.
Kevin
3

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

L3viathan
la source
Je pense que cette réponse aurait dû être une suggestion sur ma réponse car c'est littéralement la même réponse avec une petite correction de bogue.
orlp
1
@orlp Si vous regardez l'historique de cette réponse, elle est juste devenue celle de la dernière version. Si je l'avais fait comme ça au départ, je l'aurais plutôt affiché comme commentaire.
L3viathan
Ah alors ça va, la façon dont il avait l'air (et que vous avez écrit du «code réutilisé») le rendait différent de ce qu'il est. Désolé.
orlp
@orlp Aucun problème. La vôtre fonctionne maintenant et plus courte que la mienne de toute façon, je peux également supprimer cette réponse si vous pensez qu'elle est trop proche de la vôtre, cela ne me dérange pas, je voulais juste préciser que je n'ai pas simplement copié-collé votre réponse.
L3viathan
3

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

Nom d'affichage générique
la source
2

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

@#
@#
@
@####
@##
idrougge
la source
2

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!

Steadybox
la source
1
Salut, quelques choses qui pourraient vous aider à réduire cela: callocvous donnera une mémoire initialisée à 0 (pas besoin de définir tous les 0 vous-même), strchrpeut trouver la fin d'une chaîne, des opérations de chaîne de virgule peuvent être évitées {}, et x[0] == *x. Attention aussi; vous n'avez pas mallocassez de mémoire si tous les éléments sont dans la même boîte.
Dave
2

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:

|##     |#####    |##       |##     |#      |##   
|##     |#        |#####    |       |###    |#    
|#      |##       |         |###    |###    |     
|###    |         |         |       |#      |     
|       |         |#        |###    |       |#####
Ingénieur Toast
la source
2

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.
Esolanging Fruit
la source
1

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.

fergusq
la source
1

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!

roberto06
la source
Vous pouvez utiliser à [,$m,$n]=$argv;partir de PHP 7.1 pour enregistrer quelques caractères. Vous pouvez remplacer \npar un saut de ligne réel pour économiser 1 octet. vous pouvez utiliser for(;$m-->0;)$a[rand(0,$n-1)].=a;pour enregistrer les pauses, un $met un point-virgule. [,$m,$n]=$argv;$a=array_fill(0,$n,z);for(;$m-->0;)$a[rand()%$n].=a;echo join("\n",$a);85 octets
Christoph
Cela diminue encore [,$m,$n]=$argv;for(;$m--;)${rand()%$n}.=a;for(;$n--;)echo"z${$n}\n";67 octets.
Christoph
@Christoph J'ai vu la notation [,$m,$n]=$argv;sur d'autres golfs de code mais je n'ai pas pu le faire fonctionner ni dans mon environnement de développement ni sur eval.in
roberto06
essayez-le ici: sandbox.onlinephpfunctions.com/code/… .
Christoph
1
Agréable. Je pense que vous pouvez poster votre extrait de
code
1

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.

fəˈnɛtɪk
la source
1

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
|#
|#
|##
|##
|#
Rétablir Monica iamnotmaynard
la source
1

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.

TFeld
la source
1

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.

Valar Dohaeris
la source
1

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:
|##
|###
|##
|##
|###
Robert Benson
la source
1

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.

Krostd
la source
Vous pouvez enregistrer plusieurs octets définissant l'instruction display comme une fonction anonyme, pour éviter de l'écrire deux fois: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)
Luis Mendo
@LuisMendo Merci pour la suggestion, je mettrai à jour. Puis-je également définir ma fonction réelle de la même manière, par exemple. a = @ (m, n) ... car cela réduira également le nombre d'octets. Comment les gens suppriment-ils / raccourcissent-ils généralement le "nom de la fonction (arguments)" dans les réponses de code-golf MATLAB?
Krostd
Oui, vous pouvez également utiliser une fonction anoyme comme réponse. Vous pouvez même ignorer le a=. Dans ce cas, vous ne pouvez pas faire cela, en principe, car les fonctions anonymes ne peuvent pas contenir de boucles. Mais vous pourriez utiliser l'astuce de tout mettre dedans eval('...'). BTW, c'est normalement considéré comme une mauvaise et mauvaise pratique dans Matlab, mais ici nous aimons abuser des langues :-)
Luis Mendo
Hmm .. Je vais mettre à jour en fonction de votre suggestion et y réfléchir davantage et voir si je peux éviter la boucle, bien que cela semble peu probable. Je peux penser à une logique qui pourrait le faire, mais je ne sais pas comment l'implémenter .. Je pense à définir un nombre 10 ^ n, à trouver des nombres m qui sont tous des puissances de 10, puis à les imprimer. Ce sera exactement la même sortie que j'ai maintenant ..: D Des suggestions? N'hésitez pas à le poster comme une autre réponse.
Krostd
Je voulais dire m facteurs (pas n'importe quel nombre)
Krostd
1

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!

Luis Mendo
la source
1

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
pizzapants184
la source
1

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.

Krostd
la source
Je viens de réaliser que la réponse du haut utilise la même logique de 10 ^ .. Pour ce que ça vaut, et si c'est important, je ne l'ai pas utilisé comme référence pour ma réponse .. (mais dang, quelqu'un m'a battu!): P)
Krostd
Je voulais également mentionner le mérite de cette réponse pour l'idée de créer mdes entiers aléatoires qui s'additionnent n, car je suis resté coincé sur cette partie pendant un long moment .. (Je ne peux toujours pas ajouter plus de 2 liens dans mes réponses, donc l'inclure dans un commentaire)
Krostd
1

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.

Conor O'Brien
la source
Agréable! Et donc tous les résultats sont également probables, non?
Luis Mendo
@LuisMendo devrait l'être, car randinutilise l'algorithme Fisher-Yates en interne. (C'est le même algorithme que la réponse CJam utilise FWIW)
Conor O'Brien
1

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 *
officialaimm
la source
1

Fusain , 19 octets

≔EN⟦⟧θFN⊞‽θ#Eθ⁺|⪫ιω

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

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

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

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