Desafio

Trabalhadores de fábrica são geralmente muito trabalhadores. No entanto, o trabalho deles agora está sendo substituído por máquinas.

Você precisa escrever um programa que aceite um número como entrada. Ele imprimirá uma fábrica de 10 trabalhadores 10 vezes. Toda vez, cada trabalhador tem a 1/inputchance de ser demitido e substituído por uma máquina.

Entrada

Um número inteiro, proveniente de STDIN ou de uma chamada de função.

Resultado

10 casos da fábrica, cada um com geralmente mais trabalhadores demitidos.

Formato de saída - como imprimir uma fábrica

Uma fábrica fica assim:

|0000000000| ou |0000011001|

Um tubo representa as paredes, um 0 representa um trabalhador e um 1 representa uma máquina; portanto, a primeira impressão da fábrica será sempre |0000000000|.

Exemplo

Entrada: 10

Resultado:

|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

Resultado:

|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

O número de trabalhadores demitidos é ALEATÓRIO - nos meus exemplos 1/5 chance, sempre haveria 2 trabalhadores demitidos, mas seu programa precisa fazer isso aleatoriamente - às vezes 1 e às vezes 3 - eles têm apenas 1/5 de chance de serem demitidos.

Japt -R , 22 21 20 19 18 bytes

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

Tente

Explicação

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

Experimente online!

Ungolfed:

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

Experimente online!

Versão recursiva, 88 bytes

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

Experimente online!

Quão?

Começamos com k = s = '5000000000' .

Em cada iteração:

• Coagimos cada caractere i de s a um número, calculamos o módulo 5 - para que o 5 inicial seja tratado como um 0 - e executamos aleatoriamente um OR bit a bit com 1 com a probabilidade esperada 1 / n , exceto na primeira iteração .

• O contador k é deslocado à direita em 3 bits. Paramos a recursão assim que k = 0 , o que fornece 10 iterações.

  É importante observar que 5000000000 é um pouco maior que um número inteiro de 32 bits; portanto, é convertido implicitamente em 5000000000 & 0xFFFFFFFF = 705032704 imediatamente antes da primeira mudança bit a bit. Daí as seguintes etapas:

   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

Experimente online!

Quão?

10⍴0 - comece com 10 zeros.

⎕←' '~⍨⍕'|'⍵'|' - sempre que imprimir a matriz formatada,

?10⍴⍺- gerar uma matriz aleatória com valores que variam 1de entrada,

⍺=- comparação elemento a elemento com a entrada. deve marcar 1/ entrada dos elementos, dando a cada 1entrada a / toda vez,

⍵+ - adicione à matriz,

×- signum. zero permanece zero, qualquer coisa maior que um volta para um.

⍣10 - repita 10 vezes.

Retina , 30 bytes

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

Experimente online!

Estou me divertindo muito com a aleatoriedade na Retina ^^

Explicação

A primeira etapa define a string com a qual trabalharemos:

