Wyzwanie

Pracownicy fabryczni są zwykle bardzo pracowici. Jednak ich prace są obecnie powszechnie zastępowane maszynami.

Musisz napisać program, który przyjmuje liczbę jako dane wejściowe. 10 razy wydrukuje fabrykę 10 pracowników. Za każdym razem każdy pracownik ma1/input szansę zostać „zwolniony” i zastąpiony przez maszynę.

Wejście

Liczba całkowita, pochodząca ze STDIN lub wywołania funkcji.

Wynik

10 przypadków w fabryce, z których każdy zatrudnia zwykle więcej pracowników.

Format wyjściowy - jak wydrukować fabrykę

Fabryka wygląda następująco:

|0000000000| lub |0000011001|

Rura reprezentuje ściany, 0 oznacza pracownika, a 1 oznacza maszynę, więc zawsze będzie pierwszy wydruk fabryki |0000000000|.

Przykład

Wejście: 10

Wynik:

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

Wejście: 5

Wynik:

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

UWAGA

Liczba zwolnionych pracowników to RANDOM - w moich przykładach 1/5 chancezawsze będą zwolnieni 2 pracownicy, ale twój program musi to zrobić losowo - czasami 1, a czasem 3 - mają tylko 1/5 szansy na zwolnienie.

Japt -R , 22 21 20 19 18 bajtów

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

Spróbuj

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Nie golfowany:

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 bajtów

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

Wypróbuj online!

Wersja rekurencyjna, 88 bajtów

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

Wypróbuj online!

W jaki sposób?

Zaczynamy od k = s = „5000000000” .

Przy każdej iteracji:

• Mamy przymusić każdy znak í z s do numeru, obliczyć i modulo 5 - tak, że prowadzący 5 jest traktowane jak 0 - losowo wykonać bitowym OR z 1 z oczekiwanego prawdopodobieństwa 1 / n , z wyjątkiem pierwszej iteracji .

• Licznik k jest przesunięty w prawo o 3 bity. Natychmiast zatrzymujemy rekurencję k = 0 , co daje 10 iteracji.

  Należy zauważyć, że 5000000000 jest nieco większa niż 32-bitowa liczba całkowita, więc jest domyślnie konwertowana na 5000000000 i 0xFFFFFFFF = 705032704 tuż przed wystąpieniem pierwszego przesunięcia bitowego. Stąd następujące kroki:

   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 bajtów

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

Wypróbuj online!

W jaki sposób?

10⍴0 - zacznij od 10 zer.

⎕←' '~⍨⍕'|'⍵'|' - za każdym razem drukuj sformatowaną tablicę,

?10⍴⍺- generuje losową tablicę z wartościami 1wejściowymi,

⍺=- porównanie elementów z danymi wejściowymi. powinien oznaczać 1/ wprowadzać elementy, podając za 1każdym razem wejście /,

⍵+ - dodaj do tablicy,

×- signum. zero pozostaje zerem, wszystko większe niż jeden wraca do jednego.

⍣10 - powtórz 10 razy.

Siatkówka , 30 bajtów

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

Wypróbuj online!

Mam dużo zabawy z przypadkowością w Retina ^^

Wyjaśnienie

Pierwszy etap konfiguruje ciąg znaków, z którym będziemy pracować:

.+
|¶10*$(*0¶

Zastępuje całe dane wejściowe |znakiem nowej linii, a następnie 10 wierszy zawierających tyle samo0 s, ile mówi dane wejściowe. Pierwszy znak w każdej linii będzie reprezentował pracownika fabryki.

Następny etap oznacza:

.                     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

Pierwszy wiersz ciągu roboczego zawiera tylko a |, który będzie pierwszym znakiem drukowanym przy każdej iteracji pętli (będącym pierwszym znakiem pierwszego wiersza), i będzie także drukowany na końcu każdej iteracji (będący pierwszym znak całego łańcucha). Zastąpienie nigdy nie będzie miało żadnego wpływu na tę linię, ponieważ nie zawiera żadnej cyfry.

Każda inna linia zawiera ncyfry, więc istnieje 1 nszansa na przekształcenie pierwszego znaku linii (który jest jedynym znaczącym) na znak 1.

PowerShell , 82 80 69 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe $x. Tworzy tablicę wszystkich zer, zapisuje to w, $aa następnie wielokrotnie zapętla. Dogodnie fabryka jest tak szeroka, jak to warte iteracji. Przy każdej iteracji generujemy bieżącą fabrykę "|$(-join$a)|", a następnie przechodzimy przez każdy element $a.

Wewnątrz wybieramy bieżący element $_, który został -bopracowany oralbo 1na Randompodstawie szansy na podstawie danych wejściowych $x. Na przykład, do wprowadzania 10, Get-Random -max 10będzie w zakresie pomiędzy 0a 9i być 0w przybliżeniu 1/10-tej chwili. Zatem z !(...)zawijania Random, dostaniemy 1w przybliżeniu 1/inputilość czasu, a pozostałe 1-1/inputilości czasu dostaniemy $_. Tak, czasami oznacza to, że nadpisujemy 1inny 1, ale to w porządku.

Wynikowa tablica jest następnie zapisywana z powrotem do $anastępnej rundy. Wszystkie powstałe ciągi pozostają w potoku, a domniemane Write-Outputpo zakończeniu programu daje nam nowe wiersze za darmo.

-2 bajty dzięki Veskah.
-11 bajtów dzięki tylko ASCII.

Perl 6 , 58 bajtów

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

Wypróbuj online!

+(1 > $_ * rand)generuje pojedynczy bit z wymaganą częstotliwością 1s. xx 10replikuje to wyrażenie dziesięć razy, aby utworzyć pojedynczą instancję fabryki jako listę bitów, i [~]łączy tę listę w pojedynczy ciąg. xx 9dziewięć razy replikuje to wyrażenie generujące ciąg fabryczny, a następnie [\~|]wykonuje trójkątną redukcję (którą niektóre inne języki nazywają „skanowaniem”) za pomocą łańcucha lub operatora ~|, tak aby pracownik zwolniony w poprzedniej iteracji pozostał zwolniony w późniejszych.

Python 2 , 104 103 bajty

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

Wypróbuj online!

Galaretka , 22 bajty

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

Pełny program akceptujący liczbę całkowitą jako wejście wiersza poleceń i wypisujący dane wyjściowe do STDOUT.
(Jako monadyczny link zwraca listę znaków i liczb całkowitych.)

Wypróbuj online!

W jaki sposób?

Skutecznie decyduje na każdym etapie, czy każdy pracownik (w tym dowolne maszyny) straci pracę (z szansą jeden na N), jednak maszyny zostaną zastąpione maszynami (przy użyciu logicznej-LUB).

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

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

Wypróbuj online!

(Długie) wyjaśnienie

Przykładowa zawartość stosu jest pokazana po drodze. Na każdym kroku zawartość stosu wyświetlana jest od dołu do góry.

'|'    % 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 bajtów

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

Wypróbuj online!

+2 bajty za umieszczenie tablicy wewnątrz funkcji, dzięki @Shaggy za wskazanie tego

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

Wypróbuj online!

C (gcc) , 110 106 bajtów

-4 bajty od @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);}

