Herausforderung

Fabrikarbeiter sind normalerweise sehr fleißig. Ihre Arbeit wird heute jedoch häufig durch Maschinen ersetzt.

Sie müssen ein Programm schreiben, das eine Zahl als Eingabe verwendet. Es wird 10 Mal eine Fabrik mit 10 Arbeitern ausgedruckt. Jedes Mal hat jeder Arbeiter die 1/inputChance, entlassen und durch eine Maschine ersetzt zu werden.

Eingang

Eine Ganzzahl, die von STDIN oder einem Funktionsaufruf stammt.

Ausgabe

10 Fälle der Fabrik, jeder mit normalerweise mehr Arbeitern entlassen.

Ausgabeformat - So drucken Sie eine Fabrik

Eine Fabrik sieht so aus:

|0000000000| oder |0000011001|

Eine Pfeife repräsentiert die Wände, eine 0 repräsentiert einen Arbeiter und eine 1 repräsentiert eine Maschine, so dass der erste Druck der Fabrik immer sein wird |0000000000| .

Beispiel

Eingabe: 10

Ausgabe:

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

Eingabe: 5

Ausgabe:

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

HINWEIS

Die Anzahl der entlassenen Arbeiter ist ZUFÄLLIG - in meinen Beispielen 1/5 chancewürden immer 2 Arbeiter entlassen, aber Ihr Programm muss dies zufällig tun - manchmal 1 und manchmal 3 - sie haben nur 1/5 Chance, entlassen zu werden.

Japt -R , 22 21 20 19 18 Bytes

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

Versuch es

Erläuterung

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

Probieren Sie es 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`
`

Probieren Sie es online!

Rekursive Version, 88 Bytes

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

Probieren Sie es online!

Wie?

Wir beginnen mit k = s = '5000000000' .

Bei jeder Iteration:

• Wir zwingen jedes Zeichen i von s zu einer Zahl, berechnen i modulo 5 - so dass die führende 5 wie eine 0 behandelt wird - und führen zufällig ein bitweises ODER mit 1 mit der erwarteten Wahrscheinlichkeit 1 / n aus , mit Ausnahme der ersten Iteration .

• Der Zähler k ist um 3 Bits nach rechts verschoben. Wir stoppen die Rekursion, sobald k = 0 ist , was 10 Iterationen ergibt.

  Es ist wichtig zu beachten, dass 5000000000 geringfügig größer als eine 32-Bit-Ganzzahl ist. Daher wird sie unmittelbar vor der ersten bitweisen Verschiebung implizit in 5000000000 & 0xFFFFFFFF = 705032704 konvertiert . Daher die folgenden Schritte:

   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

Probieren Sie es online!

Wie?

10⍴0 - Beginnen Sie mit 10 Nullen.

⎕←' '~⍨⍕'|'⍵'|' - jedes Mal, wenn das formatierte Array gedruckt wird,

?10⍴⍺ - Erzeugen Sie ein zufälliges Array mit unterschiedlichen Werten 1 bis zur Eingabe ,

⍺=- Elementweiser Vergleich mit der Eingabe. sollte markieren 1/ Eingabe der Elemente, geben Sie jeweils ein1 / eingeben,

⍵+ - zum Array hinzufügen,

×- signum. Null bleibt Null, alles, was größer als Eins ist, kommt auf Eins zurück.

⍣10 - 10 mal wiederholen.

Netzhaut , 30 Bytes

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

Probieren Sie es online!

Ich habe viel Spaß mit Zufälligkeit in Retina ^^

Erläuterung

In der ersten Phase wird die Saite vorbereitet, mit der wir arbeiten werden:

