Meydan okuma

Fabrika işçileri genellikle çok çalışkan. Ancak, işleri artık yaygın olarak makinelerle değiştiriliyor.

Bir sayıyı girdi olarak alan bir program yazmanız gerekir. 10 işçiden oluşan bir fabrikayı 10 kez basacaktır. Her seferinde her çalışanın 1/input'kovulma' ve bir makine ile değiştirilme şansı vardır .

Giriş

STDIN veya bir işlev çağrısından gelen bir tam sayı.

Çıktı

10 vaka fabrika, her biri genellikle daha fazla işçi ile ateş.

Çıktı biçimi - fabrikada nasıl yazdırılır

Bir fabrika şöyle görünür:

|0000000000| veya |0000011001|

Bir boru duvarları, 0 bir işçiyi ve 1 bir makineyi temsil eder, bu nedenle fabrikanın ilk baskısı her zaman olacaktır |0000000000|.

Misal

Giriş: 10

Çıktı:

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

Giriş: 5

Çıktı:

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

NOT

İşten atılan işçi sayısı RANDOM'dur - benim örneklerimde 1/5 chanceher zaman 2 işçinin işten çıkarılması gerekirdi, ancak programınız bunu rastgele yapmak zorunda - bazen 1 ve bazen 3 - sadece 1/5 işten kovulma şansı var.

Japt -R , 22 21 20 19 18 bayt

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

Dene

açıklama

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 bayt

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

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

Özyinelemeli sürüm, 88 bayt

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

Çevrimiçi deneyin!

Nasıl?

Biz başlamak k = s = '5000000000' .

Her yinelemede:

• Biz her bir karakteri zorlamak i arasında s bir dizi, hesaplamak i 5 modulo lider böylece - 5 bir benzeri tedavi edilir 0 - ve rasgele bir bit yerine OR 1 beklenen bir olasılık ile 1 / n , birinci tekrar hariç .

• Sayaç k 3 bit ile sağ kaydırılır. Özyinelemeyi , 10 yineleme veren k = 0 olur olmaz durdururuz .

  5000000000'in 32 bitlik bir tam sayıdan biraz daha büyük olduğuna dikkat etmek önemlidir , bu nedenle ilk bitsel kaydırma gerçekleşmeden hemen önce örtülü olarak 5000000000 & 0xFFFFFFFF = 705032704'e dönüştürülür . Bu nedenle aşağıdaki adımlar:

   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 bayt

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

Çevrimiçi deneyin!

Nasıl?

10⍴0 - 10 sıfır ile başlayın.

⎕←' '~⍨⍕'|'⍵'|' - biçimlendirilmiş diziyi her yazdırdığınızda,

?10⍴⍺- 1girişe kadar değişen değerlerle rastgele bir dizi oluşturmak ,

⍺=- girişle eleman bazında karşılaştırma. 1elemanların işaretlenmesi / girilmesi, her bir a 1/ girişinin her seferinde verilmesi ,

⍵+ - diziye ekleme,

×- işaret. sıfır sıfır kalır, birden büyük her şey bire geri döner.

⍣10 - 10 kez tekrarlayın.

Retina , 30 bayt

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

Çevrimiçi deneyin!

Retina'da rasgele bir sürü eğleniyorum ^^

açıklama

İlk aşama, üzerinde çalışacağımız dizeyi kurar:

