チャレンジ

工場労働者は通常非常に勤勉です。しかし、彼らの仕事は現在一般的に機械に置き換えられています。

入力として数値を取るプログラムを作成する必要があります。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 = '50億'。

各反復で：

• 我々は、各文字強制Iの秒数に計算Iモジュロ5 -そうつながることを図5は、同様に処理される0 -ランダムビット単位を実行するかと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、毎回/入力を与える必要があります

⍵+ -配列に追加し、

×-サイン。ゼロはゼロのままで、1より大きい値は1に戻ります。

⍣10 -10回繰り返します。

網膜、30バイト

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

オンラインでお試しください！

私はRetinaでランダムにたくさん楽しんでいます^^

説明

最初の段階では、使用する文字列を設定します。

.+
|¶10*$(*0¶

入力全体を|、改行、および0入力が示すだけのs を含む10行で置き換えます。各行の最初の文字は、工場の労働者を表します。

次の段階とは：

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

内部では、入力に基づく可能性に基づいて、いずれかで挿入$_された現在の要素を選択しています。たとえば、inputの場合、範囲は〜であり、時間の約1/10になります。したがって、をラップすると、おおよその時間を取得し、他の時間を取得します。はい、これは時々a をanother で上書きすることを意味しますが、それで問題ありません。-bor1Random$x10Get-Random -max 10090!(...)Random11/input1-1/input$_11

その結果の配列は$a、次のラウンドのために保存されます。結果の文字列はすべてパイプラインに残され、Write-Outputプログラムの完了時に暗黙的に行われるため、改行が無料で提供されます。

-2バイト、Veskahのおかげ。
ASCIIのみのおかげで-11バイト。

Perl 6、58バイト

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

オンラインでお試しください！

+(1 > $_ * rand)必要な周波数1sの単一ビットを生成します。 xx 10その式を10回複製して、単一のファクトリインスタンスをビットのリストとして生成し、[~]そのリストを単一の文字列に結合します。 xx 9そのファクトリ文字列を生成する式を9回複製[\~|]し、stringwise or 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

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 —現在のアイテムを複製して結合します。
  • '|.ø=— 2 |秒間で囲み、STDOUTに出力します。
  • ITи —入力を10回繰り返します。
  • €L€Ω—そして、発生ごとに、ランダム要素[1 ... N]を取得します。（これにはまだ見たことがないビルトイン機能があるかもしれません）
  • Θ— 05AB1E truthified™をプッシュします。それぞれについて、1に等しいかどうかを確認します。
  • s...~ —現在のアイテムによる論理OR結果。

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

@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 0秒の文字列を空のリストにプッシュしますu。

Ｆχ

次のコマンドを10回繰り返します。

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

最後の文字列の各文字について、それをn-1何回か繰り返し、aを追加して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バイト

スペースがないというビットを見逃しました;（-修正し、-3バイトのUrielに感謝します

数字の画面入力のプロンプト

'|',(⍕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配列はデフォルトでBase 0になり（したがってw(9)、と同じですw(0 to 9)）、配列をLongとして作成すると、自動的に0に初期化されます。

（面倒なことに、20バイトはVBAが追加する自動フォーマットですが、実際には必要ではありません-19個のスペースと1つのセミコロン）

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

オンラインでお試しください！

ルビー、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と結びついています。

オンラインでお試しください！