.+
|¶10*$(*0¶

|Ersetzt die gesamte Eingabe durch eine neue Zeile und dann 10 Zeilen, die so viele enthalten0 s, wie die Eingabe . Das erste Zeichen in jeder Zeile steht für einen Arbeiter der Fabrik.

Die folgende Stufe bedeutet:

.                     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

Die erste Zeile der Arbeitszeichenfolge enthält nur a | , das das erste Zeichen ist, das von jeder Iteration der Schleife gedruckt wird (wobei es das erste Zeichen der ersten Zeile ist), und das auch am Ende jeder Iteration gedruckt wird (wobei es das erste ist) Zeichen der ganzen Zeichenkette). Die Ersetzung hat keine Auswirkung auf diese Zeile, da sie keine Ziffer enthält.

Jede andere Zeile enthält nZiffern, daher gibt es eine 1 n, um das erste Zeichen der Zeile (welches das einzig sinnvolle ist) in eine zu verwandeln 1.

PowerShell , 82 80 69 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe $x. Erstellt ein Array mit allen Nullen, speichert es in $aund wiederholt es dann so oft. Praktischerweise ist die Fabrik genauso breit wie es Iterationen wert ist. Jede Iteration, mit der wir unsere aktuelle Factory ausgeben "|$(-join$a)|", durchläuft dann jedes Element von $a.

Im Inneren wählen wir das aktuelle Element $_, das mit einem der beiden Elemente -bverknüpft wurde, basierend auf der Wahrscheinlichkeit basierend auf der Eingabe aus . Zum Beispiel für die Eingabe , liegt im Bereich zwischen und und seinem etwa 1 / 10tel der Zeit. Mit einem Wrapping von erhalten wir ungefähr die Zeit und die andere Zeit . Ja, dies bedeutet manchmal, dass wir eine mit einer anderen überschreiben , aber das ist in Ordnung.or1Random$x10Get-Random -max 10090!(...)Random11/input1-1/input$_11

Das resultierende Array wird dann $afür den nächsten Durchlauf zurückgespeichert. Alle resultierenden Zeichenfolgen Write-Outputverbleiben in der Pipeline, und der implizite Zeitpunkt des Programmabschlusses gibt uns kostenlose Zeilenumbrüche.

-2 Bytes dank Veskah.
-11 Bytes nur dank ASCII.

Perl 6 , 58 Bytes

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

Probieren Sie es online!

+(1 > $_ * rand)erzeugt ein einzelnes Bit mit der erforderlichen Frequenz von 1s. xx 10Repliziert diesen Ausdruck zehnmal, um eine einzelne Factory-Instanz als eine Liste von Bits zu erstellen, und [~]fügt diese Liste zu einer einzelnen Zeichenfolge hinzu. xx 9Repliziert diesen Factory-String-generierenden Ausdruck neun Mal und führt dann [\~|]eine dreieckige Reduktion (die in einigen anderen Sprachen als "Scan" bezeichnet wird) mit dem String oder Operator durch ~|, sodass ein Worker, der in einer früheren Iteration gefeuert wurde, in späteren Iterationen gefeuert bleibt.

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

Probieren Sie es online!

Jelly , 22 Bytes

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

Ein vollständiges Programm, das die Ganzzahl als Befehlszeileneingabe akzeptiert und die Ausgabe an STDOUT ausgibt.
(Als monadische Verknüpfung wird eine Liste von Zeichen und ganzen Zahlen zurückgegeben.)

Probieren Sie es online!

Wie?

Entscheidet in jeder Phase effektiv, ob jeder Arbeiter (einschließlich aller Maschinen) seinen Job verliert (mit einer Eins-in-N-Chance), jedoch werden Maschinen durch Maschinen ersetzt (mit logischem ODER).

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

Probieren Sie es online!

(Lange) Erklärung

Beispielstapelinhalte werden auf dem Weg gezeigt. Bei jedem Schritt wird der Stapelinhalt von unten nach oben angezeigt.

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

Probieren Sie es online!

+2 Byte für das Einfügen des Arrays in die Funktion, danke an @Shaggy für den Hinweis

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

Probieren Sie es online!

