Thử thách

Công nhân nhà máy thường rất chăm chỉ. Tuy nhiên, công việc của họ hiện đang được thay thế bằng máy móc.

Bạn phải viết một chương trình lấy một số làm đầu vào. Nó sẽ in ra một nhà máy gồm 10 công nhân 10 lần. Mỗi lần, mỗi công nhân có 1/inputcơ hội bị 'sa thải' và được thay thế bằng một cái máy.

Đầu vào

Một số nguyên, đến từ STDIN hoặc gọi hàm.

Đầu ra

10 trường hợp của nhà máy, mỗi trường hợp thường có nhiều công nhân bị sa thải.

Định dạng đầu ra - cách in nhà máy

Một nhà máy trông như thế này:

|0000000000| hoặc là |0000011001|

Một ống đại diện cho các bức tường, 0 đại diện cho một công nhân và 1 đại diện cho một máy móc, vì vậy bản in đầu tiên của nhà máy sẽ luôn luôn là |0000000000|.

Thí dụ

Đầu vào: 10

Đầu ra:

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

Đầu vào: 5

Đầu ra:

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

GHI CHÚ

Số công nhân bị sa thải là RANDOM - trong ví dụ của tôi 1/5 chancesẽ luôn có 2 công nhân bị sa thải nhưng chương trình của bạn phải thực hiện điều này một cách ngẫu nhiên - đôi khi 1 và đôi khi 3 - họ chỉ có 1/5 cơ hội bị sa thải.

Japt -R , 22 21 20 19 18 byte

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

Thử nó

Giải trình

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

Hãy thử trực tuyến!

Ung dung:

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

Hãy thử trực tuyến!

Phiên bản đệ quy, 88 byte

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi bắt đầu với k = s = '5000000000' .

Ở mỗi lần lặp:

• Chúng tôi ép buộc mỗi ký tự i của s thành một số, tính i modulo 5 - sao cho số 5 đứng đầu được coi là 0 - và thực hiện ngẫu nhiên một bit HOẶC với 1 với xác suất dự kiến 1 / n , ngoại trừ lần lặp đầu tiên .

• Bộ đếm k được dịch chuyển phải 3 bit. Chúng tôi dừng đệ quy ngay khi k = 0 , đưa ra 10 lần lặp.

  Điều quan trọng cần lưu ý là 5000000000 lớn hơn một chút so với số nguyên 32 bit, do đó, nó được chuyển đổi hoàn toàn thành 5000000000 & 0xFFFFFFFF = 705032704 ngay trước khi xảy ra dịch chuyển bitwise đầu tiên. Do đó các bước sau:

   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

Hãy thử trực tuyến!

Làm sao?

10⍴0 - bắt đầu với 10 số không.

⎕←' '~⍨⍕'|'⍵'|' - mỗi lần in mảng được định dạng,

?10⍴⍺- tạo một mảng ngẫu nhiên với các giá trị khác nhau 1cho đầu vào,

⍺=- so sánh yếu tố khôn ngoan với đầu vào. nên đánh dấu 1/ đầu vào của các phần tử, cho mỗi a 1/ đầu vào mỗi lần,

⍵+ - thêm vào mảng,

×- dấu hiệu. không ở lại không, bất cứ điều gì lớn hơn một trở lại một.

⍣10 - lặp lại 10 lần.

Võng mạc , 30 byte

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

Hãy thử trực tuyến!

Tôi có rất nhiều niềm vui với sự ngẫu nhiên ở Retina ^^

Giải trình

Giai đoạn đầu tiên thiết lập chuỗi chúng ta sẽ làm việc với:

