Sfida

Gli operai di solito lavorano molto duramente. Tuttavia, il loro lavoro viene ora comunemente sostituito con le macchine.

Devi scrivere un programma che accetta un numero come input. Stamperà una fabbrica di 10 lavoratori 10 volte. Ogni volta, ogni lavoratore ha la 1/inputpossibilità di essere "licenziato" e sostituito da una macchina.

Ingresso

Un numero intero, proveniente da STDIN o una chiamata di funzione.

Produzione

10 casse della fabbrica, ognuna con di solito più lavoratori licenziati.

Formato di output: come stampare una fabbrica

Una fabbrica si presenta così:

|0000000000| o |0000011001|

Un tubo rappresenta i muri, uno 0 rappresenta un lavoratore e un 1 rappresenta una macchina, quindi la prima stampa della fabbrica sarà sempre |0000000000|.

Esempio

Ingresso: 10

Produzione:

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

Ingresso: 5

Produzione:

|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

Il numero di lavoratori licenziati è CASUALE - nei miei esempi 1/5 chanceci sarebbero sempre 2 lavoratori licenziati, ma il tuo programma deve farlo in modo casuale - a volte 1 e a volte 3 - hanno solo 1/5 di probabilità di essere licenziati.

Japt -R , 22 21 20 19 18 byte

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

Provalo

Spiegazione

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 byte

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

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

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

Provalo online!

Versione ricorsiva, 88 byte

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

Provalo online!

Come?

Iniziamo con k = s = '5000000000' .

Ad ogni iterazione:

• Costringiamo ogni carattere i di s in un numero, calcoliamo i modulo 5 - in modo che il 5 iniziale sia trattato come uno 0 - ed eseguiamo casualmente un OR bit a bit con 1 con la probabilità attesa 1 / n , tranne sulla prima iterazione .

• Il contatore k viene spostato a destra di 3 bit. Interrompiamo la ricorsione non appena k = 0 , che fornisce 10 iterazioni.

  È importante notare che 5000000000 è leggermente più grande di un numero intero a 32 bit, quindi viene implicitamente convertito in 5000000000 e 0xFFFFFFFF = 705032704 appena prima che si verifichi il primo spostamento bit a bit. Quindi i seguenti passaggi:

   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 byte

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

Provalo online!

Come?

10⍴0 - Inizia con 10 zeri.

⎕←' '~⍨⍕'|'⍵'|' - ogni volta che stampa l'array formattato,

?10⍴⍺- genera un array casuale con valori che vanno 1in input,

⍺=- confronto a livello di elemento con l'input. dovrebbe contrassegnare 1/ inserire gli elementi, dando ogni a 1/ input ogni volta,

⍵+ - aggiungi all'array,

×- signum. zero rimane zero, tutto ciò che è maggiore di uno ritorna a uno.

⍣10 - ripetere 10 volte.

Retina , 30 byte

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

Provalo online!

Mi sto divertendo molto con casualità in Retina ^^

Spiegazione

Il primo stadio imposta la stringa con cui lavoreremo:

.+
|¶10*$(*0¶

Sostituisce l'intero input con |, una nuova riga e quindi 10 righe contenenti tutti gli 0s che dice l'input. Il primo carattere su ogni riga rappresenterà un lavoratore della fabbrica.

La seguente fase 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 prima riga della stringa di lavoro contiene solo a |, che sarà il primo carattere stampato da ogni iterazione del loop (essendo il primo carattere della prima riga) e verrà anche stampato alla fine di ogni iterazione (essendo il primo carattere di tutta la stringa). La sostituzione non avrà mai alcun effetto su questa riga perché non contiene cifre.

Ogni altra riga contiene ncifre, quindi esiste un 1 in grado ndi trasformare il primo carattere della riga (che è l'unico significativo) in a 1.

PowerShell , 82 80 69 byte

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

Provalo online!

Accetta input $x. Crea un array di tutti gli zeri, lo salva in $ae poi lo fa più volte. Convenientemente, la fabbrica è larga quanto vale le iterazioni. Ogni iterazione con cui produciamo la nostra attuale fabbrica "|$(-join$a)|", quindi eseguiamo il ciclo attraverso ogni elemento di $a.

Al suo interno stiamo selezionando l'elemento corrente $_che è stato -binizializzato orcon uno in 1base al Randomcaso in base all'input $x. Ad esempio, per l'ingresso 10, Get-Random -max 10varierà tra 0e 9ed essere 0di circa 1 / 10th del tempo. Quindi, con un !(...)avvolgimento di Random, avremo 1approssimativamente una 1/inputquantità di tempo e l'altra 1-1/inputquantità di tempo che avremo $_. Sì, questo a volte significa che stiamo sovrascrivendo un 1con un altro 1, ma va bene.

L'array risultante viene quindi archiviato nuovamente $aper il prossimo giro. Tutte le stringhe risultanti vengono lasciate sulla pipeline e l'implicito Write-Outputal completamento del programma ci dà nuove linee gratis.

-2 byte grazie alla Veskah.
-11 byte grazie solo a ASCII.

Perl 6 , 58 byte

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

Provalo online!

+(1 > $_ * rand)genera un singolo bit con la frequenza richiesta di 1s. xx 10replica quell'espressione dieci volte per produrre una singola istanza di fabbrica come un elenco di bit e [~]unisce tale elenco in una singola stringa. xx 9replica quell'espressione generatrice di stringhe di fabbrica nove volte, quindi [\~|]esegue una riduzione triangolare (che alcune altre lingue chiamano "scan") con lo stringally o l'operatore ~|, in modo che un lavoratore licenziato in una precedente iterazione rimanga licenziato in quelle successive.

Python 2 , 104 103 byte

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

Provalo online!

Gelatina , 22 byte

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

Un programma completo che accetta l'intero come input da riga di comando e stampa l'output su STDOUT.
(Come collegamento monadico restituisce un elenco di caratteri e numeri interi.)

Provalo online!

Come?

Decide efficacemente in ogni fase se ogni lavoratore (comprese le macchine) perde il proprio lavoro (con una possibilità in N), tuttavia le macchine vengono sostituite da macchine (usando OR logico).

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

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

Provalo online!

(Lunga) spiegazione

Il contenuto dello stack di esempio viene mostrato lungo la strada. Ad ogni passaggio, i contenuti dello stack vengono visualizzati dal basso verso l'alto.

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

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

Provalo online!

+2 byte per inserire l'array all'interno della funzione, grazie a @Shaggy per averlo sottolineato

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

Provalo online!

C (gcc) , 110 106 byte

-4 byte da @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);}