C (GCC) , 110 106 Bytes

-4 Bytes von @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);}

Probieren Sie es online!

Durchläuft eine Liste von Zeichen für jede Ersetzungsrunde.

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

Probieren Sie es online!

05AB1E , 22 Bytes

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

Probieren Sie es online!

Es sollte mehr Platz zum Golfen geben.

• TÅ0 - Schieben Sie eine Liste von 10 Nullen.
• TF... - Mach das 10 mal:
  • DJ - Duplizieren Sie das aktuelle Element und verbinden Sie es.
  • '|.ø=- Mit zwei |s umgeben und auf STDOUT drucken.
  • ITи - Wiederholen Sie die Eingabe 10 Mal.
  • €L€Ω- Und für jedes Vorkommen erhalten Sie ein zufälliges Element von [1 ... N] . (Möglicherweise gibt es eine integrierte Funktion, die ich noch nicht gesehen habe.)
  • Θ- 05AB1E truthified ™ drücken. Überprüfen Sie für jedes, ob es 1 entspricht .
  • s...~ - Logisch ODER das Ergebnis des aktuellen Elements.

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 dank @ OlivierGrégoire und -3 Bytes mehr durch die Konvertierung von Java 8 nach Java 10.

Erläuterung:

Probieren Sie es online aus.

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

Kohle , 30 29 27 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

⊞υ×χ0

Schieben Sie eine Zeichenfolge von 10 0s in die leere Liste u.

Ｆχ

Wiederholen Sie den nächsten Befehl 10 Mal.

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

Wiederholen Sie dies für jedes Zeichen der letzten Zeichenfolge, n-1fügen Sie ein hinzu 1und wählen Sie ein zufälliges Zeichen aus der Zeichenfolge aus. Dies gibt die 1/nMöglichkeit, den Charakter in a zu ändern 1. Das Ergebnis wird nach verschoben u.

Ｅυ⪫||ι

Ordnen Sie über der Liste der Zeichenfolgen, die jeweils mit umgeben sind |, implizit jeweils eine eigene Zeile zu.

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

Probieren Sie es online!

APL + WIN, 30 40 35 Bytes

Verpasste das bisschen über keine Leerzeichen; (- behoben & danke an Uriel für -3 Bytes

Fordert zur Eingabe der Nummer auf dem Bildschirm auf

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

Erklärung ähnlich der von 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

Zum leichteren Lesen eingerückt:

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

Nutzt 2 Punkte: VBA - Arrays wird standardmäßig auf Basis 0 (so w(9)ist die gleiche wie w(0 to 9)) und die Schaffung der Array als lange wird automatisch initialisieren es auf 0.

(Es ist ärgerlich, dass 20 Bytes automatisch formatiert werden, die VBA hinzufügt, aber nicht benötigt - 19 Leerzeichen und ein Semikolon)

Ich sehe noch keine Antwort für Ruby, also:

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

Probieren Sie es online!

Ruby, 67 Bytes

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

Ich glaube, ich habe hier ein paar Dinge betrogen. Zuallererst druckt diese Funktion die Ausgabe mit Anführungszeichen um jede Zeile, zB:

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

Wenn dies nicht akzeptabel ist (vorausgesetzt, dies ist ascii-art , was wahrscheinlich der Fall ist), ist hier eine Lösung, die 70 Bytes ohne Anführungszeichen ausgibt :

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

Erläuterung:

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

verschmelzen Loops wurden (erneut) 5 Bytes gespart:

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

Mit -nRoder als Pipe ausführen probieren Sie es online aus .

edit 1: festes format und erste ausgabe (keine änderung der
byteanzahl durch zusätzliches golfen ) edit 2: ein weiteres byte golfen: nach dem letzten druck muss niemand mehr gefeuert werden.

C # (Visual C # Interactive Compiler) , 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");}

Hey, zumindest habe ich mich mit Java beschäftigt.

Probieren Sie es online!