Travailleurs d'usine

18

Défi

Les travailleurs d'usine sont généralement très travailleurs. Cependant, leur travail est désormais généralement remplacé par des machines.

Vous devez écrire un programme qui prend un nombre en entrée. Il imprimera 10 fois une usine de 10 travailleurs. Chaque fois, chaque travailleur a une 1/inputchance d'être «licencié» et remplacé par une machine.

Contribution

Un entier, provenant de STDIN ou d'un appel de fonction.

Production

10 caisses de l'usine, chacune avec généralement plus de travailleurs licenciés.

Format de sortie - comment imprimer une usine

Une usine ressemble à ceci:

|0000000000| ou |0000011001|

Un tuyau représente les murs, un 0 représente un travailleur et un 1 représente une machine, donc la première impression de l'usine sera toujours |0000000000|.

Exemple

Entrée: 10

Production:

|0000000000| //always start off with this
|0000000010| //a 1/10 chance means that this worker lost his job
|0000010010|
|0010010010|
|1010010010|
|1010110010|
|1010110011|
|1010111011|
|1010111111|
|1110111111|


Entrée: 5

Production:

|0000000000| //always start here
|0000001001| //a 1/5 chance means that 2 workers got fired
|1000101001|
|1000101111|
|1101101111|
|1111111111| //after achieving all machinery, the machines continue to be printed
|1111111111|
|1111111111|
|1111111111|
|1111111111|

REMARQUE

Le nombre de travailleurs licenciés est ALÉATOIRE - dans mes exemples car 1/5 chanceil y aurait toujours 2 travailleurs licenciés mais votre programme doit le faire au hasard - parfois 1 et parfois 3 - ils ont juste 1/5 de chance d'être licenciés.

lolade
la source
1
Peu importe - le travailleur peut être considéré comme très chanceux;)
lolad
2
Une entrée de 10 signifie-t-elle que chaque travailleur a 1/10 de chance de perdre son emploi à chaque fois, ou qu'un dixième des travailleurs seront licenciés à chaque fois?
12Me21
1
Le premier comme spécifié dans la NOTE (parfois 1 parfois 3)
Weijun Zhou
1
@ 12Me21, cela signifie que chaque travailleur a 1/10 de chance de perdre son emploi, PAS ce dernier.
lolad
6
@Uriel Non, je suis méchant =)
lolad

Réponses:

7

Japt -R , 22 21 20 19 18 octets

AÆP=®|!UöêAçTÃû|C

Essayez-le


Explication

AÆP=®|!UöêAçTÃû|C     :Implicit input of integer U
A                      :10
 Æ                     :Map the range [0,A)
  P=                   :  Assign to P (initially the empty string)
    ®                  :    Map P
     |                 :      Bitwise OR with
      !                :      The negation of
       Uö              :      A random integer in the range [0,U)
         Ã             :    End Map
          ª            :    OR, for the first element when the above will still be an empty string (falsey)
           Aç          :    Ten times repeat
             T         :      Zero
              Ã        :End Map
               û|      :Centre pad each element with "|"
                 C     :  To length 12
                       :Implicitly join with newlines and output
Hirsute
la source
7

R , 92 89 octets

