도전

공장 노동자들은 대개 매우 열심히 일하고 있습니다. 그러나 그들의 작업은 이제 일반적으로 기계로 대체되고 있습니다.

숫자를 입력으로받는 프로그램을 작성해야합니다. 10 명의 공장을 10 번 인쇄합니다. 매번 각 근로자는 1/input'해고'되고 기계로 교체 될 수 있습니다.

입력

STDIN 또는 함수 호출에서 오는 정수입니다.

산출

공장의 경우 10 건, 보통은 더 많은 근로자가 해고 됨.

출력 형식-공장 인쇄 방법

공장은 다음과 같습니다

|0000000000| 또는 |0000011001|

파이프는 벽을 나타내고, 0은 작업자를, 1은 기계를 나타내므로 공장의 첫 번째 인쇄는 항상입니다 |0000000000|.

예

입력 : 10

산출:

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

입력 : 5

산출:

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

노트

해고 된 노동자의 수는 RANDOM입니다. 제 예제에서는 1/5 chance항상 2 명의 노동자가 해고 될 것이지만 프로그램은 무작위로 (때때로 1 명, 때로는 3 명) 해고 할 확률이 1/5입니다.

Japt -R , 22 21 20 19 18 바이트

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

시도 해봐

설명

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 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

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

자바 스크립트 (ES6), 84 바이트

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

온라인으로 사용해보십시오!

재귀 버전, 88 바이트

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

온라인으로 사용해보십시오!

어떻게?

우리는 시작 케이 = S = '5000000000' .

각 반복에서 :

• 우리 는 s의 각 문자 i 를 숫자로 강제하고 i 모듈로 5를 계산 하여 선행 5 가 0으로 취급 되도록하고 첫 번째 반복을 제외하고 예상 확률 1 / n 으로 1 로 비트 OR을 무작위로 수행합니다. .

• 카운터 k 는 3 비트만큼 오른쪽으로 시프트된다. k = 0이 되 자마자 재귀를 멈 추면 10 회 반복됩니다.

  는 것이 중요하다 5,000,000,000는 내재적으로 변환되어 있으므로, 32 비트 정수보다 약간 큰 5,000,000,000을 0xFFFFFFFF = 705,032,704 및 제 비트 시프트가 발생하기 직전. 따라서 다음 단계 :

   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 바이트

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

온라인으로 사용해보십시오!

어떻게?

10⍴0 -10 개의 0으로 시작하십시오.

⎕←' '~⍨⍕'|'⍵'|' -포맷 된 배열을 인쇄 할 때마다

?10⍴⍺- 1입력 범위의 값으로 임의의 배열을 생성합니다 .

⍺=-입력과 요소 별 비교 1요소의 표시 / 입력, 매번 각각의 1/ 입력을 제공 해야합니다 .

⍵+ -배열에 추가

×-signum. 0은 0을 유지하고 1보다 큰 것은 1로 돌아옵니다.

⍣10 -10 번 반복하십시오.

망막 , 30 바이트

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

온라인으로 사용해보십시오!

Retina에서 무작위로 많은 재미를 느낍니다 ^^

설명

첫 번째 단계는 작업 할 문자열을 설정합니다.

.+
|¶10*$(*0¶

전체 입력을 |줄 바꿈으로 바꾸고 입력 줄 수만큼을 포함하는 10 줄을 바꿉니다 0. 각 줄의 첫 번째 문자는 공장 노동자를 나타냅니다.

다음 단계는 다음을 의미합니다.

.                     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

작업 문자열의 첫 번째 줄에는 |루프 만 반복 될 때마다 첫 번째 문자가 인쇄되고 첫 번째 줄의 첫 번째 문자가되는 첫 번째 문자가 포함되며 모든 반복이 끝날 때도 첫 번째 문자가됩니다. 전체 문자열의 문자). 이 줄에는 숫자가 포함되어 있지 않기 때문에이 줄에 영향을 미치지 않습니다.

서로 다른 행에는 n숫자 가 포함되어 있으므로 행 n의 첫 번째 문자 (유일한 의미있는 문자)를로 변환 할 가능성 이 1입니다 1.

PowerShell , 82 80 69 바이트

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

온라인으로 사용해보십시오!

입력을 $x받습니다. 모든 0의 배열을 작성하여 저장 $a한 다음 여러 번 반복합니다. 편리하게도, 공장은 반복 가치만큼 넓습니다. 반복 할 때마다 현재 팩토리를로 출력 "|$(-join$a)|"한 다음의 각 요소를 반복합니다 $a.

우리는 현재 요소를 선택하고 내부 $_했다 -binary- or중 하나와 ED 1에 기초하여 Random입력을 기반으로 기회를 $x. 예를 들어, 입력 10, Get-Random -max 10사이의 범위 일 것이다 0와 9되고 0시간의 약 1 / 10. 따라서 함께 !(...)포장 Random, 우리는거야 1약 1/input시간의 양, 다른 1-1/input우리가 얻을 것이다 시간의 양을 $_. 예, 이것은 때때로 우리가 1다른 것으로 덮어 쓰고 있음을 의미 1하지만 괜찮습니다.

그 결과 배열은 다음 둘러보기를 $a위해 다시 저장됩니다 . 결과로 나오는 모든 문자열은 파이프 라인에 남아 Write-Output있으며 프로그램 완료시 암시 적 으로 줄 바꿈을 무료로 제공합니다.

Veskah 덕분에 -2 바이트.
ASCII 전용으로 -11 바이트

펄 6 , 58 바이트

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

온라인으로 사용해보십시오!