.+
|¶10*$(*0¶

Nó thay thế toàn bộ đầu vào bằng |, một dòng mới và sau đó 10 dòng chứa nhiều 0s như đầu vào nói. Ký tự đầu tiên trên mỗi dòng sẽ đại diện cho một công nhân của nhà máy.

Giai đoạn sau có nghĩa là:

.                     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

Dòng đầu tiên của chuỗi làm việc chỉ chứa a |, sẽ là ký tự đầu tiên được in bởi mỗi lần lặp của vòng lặp (là ký tự đầu tiên của dòng đầu tiên) và cũng sẽ được in ở cuối mỗi lần lặp (là lần đầu tiên ký tự của toàn chuỗi). Sự thay thế sẽ không bao giờ có bất kỳ ảnh hưởng nào đến dòng này vì nó không chứa bất kỳ chữ số nào.

Mỗi dòng khác chứa các nchữ số, do đó, có 1 ncơ hội để biến ký tự đầu tiên của dòng (là ký tự duy nhất có ý nghĩa) thành a 1.

PowerShell , 82 80 69 byte

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

Hãy thử trực tuyến!

Đưa đầu vào $x. Tạo một mảng gồm tất cả các số không, lưu nó vào $avà sau đó lặp lại nhiều lần. Thuận tiện, nhà máy chỉ rộng như nó được lặp lại giá trị. Mỗi lần lặp, chúng tôi xuất nhà máy hiện tại của chúng tôi với "|$(-join$a)|", sau đó lặp qua từng phần tử của $a.

Bên trong chúng ta chọn phần tử hiện hành $_đã được -binary- ored với một trong hai 1dựa trên Randomcơ hội dựa trên đầu vào $x. Ví dụ, đối đầu vào 10, Get-Random -max 10sẽ nằm trong khoảng giữa 0và 9và có 0khoảng 1 / 10th của thời điểm đó. Do đó, với việc !(...)gói Random, chúng tôi sẽ có được 1khoảng 1/inputthời gian và 1-1/inputkhoảng thời gian khác chúng tôi sẽ nhận được $_. Vâng, điều này đôi khi có nghĩa là chúng ta ghi đè lên một cái 1khác 1, nhưng điều đó tốt.

Mảng kết quả đó sau đó được lưu trữ trở lại $acho vòng tiếp theo. Tất cả các chuỗi kết quả được để lại trên đường ống và ẩn Write-Outputkhi hoàn thành chương trình cung cấp cho chúng tôi các dòng mới miễn phí.

-2 byte nhờ Veskah.
-11 byte chỉ nhờ ASCII.

Perl 6 , 58 byte

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

Hãy thử trực tuyến!

+(1 > $_ * rand)tạo ra một bit đơn với tần số yêu cầu 1là s. xx 10sao chép biểu thức đó mười lần để tạo ra một cá thể nhà máy duy nhất dưới dạng một danh sách các bit và [~]nối danh sách đó thành một chuỗi. xx 9sao chép biểu thức tạo chuỗi nhà máy đó chín lần, và sau đó [\~|]thực hiện giảm tam giác (mà một số ngôn ngữ khác gọi là "quét") bằng toán tử chuỗi hoặc toán tử ~|, để một công nhân được bắn trong lần lặp trước đó vẫn bị bắn trong các lần lặp sau.

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

Hãy thử trực tuyến!

Thạch , 22 byte

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

Một chương trình đầy đủ chấp nhận số nguyên dưới dạng đầu vào dòng lệnh và in đầu ra thành STDOUT.
(Là một liên kết đơn, nó trả về một danh sách các ký tự và số nguyên.)

Hãy thử trực tuyến!

Làm sao?

Quyết định hiệu quả ở từng giai đoạn nếu mỗi công nhân (bao gồm bất kỳ máy nào) mất việc (với cơ hội N trong một), tuy nhiên máy được thay thế bằng máy (sử dụng logic-OR).

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

Hãy thử trực tuyến!

(Dài) giải thích

Ví dụ nội dung ngăn xếp được hiển thị trên đường đi. Ở mỗi bước, nội dung ngăn xếp được hiển thị từ dưới lên trên.

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

Hãy thử trực tuyến!

+2 byte để đặt mảng bên trong hàm, cảm ơn @Shaggy đã chỉ ra điều đó

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

Hãy thử trực tuyến!

C (gcc) , 110 106 byte

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

Hãy thử trực tuyến!

Lặp lại thông qua một danh sách các ký tự cho mỗi vòng thay thế.

Ung dung:

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

Hãy thử trực tuyến!

05AB1E , 22 byte

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

Hãy thử trực tuyến!

Cần có thêm một số phòng để chơi gôn.

• TÅ0 - Đẩy danh sách 10 số không.
• TF... - Làm điều này 10 lần:
  • DJ - Nhân đôi mục hiện tại và tham gia nó.
  • '|.ø=- Bao quanh nó với hai |s và in ra STDOUT.
  • ITи - Lặp lại đầu vào 10 lần.
  • €L€Ω- Và với mỗi lần xuất hiện, hãy lấy một yếu tố ngẫu nhiên là [1 ... N] . (Có thể có một tích hợp sẵn cho cái này mà tôi chưa thấy)
  • Θ- Đẩy 05AB1E thật sự ™. Đối với mỗi, kiểm tra nếu nó bằng 1 .
  • s...~ - Hợp lý HOẶC kết quả của mục hiện tại.

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 nhờ @ OlivierGrégoire và -3 byte nữa bằng cách chuyển đổi Java 8 sang Java 10.

Giải trình:

Hãy thử trực tuyến.

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

Than , 30 29 27 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

⊞υ×χ0

Đẩy một chuỗi 10 0giây vào danh sách trống u.

Ｆχ

Lặp lại lệnh tiếp theo 10 lần.

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

Đối với mỗi ký tự của chuỗi cuối cùng, lặp lại n-1lần đó , thêm a 1và chọn một ký tự ngẫu nhiên từ chuỗi. Điều này cho một 1/ncơ hội thay đổi nhân vật thành a 1. Kết quả được đẩy đến u.

Ｅυ⪫||ι

Ánh xạ qua danh sách các chuỗi, bao quanh từng chuỗi |, sau đó in ngầm từng chuỗi trên dòng riêng của nó.

Con trăn 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))