Provalo online!

Scorre l'elenco di caratteri per ogni round di sostituzioni.

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 byte

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

Perl 5 , 44 byte

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

Provalo online!

05AB1E , 22 byte

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

Provalo online!

Dovrebbe esserci più spazio per il golf.

• TÅ0 - Premere un elenco di 10 zeri.
• TF... - Fallo 10 volte:
  • DJ - Duplica l'elemento corrente e unisciti a esso.
  • '|.ø=- Circondalo con due |secondi e stampa su STDOUT.
  • ITи - Ripetere l'ingresso 10 volte.
  • €L€Ω- E per ogni occorrenza, ottieni un elemento casuale di [1 ... N] . (Potrebbe esserci un built-in per questo che non ho ancora visto)
  • Θ- Push 05AB1E truthified ™. Per ciascuno, controlla se è uguale a 1 .
  • s...~ - Logico O il risultato dell'elemento corrente.

JavaScript, 83 byte

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 byte

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 byte grazie a @ OlivierGrégoire e -3 più byte convertendo Java 8 in Java 10.

Spiegazione:

Provalo 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

Carbone , 30 29 27 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

⊞υ×χ0

Spingi una stringa di 10 0 s nell'elenco vuoto u.

Ｆχ

Ripeti il ​​comando successivo 10 volte.

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

Per ogni carattere dell'ultima stringa, ripetilo n-1volte, aggiungi a 1e scegli un carattere casuale dalla stringa. Questo dà la 1/npossibilità di cambiare il personaggio in a 1. Il risultato viene spinto au .

Ｅυ⪫||ι

Mappa sopra l'elenco delle stringhe, circondandole ciascuna |, quindi stampa implicitamente ciascuna sulla propria riga.

Python 3 , 132 byte

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

Provalo online!

APL + WIN, 30 40 35 byte

Mancava il bit per nessuno spazio; (- risolto e grazie a Uriel per -3 byte

Richiede l'immissione dello schermo del numero

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

Spiegazione simile a quella di 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 byte

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

Rientrato per una lettura più semplice:

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

Sfrutta 2 punti: gli array VBA passeranno automaticamente alla Base 0 (quindi w(9)è uguale aw(0 to 9) ) e la creazione dell'array come Long lo inizializzerà automaticamente su 0.

(Stranamente, 20 byte si formattano automaticamente con l'aggiunta di VBA ma non sono necessari - 19 spazi e un punto e virgola)

Non vedo ancora la risposta per Ruby, quindi:

Rubino , 92 byte

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

Provalo online!

Rubino, 67 byte

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

Penso di aver imbrogliato alcune cose qui. Prima di tutto, questa funzione stampa l'output con virgolette attorno a ciascuna riga, ad esempio:

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 questo è inaccettabile (dato che si tratta di ascii-art , è probabilmente il caso), ecco una soluzione che stampa senza virgolette per 70 byte :

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

Spiegazione:

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

l'unione di loop ha salvato 5 byte (di nuovo):

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

Esegui come pipe -nRo provalo online .

modifica 1: formato fisso e primo output (nessuna modifica nel conteggio dei byte grazie al golfing aggiuntivo)
modifica 2: golf un altro byte: dopo l'ultima stampa, non è più necessario sparare a nessuno.

C # (compilatore interattivo Visual C #) , 131 byte

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

Ehi, almeno ho legato con Java.

Provalo online!