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.

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

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 ""

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
  

APL (Dyalog) , 37 octets

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

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.

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.

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.

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.

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!

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

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

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!

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';
            }
        }
    }
}

SmileBASIC, 75 octets

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

Perl 5 , 44 octets

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

Essayez-le en ligne!

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.

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

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

<p><input id=i value=10 /><button id=t onclick="o.textContent=f(+i.value)">Run</button><p><pre id=o></pre>

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

Fusain , 30 29 27 octets

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

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.

Ｆχ

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.

Ｅυ⪫||ι

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

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!

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 |

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)

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!

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' ascii-art , 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'

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.

C # (Visual C # Interactive Compiler) , 131 octets

n=>{var r=new Random();var a=new int[10];for(int i=0;i<100;a[i%10]|=r.Next(n)<1?1:0)if(i++%10<1)Write("|"+string.Concat(a)+"|\n");}

Hé, au moins je suis à égalité avec Java.

Essayez-le en ligne!