Hãy thử trực tuyến!

APL + THẮNG, 30 40 35 byte

Bỏ lỡ một chút về không có khoảng trắng; (- đã sửa và cảm ơn Uriel cho -3 byte

Lời nhắc cho màn hình nhập số

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

Giải thích tương tự như của 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

Thụt lề để đọc dễ dàng hơn:

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

Tận dụng lợi thế 2 điểm: Mảng VBA sẽ mặc định là Cơ sở 0 (vì vậy w(9) tương tự nhưw(0 to 9) ) và tạo Mảng như một Long sẽ tự động khởi tạo nó thành 0.

(Khó chịu, 20 byte là định dạng tự động mà VBA thêm vào nhưng không thực sự bắt buộc - 19 dấu cách và một dấu chấm phẩy)

Tôi chưa thấy câu trả lời cho Ruby, vì vậy:

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

Hãy thử trực tuyến!

Ruby, 67 byte

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

Tôi nghĩ rằng tôi đã lừa dối một vài điều ở đây. Trước hết, chức năng này in đầu ra với dấu ngoặc kép quanh mỗi dòng, ví dụ:

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

Nếu điều này là không thể chấp nhận (cho rằng đây là nghệ thuật , đó có thể là trường hợp), đây là một giải pháp in mà không có dấu ngoặc kép cho 70 byte :

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

Giải trình:

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

các vòng lặp hợp nhất đã lưu 5 byte (một lần nữa):

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

Chạy như ống với -nRhoặc thử trực tuyến .

chỉnh sửa 1: định dạng cố định và đầu ra đầu tiên (không thay đổi số byte nhờ chơi gôn bổ sung)
chỉnh sửa 2: Chơi thêm một byte: Sau lần in cuối cùng, không còn cần phải bắn ai nữa.

C # (Trình biên dịch tương tác 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");}

Này, ít nhất tôi đã gắn với Java.

Hãy thử trực tuyến!