+(1 > $_ * rand)1s 의 필요한 주파수로 단일 비트를 생성합니다 . xx 10해당 표현식을 10 번 복제하여 단일 팩토리 인스턴스를 비트 [~]목록으로 생성하고 해당 목록을 단일 문자열로 결합합니다. xx 9팩토리 문자열 생성 표현식을 9 번 복제 한 다음 [\~|]stringwise 또는 operator를 사용하여 삼각형 축소 (일부 다른 언어에서는 "스캔"이라고 함)를 수행 ~|하므로 이전 반복에서 해고 된 작업자는 이후에 해고됩니다.

파이썬 2 , 104 103 바이트

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

온라인으로 사용해보십시오!

젤리 , 22 바이트

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

정수를 명령 행 입력으로 승인하고 출력을 STDOUT에 인쇄하는 전체 프로그램.
모나 딕 링크로서 문자 및 정수 목록을 반환합니다.

온라인으로 사용해보십시오!

어떻게?

각 작업자 (기계 포함)가 작업을 잃는 경우 (N 확률로 1 명씩) 각 단계에서 효과적으로 결정하지만 기계는 기계로 교체됩니다 (논리 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 바이트

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

온라인으로 사용해보십시오!

(긴) 설명

스택 내용의 예가 그 과정을 따라 표시됩니다. 각 단계에서 스택 내용이 아래에서 위로 표시됩니다.

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

자바 스크립트 (Node.js) , 105 93 90 바이트

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

온라인으로 사용해보십시오!

@Shaggy 덕분에 배열을 함수 안에 넣을 때 +2 바이트

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

온라인으로 사용해보십시오!

C (GCC) , 110 (106) 바이트

@ceilingcat에서 -4 바이트

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

온라인으로 사용해보십시오!

각 교체 라운드에 대한 문자 목록을 반복합니다.

언 골프 드 :

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 바이트

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

펄 5 , 44 바이트

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

온라인으로 사용해보십시오!

05AB1E , 22 바이트

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

온라인으로 사용해보십시오!

골프를위한 더 많은 공간이 있어야합니다.

• TÅ0 — 0으로 된 목록을 누릅니다.
• TF... —이 작업을 10 회 수행하십시오.
  • DJ — 현재 항목을 복제하고 결합합니다.
  • '|.ø=— 두 개로 둘러싸고 |STDOUT으로 인쇄하십시오.
  • ITи — 입력을 10 번 반복하십시오.
  • €L€Ω— 그리고 각각의 발생에 대해 [1 ... N] 의 랜덤 요소를 얻습니다 . (내가 아직 보지 못한 내장 기능이있을 수 있습니다)
  • Θ— 05AB1E truthified ™를 누릅니다. 각각에 대해 1과 같은지 확인하십시오 .
  • s...~ — 논리 OR 현재 항목 별 결과.

자바 스크립트, 83 바이트

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>

자바 10 153 152 131 바이트

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 덕분에 -18 바이트 , Java 8을 Java 10으로 변환하여 -3 바이트 더.

설명:

온라인으로 사용해보십시오.

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

숯 , 30 29 27 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

⊞υ×χ0

0빈 목록 에 10 초 문자열을 밀어 넣습니다 u.

Ｆχ

다음 명령을 10 번 반복하십시오.

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

마지막 문자열의 각 문자에 대해 반복하고을 n-1추가 1하고 문자열에서 임의의 문자를 선택하십시오. 이것은 제공 1/n에있는 문자를 변화의 기회를 1. 결과가 (으)로 푸시됩니다 u.

Ｅυ⪫||ι

로 묶은 문자열 목록을 매핑 |한 다음 암시 적으로 각 행에 인쇄합니다.

파이썬 3 , 132 바이트

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

온라인으로 사용해보십시오!

APL + WIN, 30 40 35 바이트

공백이없는 비트를 놓쳤다; (-고정 및 3 바이트의 Uriel 덕분에

숫자의 화면 입력을위한 프롬프트

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

우리엘과 비슷한 설명 :

?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 바이트

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

쉽게 읽을 수 있도록 들여 쓰기

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 점을 활용합니다. VBA 어레이는 기본적으로 Base 0으로 설정되므로 ( w(9)와 동일 w(0 to 9)) Long으로 어레이를 생성하면 자동으로 0으로 초기화됩니다.

(귀찮게, 20 바이트는 VBA가 추가하지만 실제로는 필요하지 않은 자동 포맷팅입니다-19 개의 공백과 하나의 세미콜론)

루비에 대한 답변을 아직 보지 못했습니다.

루비 , 92 바이트

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

온라인으로 사용해보십시오!

루비, 67 바이트

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

여기 몇 가지를 속인 것 같습니다. 우선,이 함수는 각 줄 주위에 따옴표로 출력을 인쇄합니다. 예 :

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

이것이 용납 할 수없는 경우 (이것이 ascii-art 라면, 아마도 그럴 것입니다), 여기에 70 바이트에 대한 따옴표없이 인쇄하는 해결책이 있습니다 .

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

설명:

->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 바이트

병합 루프를 5 바이트 (다시) 절약했습니다.

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

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

편집 1 : 고정 형식 및 첫 번째 출력 (추가 골프로 인해 바이트 수의 변경 없음)
편집 2 : 1 바이트 더 골프 : 마지막 인쇄 후 더 이상 아무도 발사 할 필요가 없습니다.

C # (Visual C # 대화식 컴파일러) , 131 바이트

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

야, 적어도 나는 Java와 묶었 다.

온라인으로 사용해보십시오!