Desafío

Los trabajadores de las fábricas suelen ser muy trabajadores. Sin embargo, su trabajo ahora está siendo reemplazado comúnmente por máquinas.

Tienes que escribir un programa que tome un número como entrada. Imprimirá una fábrica de 10 trabajadores 10 veces. Cada vez, cada trabajador tiene la 1/inputposibilidad de ser 'despedido' y reemplazado por una máquina.

Entrada

Un número entero, proveniente de STDIN o una llamada de función.

Salida

10 casos de la fábrica, cada uno con generalmente más trabajadores despedidos.

Formato de salida: cómo imprimir una fábrica

Una fábrica se ve así:

|0000000000| o |0000011001|

Una tubería representa las paredes, un 0 representa un trabajador y un 1 representa una máquina, por lo que la primera impresión de la fábrica siempre será |0000000000|.

Ejemplo

Entrada: 10

Salida:

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

Entrada: 5

Salida:

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

NOTA

El número de trabajadores despedidos es ALEATORIO: en mis ejemplos 1/5 chance, siempre habrá 2 trabajadores despedidos, pero su programa tiene que hacer esto al azar, a veces 1 y a veces 3, solo tienen 1/5 de posibilidades de ser despedidos.

Japt -R , 22 21 20 19 18 bytes

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

Intentalo

Explicación

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 bytes

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

Pruébalo en línea!

Sin 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 bytes

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

Pruébalo en línea!

Versión recursiva, 88 bytes.

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

Pruébalo en línea!

¿Cómo?

Comenzamos con k = s = '5000000000' .

En cada iteración:

• Obligamos a cada carácter i de s a un número, calculamos i módulo 5 , de modo que el 5 inicial se trata como un 0 , y realizamos aleatoriamente un OR bit a bit con 1 con la probabilidad esperada 1 / n , excepto en la primera iteración .

• El contador k se desplaza a la derecha en 3 bits. Paramos la recursión tan pronto como k = 0 , lo que da 10 iteraciones.

  Es importante tener en cuenta que 5000000000 es un poco más grande que un entero de 32 bits, por lo que se convierte implícitamente en 5000000000 & 0xFFFFFFFF = 705032704 justo antes de que ocurra el primer desplazamiento a nivel de bits. De ahí los siguientes pasos:

   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 bytes

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

Pruébalo en línea!

¿Cómo?

10⍴0 - Comience con 10 ceros.

⎕←' '~⍨⍕'|'⍵'|' - cada vez que imprima la matriz formateada,

?10⍴⍺- generar una matriz aleatoria con valores que van 1a la entrada,

⍺=- comparación de elementos sabios con la entrada. debe marcar 1/ entrada de los elementos, dando cada a 1/ entrada cada vez,

⍵+ - agregar a la matriz,

×- Signum. cero permanece cero, cualquier cosa mayor que uno vuelve a uno.

⍣10 - Repite 10 veces.

Retina , 30 bytes

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

Pruébalo en línea!

Me estoy divirtiendo mucho con la aleatoriedad en Retina ^^

Explicación

La primera etapa configura la cadena con la que trabajaremos:

.+
|¶10*$(*0¶

Reemplaza toda la entrada con |una nueva línea y luego 10 líneas que contienen tantos 0s como dice la entrada. El primer carácter en cada línea representará a un trabajador de la fábrica.

La siguiente etapa significa:

.                     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 primera línea de la cadena de trabajo contiene solo un |, que será el primer carácter impreso por cada iteración del bucle (siendo el primer carácter de la primera línea), y también se imprimirá al final de cada iteración (siendo el primero carácter de toda la cadena). El reemplazo nunca tendrá ningún efecto en esta línea porque no contiene ningún dígito.

Cada otra línea contiene ndígitos, por lo que hay un 1 en nposibilidad de convertir el primer carácter de la línea (que es el único significativo) en a 1.

PowerShell , 82 80 69 bytes

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

Pruébalo en línea!

Toma entrada $x. Crea una matriz de todos los ceros, los guarda $ay luego los repite muchas veces. Convenientemente, la fábrica es tan amplia como el valor de las iteraciones. Cada iteración, sacamos nuestra fábrica actual con "|$(-join$a)|", luego recorremos cada elemento de $a.

En el interior, estamos seleccionando el elemento actual $_que se ha -binutilizado, orya sea en 1función de la Randomposibilidad basada en la entrada $x. Por ejemplo, para la entrada 10, Get-Random -max 10oscilará entre 0y 9y será 0aproximadamente 1/10 del tiempo. Por lo tanto, con una !(...)envoltura Random, obtendremos una cantidad 1aproximada 1/inputde tiempo y la otra 1-1/inputcantidad de tiempo $_. Sí, esto a veces significa que estamos sobrescribiendo un 1con otro 1, pero está bien.

Esa matriz resultante se almacena de nuevo en $ala siguiente ronda. Todas las cadenas resultantes quedan en la tubería, y lo implícito Write-Outputen la finalización del programa nos da nuevas líneas de forma gratuita.

-2 bytes gracias a Veskah.
-11 bytes gracias a ASCII-only.

Perl 6 , 58 bytes

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

Pruébalo en línea!

+(1 > $_ * rand)genera un solo bit con la frecuencia requerida de 1s. xx 10replica esa expresión diez veces para producir una única instancia de fábrica como una lista de bits, y [~]une esa lista en una sola cadena. xx 9replica esa expresión generadora de cadenas de fábrica nueve veces, y luego [\~|]realiza una reducción triangular (que algunos otros lenguajes llaman "exploración") con stringwise u operador ~|, de modo que un trabajador despedido en una iteración anterior permanece activado en las posteriores.

Python 2 , 104 103 bytes

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

Pruébalo en línea!

Jalea , 22 bytes

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

Un programa completo que acepta el entero como una entrada de línea de comando e imprime la salida a STDOUT.
(Como enlace monádico, devuelve una lista de caracteres y enteros).

Pruébalo en línea!

¿Cómo?

Decide de manera efectiva en cada etapa si cada trabajador (incluidas las máquinas) pierde su trabajo (con una posibilidad de N), sin embargo, las máquinas se reemplazan por máquinas (usando OR lógico).

ẋ⁵ẋ€⁵¬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 bytes

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

Pruébalo en línea!

(Larga) explicación

Ejemplos de contenido de la pila se muestran en el camino. En cada paso, el contenido de la pila se muestra de abajo hacia arriba.

'|'    % 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 bytes

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

Pruébalo en línea!

+2 bytes para colocar la matriz dentro de la función, gracias a @Shaggy por señalar eso

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

Pruébalo en línea!

C (gcc) , 110 106 bytes

-4 bytes 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);}

