ท้าทาย

คนงานในโรงงานมักจะทำงานหนักมาก อย่างไรก็ตามงานของพวกเขาตอนนี้ถูกแทนที่ด้วยเครื่องทั่วไป

คุณต้องเขียนโปรแกรมที่ใช้ตัวเลขเป็นอินพุต มันจะพิมพ์โรงงาน 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="")

ลองออนไลน์!

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 ไบต์

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

ลองออนไลน์!

อย่างไร?

เราเริ่มต้นด้วยK = s = '5000000000'

ในแต่ละรอบซ้ำ:

• เรารวมอักขระแต่ละตัวiของsกับตัวเลขคำนวณi modulo 5 - เพื่อให้ค่า5นำไปปฏิบัติเช่น0 - และสุ่มทำการ bitwise OR กับ1ด้วยความน่าจะเป็นที่คาดหวัง1 / nยกเว้นการทำซ้ำครั้งแรก .

• ตัวนับkเลื่อนไปทางขวา 3 บิต เราหยุดการสอบถามซ้ำทันทีที่k = 0ซึ่งให้การวนซ้ำ 10 ครั้ง

  สิ่งสำคัญคือให้สังเกตว่า5000000000มีขนาดใหญ่กว่าจำนวนเต็ม 32 บิตเล็กน้อยดังนั้นจึงถูกแปลงเป็น5000000000 & 0xFFFFFFFF = 705032704โดยปริยายก่อนที่จะเกิดการเปลี่ยนแปลงระดับบิตแรก ดังนั้นขั้นตอนดังต่อไปนี้:

   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 ศูนย์

⎕←' '~⍨⍕'|'⍵'|' - ทุกครั้งที่พิมพ์อาเรย์ที่จัดรูปแบบแล้ว

?10⍴⍺- สร้างอาร์เรย์แบบสุ่มที่มีค่าตั้งแต่1อินพุต

⍺=- การเปรียบเทียบองค์ประกอบที่ชาญฉลาดกับอินพุต ควรทำเครื่องหมาย1/ อินพุตขององค์ประกอบโดยให้แต่ละ1/ อินพุตทุกครั้ง

⍵+ - เพิ่มไปยังอาร์เรย์

×- signum ศูนย์ยังคงเป็นศูนย์ทุกอย่างที่มากกว่าหนึ่งจะกลับมาเป็นหนึ่ง

⍣10 - ทำซ้ำ 10 ครั้ง

เรติน่า 30 ไบต์

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

ลองออนไลน์!

ฉันสนุกกับการสุ่มในจอประสาทตา ^^

คำอธิบาย

ขั้นตอนแรกตั้งค่าสตริงที่เราจะทำงานร่วมกับ:

.+
|¶10*$(*0¶

มันจะแทนที่อินพุตทั้งหมดด้วย|ขึ้นบรรทัดใหม่แล้ว 10 บรรทัดที่มี0s มากที่สุดเท่าที่อินพุตพูด อักขระตัวแรกในแต่ละบรรทัดจะเป็นตัวแทนของคนงานในโรงงาน

ขั้นตอนต่อไปนี้หมายถึง:

.                     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ตัวเลขจึงมี 1 ในnโอกาสที่จะเปิดตัวอักษรตัวแรกของบรรทัด (ซึ่งเป็นคนเดียวที่มีความหมายอย่างใดอย่างหนึ่ง) 1เป็น

PowerShell , 82 80 69 ไบต์

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

ลองออนไลน์!

$xจะเข้า สร้างอาร์เรย์ของศูนย์ทั้งหมดบันทึกลงใน$aและจากนั้นวนซ้ำหลายครั้ง สิ่งอำนวยความสะดวกโรงงานมีความกว้างเท่ากับที่ต้องทำซ้ำ แต่ละซ้ำเราส่งออกจากโรงงานของเราในปัจจุบันด้วยแล้วห่วงผ่านองค์ประกอบของแต่ละ"|$(-join$a)|"$a

ข้างในเรากำลังเลือกองค์ประกอบปัจจุบัน$_ที่ไม่-bเหมาะสมorด้วยเช่นกัน1ขึ้นอยู่กับโอกาสบนพื้นฐานของข้อมูลRandom $xตัวอย่างเช่นสำหรับการป้อนข้อมูล10, Get-Random -max 10จะอยู่ในช่วงระหว่าง0และ9และจะ0ใช้เวลาประมาณ 1 / 10th ของเวลา ดังนั้นจึงมี!(...)การตัดRandomเราจะได้รับการ1ประมาณ1/inputปริมาณของเวลาและอื่น ๆจำนวนของเวลาที่เราจะได้รับ1-1/input $_ใช่บางครั้งหมายความว่าเราเขียนทับสิ่ง1อื่น1แต่ก็ไม่เป็นไร

อาร์เรย์ที่เป็นผลลัพธ์จะถูกจัดเก็บกลับเข้าไปใน$aรอบถัดไป สตริงผลลัพธ์ทั้งหมดจะถูกทิ้งไว้ที่ไพพ์ไลน์และการบอกนัยWrite-Outputที่โปรแกรมเสร็จจะทำให้เราขึ้นบรรทัดใหม่ได้ฟรี

-2 ไบต์ต้องขอบคุณ Veskah
-11 ไบต์ขอบคุณ ASCII-only

Perl 6 , 58 ไบต์

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

ลองออนไลน์!

+(1 > $_ * rand)สร้างบิตเดียวกับความถี่ที่ต้องการของ1s xx 10ทำซ้ำนิพจน์นั้นสิบครั้งเพื่อสร้างอินสแตนซ์จากโรงงานเดียวเป็นรายการของบิตและ[~]รวมรายการนั้นไว้ในสตริงเดียว xx 9ซ้ำที่โรงงานสตริงที่ก่อให้เกิดการแสดงออกเก้าครั้งแล้ว[\~|]ไม่ลดลงสามเหลี่ยม (ซึ่งบางส่วนภาษาอื่น ๆ เรียกว่า "สแกน") กับ stringwise หรือผู้ประกอบการ~|เพื่อให้คนงานไล่ออกในก่อนหน้านี้ยังคงย้ำไล่ออกในคนต่อมา

Python 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
(เป็นลิงก์แบบ monadic จะส่งคืนรายการของอักขระและจำนวนเต็ม)

ลองออนไลน์!

อย่างไร?

ตัดสินใจอย่างมีประสิทธิภาพในแต่ละขั้นตอนหากผู้ปฏิบัติงานแต่ละคน (รวมถึงเครื่องใด ๆ ) สูญเสียงานของพวกเขา (โดยมีโอกาสหนึ่งครั้งใน N) อย่างไรก็ตามเครื่องจะถูกแทนที่ด้วยเครื่อง (ใช้ตรรกะ-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

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

ลองออนไลน์!

+2 ไบต์สำหรับการใส่อาร์เรย์ภายในฟังก์ชันด้วย @Shaggy สำหรับการชี้ให้เห็น

(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 ไบต์

-4 ไบต์จาก @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);}

ลองออนไลน์!

วนซ้ำรายการของอักขระสำหรับการแทนที่แต่ละรอบ

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 ไบต์

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

Perl 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 - กดรายการ 10 ศูนย์
• TF... - ทำเช่นนี้ 10 ครั้ง:
  • DJ - ทำซ้ำรายการปัจจุบันและเข้าร่วม
  • '|.ø=- ล้อมรอบด้วยสอง|s และพิมพ์ไปยัง STDOUT
  • ITи - ทำซ้ำอินพุต 10 ครั้ง
  • €L€Ω- และสำหรับการเกิดขึ้นแต่ละครั้งรับองค์ประกอบแบบสุ่มของ[1 ... N]N] (อาจมีในตัวสำหรับสิ่งนี้ซึ่งฉันยังไม่เห็น)
  • Θ- กด 05AB1E Factified ™ ตรวจสอบแต่ละรายการว่าเท่ากับ1 หรือไม่หรือไม่
  • s...~ - ตรรกะหรือผลลัพธ์โดยรายการปัจจุบัน

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

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

-18 ไบต์ขอบคุณ@ OlivierGrégoireและ -3 ไบต์เพิ่มเติมโดยการแปลง Java 8 เป็น Java 10

คำอธิบาย:

ลองออนไลน์

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

ผลักดันสตริงของ 10 0s uไปยังรายการที่ว่างเปล่า

Ｆχ

ทำซ้ำคำสั่งถัดไป 10 ครั้ง

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

สำหรับอักขระแต่ละตัวของสตริงสุดท้ายให้ทำซ้ำn-1ครั้งเพิ่ม1และเลือกอักขระสุ่มจากสตริง นี้จะช่วยให้โอกาสของการเปลี่ยนแปลงตัวละครไปยัง1/n ผลที่ได้คือผลักดันให้1u

Ｅυ⪫||ι

แม็พเหนือรายการของสตริงที่ล้อมรอบด้วย|จากนั้นพิมพ์โดยปริยายบนบรรทัดของตัวเอง

Python 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 + ชนะ30 40 35 ไบต์

พลาดบิตไปโดยไม่มีช่องว่าง (- แก้ไข & ขอบคุณ Uriel เป็น -3 ไบต์

แจ้งให้ป้อนหมายเลขหน้าจอ

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

คำอธิบายคล้ายกับของ 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 ไบต์

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 Arrays จะใช้ค่าเริ่มต้นเป็น Base 0 (เช่นw(9)เดียวกับw(0 to 9)) และการสร้าง Array เป็น Long จะเริ่มต้นโดยอัตโนมัติเป็น 0

(น่ารำคาญมีการจัดรูปแบบอัตโนมัติ20ไบต์ที่ VBA เพิ่ม แต่ไม่จำเป็นต้องใช้จริง - มีช่องว่าง 19 ช่องและเซมิโคลอนหนึ่งอัน)

ฉันยังไม่เห็นคำตอบสำหรับ Ruby ดังนั้น:

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

ลองออนไลน์!

Ruby, 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 ศิลปะที่น่าจะเป็นกรณี) นี่คือทางออกที่พิมพ์ไม่ทราบราคาสำหรับ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: ตีเพิ่มอีกหนึ่งไบต์: หลังจากพิมพ์ครั้งสุดท้ายไม่จำเป็นต้องยิงใครอีก

C # (Visual C # Interactive คอมไพเลอร์) , 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");}

อย่างน้อยฉันก็ผูกกับจาวา

ลองออนไลน์!