.+
|¶10*$(*0¶

Ele substitui toda a entrada por |uma nova linha e, em seguida, 10 linhas contendo tantos 0s quanto a entrada indica. O primeiro caractere em cada linha representará um trabalhador da fábrica.

O seguinte estágio 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

A primeira linha da sequência de trabalho contém apenas a |, que será o primeiro caractere impresso por cada iteração do loop (sendo o primeiro caractere da primeira linha) e também será impresso no final de cada iteração (sendo o primeiro caractere de toda a cadeia). A substituição nunca terá efeito nesta linha porque não contém nenhum dígito.

Cada outra linha contém ndígitos; portanto, há 1 em nchance de transformar o primeiro caractere da linha (que é o único significativo) em um 1.

PowerShell , 82 80 69 bytes

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

Experimente online!

Recebe entrada $x. Cria uma matriz de todos os zeros, salva esses dados $ae os repete várias vezes. Convenientemente, a fábrica é tão ampla quanto vale as iterações. A cada iteração, produzimos nossa fábrica atual e "|$(-join$a)|", em seguida, percorremos cada elemento de $a.

Dentro, estamos selecionando o elemento atual $_que foi -binarado orcom 1base na Randomchance baseada na entrada $x. Por exemplo, para a entrada 10, Get-Random -max 10vai variar entre 0e 9e seja0 aproximadamente 1/10 do tempo. Assim, com o !(...)empacotamento de Random, obteremos 1aproximadamente uma 1/inputquantidade de tempo e a outra 1-1/inputquantidade de tempo $_. Sim, isso às vezes significa que estamos substituindo um 1por outro 1, mas tudo bem.

Essa matriz resultante é então armazenada de volta $apara a próxima rodada. Todas as seqüências resultantes são deixadas no pipeline e o implícito Write-Outputna conclusão do programa nos fornece novas linhas de graça.

-2 bytes graças ao Veskah.
-11 bytes, graças apenas ao ASCII.

Perl 6 , 58 bytes

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

Experimente online!

+(1 > $_ * rand)gera um único bit com a frequência necessária de 1s. xx 10replica essa expressão dez vezes para produzir uma única instância de fábrica como uma lista de bits e [~]une essa lista em uma única sequência. xx 9replica essa expressão geradora de cadeia de fábrica nove vezes e, em seguida, [\~|]realiza uma redução triangular (que alguns outros idiomas chamam de "varredura") com o operador ou a cadeia de caracteres ~|, para que um trabalhador acionado em uma iteração anterior permaneça acionado nas versões 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

Experimente online!

Gelatina , 22 bytes

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

Um programa completo que aceita o número inteiro como entrada de linha de comando e imprime a saída em STDOUT.
(Como um link monádico, ele retorna uma lista de caracteres e números inteiros.)

Experimente online!

Quão?

Decide efetivamente em cada estágio se cada trabalhador (incluindo qualquer máquina) perde seu emprego (com uma chance em N), no entanto, as máquinas são substituídas 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

Experimente online!

Explicação (longa)

Exemplo de conteúdo da pilha é mostrado ao longo do caminho. Em cada etapa, o conteúdo da pilha é mostrado de baixo para cima.

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

Experimente online!

+2 bytes para colocar a matriz dentro da função, graças a @Shaggy por apontar isso

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

Experimente online!

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

Experimente online!

Repete uma lista de caracteres para cada rodada de substituições.

Ungolfed:

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

Experimente online!

05AB1E , 22 bytes

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

Experimente online!

Deveria haver mais espaço para jogar golfe.

• TÅ0 - Empurre uma lista de 10 zeros.
• TF... - Faça isso 10 vezes:
  • DJ - Duplique o item atual e junte-se a ele.
  • '|.ø= - Cercá-lo com dois | imprima em STDOUT.
  • ITи - Repita a entrada 10 vezes.
  • €L€Ω- E para cada ocorrência, obtenha um elemento aleatório de [1 ... N] . (Pode haver um built-in para isso que eu ainda não vi)
  • Θ- Pressione 05AB1E truthified ™. Para cada, verifique se é igual a 1 .
  • s...~ - Lógico OU o resultado pelo item atual.

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 graças a @ OlivierGrégoire , e mais -3 bytes ao converter o Java 8 em Java 10.

Explicação:

Experimente online.

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

Carvão , 30 29 27 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

⊞υ×χ0

Empurre uma sequência de 10 0s para a lista vazia u.

Ｆχ

Repita o próximo comando 10 vezes.

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

Para cada caractere da última string, repita-a n-1vezes, adicione 1ae escolha um caractere aleatório da string. Isso dá a 1/nchance de mudar o personagem para a 1. O resultado é enviado para u.

Ｅυ⪫||ι

Mapeie a lista de cadeias de caracteres, envolvendo cada uma delas |e imprima implicitamente cada uma em sua própria linha.

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

Experimente online!

APL + WIN, 30 40 35 bytes

Perdeu o bit sobre nenhum espaço; (- fixo & graças a Uriel por -3 bytes

Solicita a entrada na tela do número

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

Explicação semelhante à 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

Recuado para facilitar a leitura:

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

Aproveita 2 pontos: as matrizes VBA serão padronizadas como Base 0 (assim w(9)é o mesmo quew(0 to 9) ) e a criação da matriz como um longo inicializará automaticamente para 0.

(Irritantemente, 20 bytes são formatação automática que o VBA adiciona, mas não é realmente necessário - 19 espaços e um ponto e vírgula)

Ainda não vejo resposta para Ruby, então:

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

Experimente online!

Ruby, 67 bytes

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

Eu acho que trapacei algumas coisas aqui. Antes de tudo, essa função imprime a saída entre aspas em cada linha, por exemplo:

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

Se isso é inaceitável (dado que é arte-ASCII , provavelmente esse é o caso), aqui está uma solução que imprime sem aspas por 70 bytes :

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

Explicação:

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

a mesclagem de loops salvou 5 bytes (novamente):

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

Execute como pipe -nRou experimente online .

edit 1: formato fixo e primeira saída (sem alteração na contagem de bytes graças ao golfe adicional)
edit 2: golf mais um byte: após a última impressão, não é mais necessário disparar ninguém.

C # (compilador interativo do 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");}

Ei, pelo menos eu amarrei com Java.

Experimente online!