Wypróbuj online!

Iteruje przez listę znaków dla każdej rundy zamiany.

Nie golfowany:

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 bajtów

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

Perl 5 , 44 bajtów

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

Wypróbuj online!

05AB1E , 22 bajty

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

Wypróbuj online!

Powinno być więcej miejsca na grę w golfa.

• TÅ0 - Wciśnij listę 10 zer.
• TF... - Zrób to 10 razy:
  • DJ - Zduplikuj bieżący element i dołącz do niego.
  • '|.ø=- Otocz go dwoma |si drukuj do STDOUT.
  • ITи - Powtórz wprowadzanie 10 razy.
  • €L€Ω- I dla każdego wystąpienia, zdobądź losowy element [1 ... N] . (Może być wbudowany w to, czego jeszcze nie widziałem)
  • Θ- Wciśnij 05AB1E trueified ™. Dla każdego sprawdź, czy jest równy 1 .
  • s...~ - Logiczny LUB wynik według bieżącego elementu.

JavaScript, 83 bajty

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 bajtów

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 bajtów dzięki @ OlivierGrégoire i -3 bajtów więcej poprzez konwersję Java 8 na Java 10.

Wyjaśnienie:

Wypróbuj 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

Węgiel drzewny , 30 29 27 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

⊞υ×χ0

Wciśnij ciąg 10 0s do pustej listy u.

Ｆχ

Powtórz następne polecenie 10 razy.

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

Dla każdego znaku ostatniego ciągu powtórz go n-1razy, dodaj a 1i wybierz losowy znak z ciągu. Daje to 1/nszansę na zmianę postaci na 1. Wynik jest wypychany do u.

Ｅυ⪫||ι

Zamapuj na liście ciągów, otaczając każdy z nich |, a następnie domyślnie wydrukuj każdy w osobnym wierszu.

Python 3 , 132 bajty

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

Wypróbuj online!

APL + WIN, 30 40 35 bajtów

Brakowało spacji o braku spacji; (- naprawiono & dzięki Urielowi za -3 bajty

Monity o wprowadzenie liczby na ekranie

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

Wyjaśnienie podobne do Uriela:

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

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

Wcięte dla łatwiejszego czytania:

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

Wykorzystuje 2 punkty: Tablice VBA będą domyślnie w(9)ustawione na Bazę 0 (tak samo jak w(0 to 9)), a utworzenie Tablicy jako Długiej automatycznie zainicjuje ją na 0.

(Irytujące jest to, że 20 bajtów to automatyczne formatowanie, które dodaje VBA, ale tak naprawdę nie jest wymagane - 19 spacji i jeden średnik)

Nie widzę jeszcze odpowiedzi dla Ruby, więc:

Rubin , 92 bajty

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

Wypróbuj online!

Rubin, 67 bajtów

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

Myślę, że oszukałem tutaj kilka rzeczy. Przede wszystkim funkcja drukuje dane wyjściowe z cudzysłowami wokół każdej linii, np .:

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

Jeśli jest to nie do przyjęcia (biorąc pod uwagę, że jest to ascii-art , prawdopodobnie tak jest), oto rozwiązanie, które drukuje bez cudzysłowów dla 70 bajtów :

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

Wyjaśnienie:

->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 bajtów

scalanie pętli zapisanych 5 bajtów (ponownie):

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

Uruchom jako potok z -nRlub spróbuj online .

edycja 1: poprawiono format i pierwsze wyjście (bez zmiany liczby bajtów dzięki dodatkowemu
golfowi ) edycja 2: grał w golfa jeszcze jeden bajt: po ostatnim wydrukowaniu nie trzeba już strzelać

C # (interaktywny kompilator Visual C #) , 131 bajtów

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

Hej, przynajmniej związałem się z Javą.

Wypróbuj online!