Pruébalo en línea!

Itera a través de una lista de caracteres para cada ronda de reemplazos.

Sin 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 bytes

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

Perl 5 , 44 bytes

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

Pruébalo en línea!

05AB1E , 22 bytes

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

Pruébalo en línea!

Debería haber más espacio para jugar al golf.

• TÅ0 - Empuje una lista de 10 ceros.
• TF... - Haz esto 10 veces:
  • DJ - Duplicar el elemento actual y unirlo.
  • '|.ø=- Rodéelo con dos |sy imprima en STDOUT.
  • ITи - Repita la entrada 10 veces.
  • €L€Ω- Y para cada aparición, obtenga un elemento aleatorio de [1 ... N] . (Puede haber una función incorporada para esto que aún no he visto)
  • Θ- Presione 05AB1E truthified ™. Para cada uno, verifique si es igual a 1 .
  • s...~ - Lógico O el resultado por el elemento actual.

JavaScript, 83 bytes

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 bytes

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 bytes gracias a @ OlivierGrégoire , y -3 bytes más al convertir Java 8 a Java 10.

Explicación:

Pruébalo en línea.

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

Carbón , 30 29 27 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

⊞υ×χ0

Empuje una cadena de 10 0s a la lista vacía u.

Ｆχ

Repita el siguiente comando 10 veces.

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

Para cada carácter de la última cadena, repítalo n-1veces, agregue un 1y elija un carácter aleatorio de la cadena. Esto da la 1/nposibilidad de cambiar el personaje a a 1. El resultado es empujado a u.

Ｅυ⪫||ι

Mapee sobre la lista de cadenas, rodeando cada una de ellas |, luego imprima implícitamente cada una en su propia línea.

Python 3 , 132 bytes

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

Pruébalo en línea!

APL + WIN, 30 40 35 bytes

Perdí el bit sobre no espacios; (- arreglado y gracias a Uriel por -3 bytes

Solicita la entrada en pantalla del número

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

Explicación similar a la de 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 bytes

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

Sangrado para facilitar la lectura:

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

Aprovecha 2 puntos: las matrices de VBA pasarán por defecto a Base 0 (por lo que w(9)es lo mismo quew(0 to 9) ) y la creación de la matriz como larga la inicializará automáticamente a 0.

(De manera molesta, 20 bytes tienen un formato automático que VBA agrega pero que en realidad no se requiere: 19 espacios y un punto y coma)

Todavía no veo la respuesta para Ruby, así que:

Ruby , 92 bytes

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

Pruébalo en línea!

Ruby, 67 bytes

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

Creo que he engañado algunas cosas aquí. En primer lugar, esta función imprime la salida con comillas alrededor de cada línea, por ejemplo:

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 esto es inaceptable (dado que esto es ascii-art , ese es probablemente el caso), aquí hay una solución que imprime sin comillas para 70 bytes :

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

Explicación:

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

fusionar bucles guardados 5 bytes (nuevamente):

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

Ejecutar como tubería -nRo probarlo en línea .

edición 1: formato fijo y primera salida (sin cambios en el recuento de bytes gracias al golf adicional)
edición 2: golfó un byte más: después de la última impresión, ya no hay necesidad de despedir a nadie.

C # (compilador interactivo de Visual C #) , 131 bytes

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

Oye, al menos me até con Java.

Pruébalo en línea!