cat(t(cbind("|",apply("[<-"(matrix(runif(100)<1/scan(),10),1,,0),2,cummax),"|
")),sep="")

Essayez-le en ligne!

Non golfé:

m <- matrix(runif(100)<1/n,10,10)   #10x10 matrix of TRUE with probability 1/n
                                    #and FALSE with probability 1-1/n
m[1,] <- 0                          #set first row to 0
m <- apply(m,2,cummax)              #take the column cumulative maxima
m <- cbind("|",m,"|\n")             #put "|" as the first and last columns
m <- t(m)                           #transpose m for the write function
cat(m,sep="")                       #print m to stdout, separated by ""

Giuseppe
la source
1
J'ai passé pas mal de temps à essayer de battre 92 cet après-midi en utilisant diverses implémentations de replicateet forboucles sans succès, mais avec vos conseils Do-while loops, je viens de réaliser à quel point cela pouvait {être abusif . J'ai étendu cet abus à un exemple avec for()une solution de 92 octets. Peut-être que vous avez déjà réalisé les implications de l' {abus lorsque vous avez écrit ce conseil, mais je viens de le réaliser. tio.run/##K/r/…
Vlo
@Vlo Est-ce le bon lien TIO? Pourtant, on dirait que tu m'as battu avec une fonction! Je t'ai joué au golf à 82 octets
Giuseppe
Je devrais commencer un salon de discussion R ... Je pense que ce "for"n'est presque toujours pas mieux que for, et c'est parfois pire !
Giuseppe
Haha, bien sûr, pmaxpeut être utilisé. Voici mon point précédent sur l' {opérateur. tio.run/##PZDBasNADETv@xVDfKhNjcGHXAKl5OJTT2l/…
Vlo
6

JavaScript (ES6), 84 octets

n=>[...s=2e9+''].map(j=>`|${s=s.replace(/./g,i=>i&1|Math.random()*n<!+j)}|`).join`
`

Essayez-le en ligne!


Version récursive, 88 octets

n=>(g=k=>k?`|${s=s.replace(/./g,i=>i%5|Math.random()*n<(s!=k))}|
`+g(k>>3):'')(s=5e9+'')

Essayez-le en ligne!

Comment?

Nous commençons par k = s = '5000000000' .

À chaque itération:

  • Nous contraignons chaque personnage i de s à un nombre, calculons i modulo 5 - de sorte que le 5 de tête soit traité comme un 0 - et effectuons au hasard un OR au niveau du bit avec 1 avec la probabilité attendue 1 / n , sauf lors de la première itération .

  • Le compteur k est décalé vers la droite de 3 bits. Nous arrêtons la récursivité dès que k = 0 , ce qui donne 10 itérations.

    Il est important de noter que 5000000000 est légèrement plus grand qu'un entier 32 bits, il est donc implicitement converti en 5000000000 & 0xFFFFFFFF = 705032704 juste avant le premier décalage au niveau du bit. D'où les étapes suivantes:

     step | k
    ------+-----------
       0  | 705032704
       1  | 88129088
       2  | 11016136
       3  | 1377017
       4  | 172127
       5  | 21515
       6  | 2689
       7  | 336
       8  | 42
       9  | 5
      10  | 0
    
Arnauld
la source
4

APL (Dyalog) , 37 octets

⎕{⎕←' '~⍨⍕'|''|'⋄×⍵+⍺=?10⍴⍺}⍣10100

Essayez-le en ligne!

Comment?

10⍴0 - commencez par 10 zéros.

⎕←' '~⍨⍕'|'⍵'|' - à chaque fois imprimer le tableau formaté,

?10⍴⍺ - générer un tableau aléatoire avec des valeurs allant 1 de l'entrée,

⍺=- comparaison élément par élément avec l'entrée. doit marquer 1/ saisir les éléments, en donnant à chacun1 entrée a / à chaque fois,

⍵+ - ajouter au tableau,

×- signum. zéro reste nul, tout ce qui est supérieur à un revient à un.

⍣10 - répéter 10 fois.

Uriel
la source
Je suis confus, +1 =)
lolad
3

Rétine , 30 octets

.+
|¶10*$(*0¶
.-10+0\%0<@`\d
1

Essayez-le en ligne!

Je m'amuse beaucoup avec le hasard dans Retina ^^

Explication

La première étape configure la chaîne avec laquelle nous allons travailler:

.+
|¶10*$(*0¶

Il remplace l'intégralité de l'entrée par |une nouvelle ligne, puis 10 lignes contenant autant de 0s que l'entrée l'indique. Le premier caractère de chaque ligne représentera un travailleur de l'usine.

L'étape suivante signifie:

.                     Disable automatic printing at the end of the program
 -10+                 Do the following exactly 10 times:
       %                For each line:
        0<                Print the first character, then
          @`\d            Pick a random digit and
1 (on the next line)      replace it with a 1
     0\                 Then print the first character of the whole string
                        followed by a newline

La première ligne de la chaîne de travail ne contient qu'un | , qui sera le premier caractère imprimé par chaque itération de la boucle (étant le premier caractère de la première ligne), et sera également imprimé à la fin de chaque itération (étant le premier caractère de la chaîne entière). Le remplacement n'aura jamais d'effet sur cette ligne car il ne contient aucun chiffre.

Chaque autre ligne contient des nchiffres, il y a donc 1 nchance de transformer le premier caractère de la ligne (qui est le seul significatif) en a 1.

Leo
la source
3

PowerShell , 82 80 69 octets

param($x)($a=,0*10)|%{"|$(-join$a)|";$a=$a|%{$_-bor!(Random -ma $x)}}

Essayez-le en ligne!

Prend des informations $x. Crée un tableau de tous les zéros, enregistre cela dans $aet boucle ensuite plusieurs fois. De façon pratique, l'usine est aussi large que les itérations en valent la peine. À chaque itération, nous sortons notre usine actuelle avec "|$(-join$a)|", puis parcourons chaque élément de $a.

À l'intérieur, nous sélectionnons l'élément actuel $_qui a été -binhalé oravec l'un ou l'autre en 1fonction de la Randomchance basée sur l'entrée $x. Par exemple, pour la saisie 10, Get-Random -max 10sera comprise entre 0et 9et sera 0environ 1 / 10ème du temps. Ainsi, avec un !(...)emballage le Random, nous aurons 1environ 1/inputle temps et l'autre 1-1/inputtemps $_. Oui, cela signifie parfois que nous remplaçons un 1par un autre 1, mais ça va.

Ce tableau résultant est ensuite stocké dans $ale prochain tour. Toutes les chaînes résultantes sont laissées sur le pipeline, et l'implicite Write-Outputà l'achèvement du programme nous donne des nouvelles lignes gratuitement.

-2 octets grâce à Veskah.
-11 octets grâce à ASCII uniquement.

AdmBorkBork
la source
80 octets?
Veskah
@Veskah Oui, cela fonctionnera bien. Merci!
AdmBorkBork
78?
ASCII uniquement le
69 ????
ASCII uniquement
@ ASCII uniquement Oh bien sûr, pourquoi réindexons- $anous alors que nous le parcourons déjà? lol Et c'est une astuce astucieuse avec le -bor. Merci!
AdmBorkBork
2

Perl 6 , 58 octets

{say "|$_|" for 0 x 10,|[\~|] ([~] +(1>$_*rand)xx 10)xx 9}

Essayez-le en ligne!

+(1 > $_ * rand)génère un seul bit avec la fréquence requise de 1s. xx 10réplique cette expression dix fois pour produire une seule instance d'usine sous forme de liste de bits et [~]joint cette liste en une seule chaîne. xx 9réplique cette expression génératrice de chaînes neuf fois, puis [\~|]effectue une réduction triangulaire (que certaines autres langues appellent un "scan") avec l'opérateur stringwise ou ~|, de sorte qu'un travailleur renvoyé lors d'une itération antérieure reste déclenché dans les versions ultérieures.

Sean
la source
1
Agréable. Vous pouvez supprimer l'espace avant for. Bat la solution basée sur les nombres sur laquelle {say "|{.join}|"for [\<<+|>>] (?$++X*!<<^$_).roll(10)xx 10}je travaillais de deux octets. Avec [\Z+|]ce serait 56 octets, mais cela ne fonctionne pas pour une raison quelconque.
nwellnhof
1
Vous pouvez également remplacer $_*randpar .rand. La façon dont j'interprète les règles, en renvoyant une liste de chaînes "d'usine" devrait également être OK.
nwellnhof
2

Python 2 , 104 103 octets

from random import*
x='0'*10;i=input()
exec"print'|%s|'%''.join(x);x=[choice('1'+n*~-i)for n in x];"*10

Essayez-le en ligne!

Barre
la source
Désolé, vous devez formater la sortie
lolad
@lolad fixed c:
Rod
bravo, +1 =)
lolad
2

Gelée , 22 octets

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y

Un programme complet acceptant l'entier comme entrée de ligne de commande et imprimant la sortie vers STDOUT.
(En tant que lien monadique, il renvoie une liste de caractères et d'entiers.)

Essayez-le en ligne!

Comment?

Décide effectivement à chaque étape si chaque travailleur (y compris les machines) perd son emploi (avec une chance sur un), cependant les machines sont remplacées par des machines (en utilisant OU logique).

ẋ⁵ẋ€⁵¬1¦X€€=1o\j@€⁾||Y - Main link: integer, N
 ⁵                     - literal ten
ẋ                      - repeat -> [N,N,N,N,N,N,N,N,N,N]
    ⁵                  - literal ten
  ẋ€                   - repeat €ach -> [[N,N,N,N,N,N,N,N,N,N],...,[N,N,N,N,N,N,N,N,N,N]]
       ¦               - sparse application...
      1                - ...to indices: [1]
     ¬                 - ...do: logical-NOT -> [[0,0,0,0,0,0,0,0,0,0],[N,N,...],...]
        X€€            - random integer for €ach for €ach
                       -   (0s stay as 0s; Ns become random integers in [1,N])
           =1          - equals one? (vectorises)
             o\        - cumulative reduce with logical-OR
                  ⁾||  - literal list of characters = ['|','|']
               j@€     - join with sw@pped arguments for €ach
                     Y - join with line feeds
                       - implicit print
Jonathan Allan
la source
2

MATL , 26 octets

'|'it10th&Yr=0lY(Y>48+y&Yc

Essayez-le en ligne!

(Long) explication

Des exemples de contenu de pile sont affichés en cours de route. À chaque étape, le contenu de la pile est affiché de bas en haut.

'|'    % Push this character
       % STACK: '|'
it     % Take input. Duplicate
       % STACK: '|'
                5
                5
10th   % Push [10 10]
       % STACK: '|'
                5
                5
                [10 10]
&Yr    % Random 10×10 matrix of integers from 1 to input number
       % STACK: '|'
                 5
                 [4 5 4 4 5 5 2 1 2 3
                  3 4 3 3 1 4 4 3 1 5
                  5 1 4 5 4 4 5 2 3 2
                  3 4 5 2 1 3 2 5 3 4
                  4 1 2 2 4 1 1 5 1 1
                  4 5 3 1 5 3 5 2 4 1
                  2 1 4 3 3 1 3 5 3 5
                  1 2 2 1 2 2 4 3 5 3
                  4 5 4 1 2 2 5 3 2 4
                  4 1 2 5 5 5 4 3 5 1]
=      % Is equal? Element-wise
       % STACK: '|'
                [0 1 0 0 1 1 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
0lY(   % Write 0 in the first row
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 0
                 0 0 1 0 0 0 0 1 0 0
                 0 0 0 0 0 0 0 1 0 0
                 0 1 0 0 1 0 1 0 0 0
                 0 0 0 0 0 0 0 1 0 1
                 0 0 0 0 0 0 0 0 1 0
                 0 1 0 0 0 0 1 0 0 0
                 0 0 0 1 1 1 0 0 1 0]
Y>     % Cumulative maximum down each column
       % STACK: '|'
                [0 0 0 0 0 0 0 0 0 0
                 0 0 0 0 0 0 0 0 0 1
                 1 0 0 1 0 0 1 0 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 0 1 1 0 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 0 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 0 1 1 1 1
                 1 1 1 1 1 1 1 1 1 1]
48+    % Add 48, element-wise. This transforms each number into the
       % ASCII code of its character representation
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
y      % Duplicate from below
       % STACK: '|'
                [48 48 48 48 48 48 48 48 48 48
                 48 48 48 48 48 48 48 48 48 49
                 49 48 48 49 48 48 49 48 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 48 49 49 48 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 48 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 48 49 49 49 49
                 49 49 49 49 49 49 49 49 49 49]
                 '|'
&Yc    % Horizontally concatenate all stack contents as char arrays.
       % 1-row arrays are implicitly replicated along first dimension
       % STACK: ['|0000000000|'
                 '|0000000001|'
                 '|1001001001|'
                 '|1011001101|'
                 '|1011001101|'
                 '|1111101101|'
                 '|1111101101|'
                 '|1111101111|'
                 '|1111101111|'
                 '|1111111111|']
       % Implicitly display
Luis Mendo
la source
2

JavaScript (Node.js) , 105 93 90 octets

x=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``,w=Array(10).fill(0)

Essayez-le en ligne!

+2 octets pour mettre le tableau à l'intérieur de la fonction, grâce à @Shaggy pour l'avoir signalé

(x,w=Array(10).fill(0))=>w.map(a=>(`|${w=w.map(j=>j|Math.random()<1/x),w.join``}|
`)).join``

Essayez-le en ligne!

Joost K
la source
1
Notez que les fonctions doivent être réutilisables ici, donc wdevront être déclarées dans votre fonction.
Shaggy
@Shaggy, merci de l'avoir édité. malheureusement, il a ajouté 2 octets
Joost K
2

C (gcc) , 110 106 octets

-4 octets de @ceilingcat

char l[]="|0000000000|",i,j;f(n){for(srand(time(i=0));i++<10;)for(j=!puts(l);j++<10;)rand()%n||(l[j]=49);}

Essayez-le en ligne!

Itère à travers une liste de caractères pour chaque tour de remplacements.

Non golfé:

f(n)
{
    //start with a fresh factory
    char l[]="|0000000000|";

    //init rng
    srand(time(0));

    //print 11 lines
    for(int i = 0; i < 11; i++)
    {
        //print current factory
        puts(l);

        //iterate through the workers. start at index 1 to skip the '|'
        for(int j = 1; j < 11; j++)
        {
            //the expression (rand()%n) has n possible values in the range [0,n-1],
            //so the value 0 has 1/n chance of being the result and thus the worker
            //has 1/n chance of being replaced
            if(rand()%n == 0)
            {
                l[j] = '1';
            }
        }
    }
}
vazt
la source
Je pense que vous imprimez 1 trop d'usines. L'exemple montre 10, mais votre lien TIO en montre 11.
Brian J
Hm tu as raison. Je l'ai changé en 11 après avoir lu un commentaire sur la solution de quelqu'un d'autre en leur disant que c'était censé être 11, mais je n'ai jamais vérifié l'exemple du défi. Merci
vazt
1

SmileBASIC, 75 octets

INPUT N
FOR J=0TO 9?"|";BIN$(F,10);"|
FOR I=0TO 9F=F OR!RND(N)<<I
NEXT
NEXT
12Me21
la source
1

Perl 5 , 44 octets

#!/usr/bin/perl -a
say"|$_|",s/0/rand"@F"<1|0/eg<0for(0 x10)x10

Essayez-le en ligne!

Ton Hospel
la source
1

05AB1E , 22 octets

TÅ0TFDJ'|.ø=sITи€L€ΩΘ~

Essayez-le en ligne!

Il devrait y avoir plus de place pour le golf.

  • TÅ0 - Poussez une liste de 10 zéros.
  • TF... - Faites cela 10 fois:
    • DJ - Dupliquez l'élément actuel et joignez-le.
    • '|.ø=- Entourez-le de deux |s et imprimez sur STDOUT.
    • ITи - Répétez la saisie 10 fois.
    • €L€Ω- Et pour chaque occurrence, obtenez un élément aléatoire de [1 ... N] . (Il pourrait y avoir un intégré pour cela que je n'ai pas encore vu)
    • Θ- Appuyez sur 05AB1E trueified ™. Pour chacun, vérifiez s'il est égal à 1 .
    • s...~ - Logique OU le résultat par l'élément actuel.
M. Xcoder
la source
1

JavaScript, 83 octets

f=(n,t=9,s=`|0000000000|
`)=>t?s+f(n,t-1,s.replace(/0/g,v=>+(Math.random()<1/n))):s

tsh
la source
80 octets
Shaggy
1

Java 10, 153 152 131 octets

n->{for(int j=10,a[]=new int[j],i;j-->0;){var s="|";for(i=0;i<10;a[i++]|=Math.random()*n<1?1:0)s+=a[i];System.out.println(s+"|");}}

-18 octets grâce à @ OlivierGrégoire , et -3 octets supplémentaires en convertissant Java 8 en Java 10.

Explication:

Essayez-le en ligne.

n->{                             // Method with integer parameter and no return-type
  for(int j=10,a[]=new int[j],i; //  Create the array with 10 workers (0s)
      j-->0;){                   //  Loop 10 times

    var s="|";                   //  Start a String with a wall
    for(i=0;i<10;                //  Loop `i` from 0 to 10 (exclusive)
        a[i++]                   //    After every iteration, change the current item to:
         |=                      //     If it's a 0:
           Math.random()*n<1?    //      If the random value [0:1) is below 1/n
            1                    //       Change the worker to a machine
           :                     //      Else:
            0;                   //       It remains a worker
                                 //     Else (it already is a machine)
                                 //      It remains a machine
      s+=a[i];                   //   Append the current item to the String
    System.out.println(s+"|");}} //   Print the String, with a trailing wall and new-line
Kevin Cruijssen
la source
1
131 octets . Remplacez varpar Stringpour Java 9 et inférieur et pour 3 octets supplémentaires. J'ai essentiellement fusionné les deux boucles que vous avez.
Olivier Grégoire
1

Fusain , 30 29 27 octets

⊞υ×χ0Fχ⊞υ⭆§υ±¹‽⁺1×κ⊖θEυ⪫||ι

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

⊞υ×χ0

Poussez une chaîne de 10 0s dans la liste vide u.

Fχ

Répétez la commande suivante 10 fois.

⊞υ⭆§υ±¹‽⁺1×κ⊖θ

Pour chaque caractère de la dernière chaîne, répétez-le n-1fois, ajoutez un 1et choisissez un caractère aléatoire dans la chaîne. Cela donne une 1/nchance de changer le personnage en a 1. Le résultat est poussé vers u.

Eυ⪫||ι

Carte sur la liste des chaînes, entourant chacune avec |, puis imprimez implicitement chacune sur sa propre ligne.

Neil
la source
0

Python 3 , 132 octets

from random import*
w,p,c=[0]*10,'|',1/int(input())
for _ in w:print(p+''.join(map(str,w))+p);w=list(map(lambda x:x|(random()<c),w))

Essayez-le en ligne!

Rick Rongen
la source
0

APL + WIN, 30 40 35 octets

Manqué le bit sur aucun espace; (- corrigé & merci à Uriel pour -3 octets

Invite à saisir un numéro à l'écran

'|',(⍕0⍪×+⍀n=?9 10⍴n←⎕)[;2×⍳10],'|'

Explication similaire à celle d'Uriel:

?9 10⍴n create a 9x10 matrix of numbers selected at random between 1 and number

×+⍀n= compare elements of matrix to number, cumulatively sum columns and signum

[;2×⍳10] take non-space columns

'|',(⍕0⍪.......,'|' concatenate a row of zeros and front and back columns of |
Graham
la source
9 10⍴?90⍴5?9 10⍴5. Vous devez également éliminer les espaces
Uriel
@Uriel merci pour les -3 octets et j'avais raté la règle du pas d'espace.
Graham
0

VBA, 144 octets

Sub f(i)
Dim w(9) As Long
For x = 0 To 9
s = "|"
For y = 0 To 9
s = s & w(y)
If i * Rnd() < 1 Then w(y) = 1
Next
Debug.Print s; "|"
Next
End Sub

En retrait pour une lecture plus facile:

Sub f(i)
    Dim w(9) As Long
    For x = 0 To 9
        s = "|"
        For y = 0 To 9
            s = s & w(y)
            If i * Rnd() < 1 Then w(y) = 1
        Next
        Debug.Print s; "|"
    Next
End Sub

Prend avantage de 2 points: les baies VBA seront par défaut à Base 0 ( w(9)c'est la même chose quew(0 to 9) ) et la création de la matrice en tant que longue l'initialisera automatiquement à 0.

(De façon ennuyeuse, 20 octets sont automatiquement mis en forme que VBA ajoute mais pas réellement requis - 19 espaces et un point-virgule)

Chronocide
la source
0

Je ne vois pas encore de réponse pour Ruby, donc:

Rubis , 92 octets

n=gets.to_i
z='0'*x=10
x.times do
puts'|'+z+'|'
x.times do|s|
z[s]='1' if rand(n)==0
end
end

Essayez-le en ligne!

Turophile
la source
Enregistrez un octet en utilisant rand(n)<1au lieu de rand(n)==0, et enregistrez-en quelques-uns en utilisant {..}au lieu de do..end, par exemplex.times{puts'|'+z...}
Piccolo
0

Rubis, 67 octets

->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

Je pense que j'ai triché quelques choses ici. Tout d'abord, cette fonction imprime la sortie avec des guillemets autour de chaque ligne, par exemple:

pry(main)> ->n{f=[0]*10;10.times{p"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}[5]
"|0000000000|"
"|0100100000|"
"|0100100000|"
"|0100100000|"
"|0100100100|"
"|0100110100|"
"|0101110100|"
"|0111110100|"
"|1111110110|"
"|1111110110|"
=> 10

Si cela est inacceptable (étant donné qu'il s'agit d' , c'est probablement le cas), voici une solution qui imprime sans guillemets pour 70 octets :

->n{f=[0]*10;10.times{puts"|#{f.join}|";f.map!{|l|rand>(1.0/n)?l:?1}}}

Explication:

->n{                                                              } # defines anonymous lambda
    f=[0]*10;                                                       # initializes f to [0,0,0,...] (10)
             10.times{                                           }  # main loop
                      p"|#{f.join}|";                               # joins f and prints | before and after
                                     f.map!{|l|                 }   # maps each element of f
                                               rand>(1.0/n)? :      # if rand is greater than 1.0/n
                                                            l ?1    # keep current element or replace with '1'
Piccolo
la source
0

PHP, 71 70 octets

la fusion des boucles a sauvé 5 octets (encore):

for(;$k<91;$v|=!rand(0,$argn-1)<<$k++%10)$k%10||printf("|%010b|
",$v);

Exécuter en tant que pipe avec -nRou l' essayer en ligne .


édition 1: format fixe et première sortie (pas de changement du nombre d'octets grâce au golf supplémentaire)
édition 2: golfé un octet de plus: après la dernière impression, il n'y a plus besoin de renvoyer qui que ce soit.

Titus
la source