.+
|¶10*$(*0¶

Girdinin tamamını |bir satırsonu ve ardından 10 satır içeren0 girdinin söylediği kadar s . Her satırdaki ilk karakter fabrikanın bir işçisini temsil edecektir.

Aşağıdaki aşama şu anlama gelir:

.                     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

Çalışma dizesinin ilk satırı yalnızca bir | , ilmekin her yinelemesi tarafından basılan ilk karakter olacak (ilk satırın ilk karakteri olacak) ve her yinelemenin sonunda (ilk olarak tüm dizenin karakteri). Değişimin bu satır üzerinde hiçbir etkisi olmaz, çünkü herhangi bir rakam içermez.

Diğer satırlar nrakam içerir , bu nedenle satırın nilk karakterini (tek anlamlı olan) a'ya dönüştürme şansı 1'dir 1.

PowerShell , 82 80 69 bayt

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

Çevrimiçi deneyin!

Girdi alır $x. Tüm sıfırlardan oluşan bir dizi oluşturur, bunu kaydeder $ave birçok kez döngüye alır. Uygun olarak, fabrika iterations değerinde olduğu kadar geniş. Her iterasyon, biz mevcut fabrika çıkışı ile"|$(-join$a)|" , sonra her öğeyi döngü $a.

İçeride $_, -bgirdiye dayalı bir şansa dayanarak, orikisinden biri olan mevcut öğeyi seçiyoruz . Örneğin, giriş için , arasında değişir ve ve olmak süresi yaklaşık 1 / 10'idir. Böylece, bir sargı ile yaklaşık bir süre ve diğer bir süre alacağız . Evet, bu bazen bir1Random$x10Get-Random -max 10090!(...)Random11/input1-1/input$_1 başkasının1 , ancak bu iyi.

Sonuçta elde edilen dizi daha sonra bir $asonraki gidiş için geri kaydedilir . Ortaya çıkan tüm dizeler ardışık düzende ve örtük olarak kalırWrite-Output program tamamlandığında olarak bize ücretsiz satırlar verilir.

Veskah sayesinde -2 bayt.
Yalnızca ASCII sayesinde -11 bayt.

Perl 6 , 58 bayt

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

Çevrimiçi deneyin!

+(1 > $_ * rand) gerekli frekansta tek bir bit üretir 1 s . xx 10bitler listesi olarak tek bir fabrika örneği oluşturmak için bu ifadeyi on kez çoğaltır ve [~]bu listeyi tek bir dizeye ekler. xx 9fabrika dizesi üreten ifadeyi dokuz kez çoğaltır ve daha sonra [\~|], diğer bir dize veya işleçle üçgen şeklinde bir azalma (diğer bazı diller "tarama" olarak adlandırılır) yapar ~|, böylece daha önceki bir yinelemede çalışan bir işçinin daha sonra yinelenmesi gerekir.

Python 2 , 104103 bayt

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

Çevrimiçi deneyin!

Jöle , 22 bayt

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

Tamsayıyı komut satırı girişi olarak kabul eden ve çıktıyı STDOUT'a yazdıran tam bir program.
(Monadik bir bağlantı olarak bir karakter ve tamsayı listesi döndürür.)

Çevrimiçi deneyin!

Nasıl?

Her bir işçinin (herhangi bir makine dahil) işini kaybedip kaybetmediğine (N şansı bir olan) her aşamada etkili bir şekilde karar verir, ancak makineler makinelerle değiştirilir (mantıksal-VEYA kullanılarak).

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

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

Çevrimiçi deneyin!

(Uzun) açıklama

Örnek yığın içeriği yol boyunca gösterilir. Her adımda, yığın içeriği aşağıdan yukarıya gösterilir.

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

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

Çevrimiçi deneyin!

Diziyi işlevin içine koymak için +2 bayt, bunu işaret ettiği için @Shaggy sayesinde

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

Çevrimiçi deneyin!

C (gcc) , 110 106 bayt

@Ceilingcat sitesinden -4 bayt

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

Çevrimiçi deneyin!

Her değiştirme turu için bir karakter listesi üzerinden yinelenir.

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 bayt

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

Perl 5 , 44 bayt

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

Çevrimiçi deneyin!

05AB1E , 22 bayt

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

Çevrimiçi deneyin!

Golf için biraz daha yer olmalı.

• TÅ0 - 10 sıfırlık bir listeye basın.
• TF... - Bunu 10 kez yapın:
  • DJ - Geçerli öğeyi çoğalt ve katıl.
  • '|.ø= - İki ile çevreleyin | s ve STDOUT'a yazdırın.
  • ITи - Girişi 10 kez tekrarlayın.
  • €L€Ω- Ve her bir olay için rastgele bir [1 ... N] öğesi edinin . (Bunun için henüz görmediğim bir yerleşik olabilir)
  • Θ- 05AB1E truthified ™ 'i itin. Her biri için, eşit olup olmadığını kontrol edin 1 .
  • s...~ - Mantıksal VEYA geçerli öğenin sonucu.

JavaScript, 83 bayt

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 bayt

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

@ OlivierGrégoire sayesinde -18 bayt ve Java 8'i Java 10'a dönüştürerek -3 bayt daha.

Açıklama:

Çevrimiçi deneyin.

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

Kömür , 30 29 27 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

⊞υ×χ0

0Boş listeye 10 saniyelik bir dize itin u.

Ｆχ

Bir sonraki komutu 10 kez tekrarlayın.

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

Son dizenin her karakteri için bu süreyi tekrarlayın n-1, a ekleyin 1ve dizeden rastgele bir karakter seçin. Bu 1/n, karakteri bir1 . Sonuç şuraya gönderilir u.

Ｅυ⪫||ι

Her biri ile çevrelenen dizeler listesi üzerinde eşleyin |, ardından her birini kendi satırına örtülü olarak yazdırın.

Python 3 , 132 bayt

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

Çevrimiçi deneyin!

APL + WIN, 30 40 35 bayt

Boşluk bırakma konusunda biraz cevapsız; (- sabit ve -3 bayt için Uriel'e teşekkürler)

Sayının ekran girişi için bilgi istemleri

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

Uriel ile benzer açıklama:

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

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

Daha kolay okuma için girintili:

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

2 noktadan yararlanır: VBA Dizileri varsayılan olarak Base 0'a (yani w(9) aynıdırw(0 to 9) ) olur ve Diziyi Long olarak oluşturmak otomatik olarak 0 değerine başlar.

(Can sıkıcı bir şekilde, 20 bayt, VBA'nın eklediği ancak aslında gerekli olmayan otomatik biçimlendirmedir - 19 boşluk ve bir noktalı virgül)

Henüz Ruby'nin cevabını göremiyorum, bu yüzden:

Ruby , 92 bayt

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

Çevrimiçi deneyin!

Ruby, 67 bayt

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

Sanırım burada birkaç şey aldattım. Her şeyden önce, bu işlev çıktıyı her satırın çevresinde tırnak işaretleri ile yazdırır, örneğin:

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

Bu kabul edilemezse (bunun ascii-art olduğu düşünülürse , muhtemelen durum budur), işte 70 bayt için tırnak işaretleri olmadan yazdıran bir çözüm :

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

Açıklama:

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

birleştirme döngüleri 5 bayt kurtardı (tekrar):

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

Pipo ile çalıştırın -nRveya çevrimiçi deneyin .

edit 1: sabit format ve ilk çıkış (ek golf sayesinde bayt sayısında değişiklik yok)
edit 2: bir bayt daha Golf : Son baskıdan sonra, kimseyi ateşlemeye gerek yok.

C # (Visual C # Etkileşimli Derleyici) , 131 bayt

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, en azından Java ile bağladım.

Çevrimiçi deneyin!