挑战

工厂工人通常非常努力。但是，他们的工作现在通常被机器取代。

您必须编写一个以数字作为输入的程序。它将打印出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|

注意

被解雇的工人数量是随机的-在我的示例中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 ""

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'开始。

在每次迭代中：

• 我们将s的每个字符i强制为一个数字，对i进行模5运算-使前5像0一样对待-并以1的预期概率1 / n随机执行按位OR运算，但第一次迭代除外。

• 计数器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/输入，

⍵+ -添加到数组，

×-信号。零保持零，大于1的任何值都会返回1。

⍣10 -重复10次。

视网膜，30字节

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

在线尝试！

我在Retina玩得很开心

说明

第一阶段设置我们将使用的字符串：

.+
|¶10*$(*0¶

它将整个输入替换为|，换行，然后是10行，其中包含0与输入内容 s。每行的第一个字符将代表工厂的工人。

以下阶段意味着：

.                     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。创建一个全零的数组，将其保存到$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程序完成时提供了免费的换行符。

-2个字节感谢Veskah。
-11个字节（仅使用ASCII）。

Perl 6、58字节

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

在线尝试！

+(1 > $_ * rand)生成所需频率为1s 的单个位。 xx 10复制该表达式十次以产生单个工厂实例作为位列表，并将[~]该列表连接为单个字符串。 xx 9将生成工厂字符串的表达式复制九次，然后[\~|]使用stringwise或operator进行三角形归约（某些其他语言称为“扫描”）~|，以便在较早的迭代中激发的工作者在后来的迭代中被激发。

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的完整程序。
（作为单子链接，它返回字符和整数的列表。）

在线尝试！

怎么样？

在每个阶段有效地确定每个工人（包括任何机器）是否丢掉工作（机会为N），但是机器被机器替换（使用逻辑或）。

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

@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

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]的随机元素。（可能有一个内置的，我还没有看到）
  • Θ—按05AB1E trueified™。对于每个，检查它是否等于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>

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

将10 0s 的字符串推入空白列表u。

Ｆχ

重复下一个命令10次。

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

对于最后一个字符串的每个字符，重复n-1一次，添加1，然后从字符串中选择一个随机字符。这提供了1/n将字符更改为的机会1。结果被推送到u。

Ｅυ⪫||ι

映射到字符串列表，将每个字符串都用|括起来，然后在每个行上隐式打印每个字符串。

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 + WIN，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数组将默认为以0为基数（因此w(9)与相同w(0 to 9)），并且创建数组作为Long会自动将其初始化为0。

（令人讨厌的是，VBA自动添加了20个字节的格式，但实际上并不需要-19个空格和一个分号）

我还没有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-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：打了另外一个字节：在最后一次打印后，不再需要解雇任何人。

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捆绑在一起。

在线尝试！