Виклик

Заводські робітники зазвичай дуже працьовиті. Однак зараз їх роботу зазвичай замінюють машинами.

Ви повинні написати програму, яка приймає число в якості введення. Він буде друкувати фабрику з 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' .

На кожній ітерації:

• Ми примушувати кожен символ я з х в ряд, обчислити я по модулю 5 - так що провідна 5 розглядається як 0 - і випадковим чином виконати побітовое АБО з 1 до очікуваної ймовірністю 1 / п , за винятком того, на першій ітерації .

• Лічильник 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/ вводити елементи, даючи кожен a 1/ input кожен раз,

⍵+ - додати до масиву,

×- signum. нуль залишається нулем, все більше, ніж одне, повертається до одного.

⍣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

Перший рядок робочого рядка містить лише a | , який буде першим символом, надрукованим кожною ітерацією циклу (будучи першим символом першого рядка), а також буде надрукований в кінці кожної ітерації (будучи першим символу цілого рядка). Заміна ніколи не матиме жодного ефекту для цього рядка, оскільки він не містить жодної цифри.

Кожен інший рядок містить nцифри, тому є nшанс 1 перетворити перший символ рядка (який є єдиним значущим) в a 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

Perl 6 , 58 байт

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

Спробуйте в Інтернеті!

+(1 > $_ * rand)генерує єдиний біт з необхідною частотою 1s. xx 10повторює цей вираз десять разів, щоб створити один заводський екземпляр у вигляді списку бітів, і [~]з'єднує цей список в одну рядок. xx 9повторює цей вираз, що генерує фабрику струни дев'ять разів, а потім [\~|]робить трикутне зменшення (яке деякі інші мови називають "скануванням") за допомогою рядка або оператора ~|, щоб працівник, звільнений за попередньою ітерацією, залишався звільненим у пізніших.

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 байт

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

Спробуйте в Інтернеті!

Ітераціює через список символів для кожного раунду замін.

Безголовки:

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 - Дублюйте поточний елемент і приєднуйтесь до нього.
  • '|.ø= - Оточіть його двома | с і надрукуйте для STDOUT.
  • ITи - Повторіть введення 10 разів.
  • €L€Ω- І для кожного виникнення отримайте випадковий елемент [1 ... N] . (Можливо, для цього є вбудований, якого я ще не бачив)
  • Θ- Push 05AB1E truthified ™. Для кожного перевірте, чи дорівнює 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 0 с до порожнього списку 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],'|'

Пояснення, подібне до Уріеля:

?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) ) і створення масиву як довгого автоматично ініціалізує його до 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: Полезний ще один байт: Після останньої друку більше не потрібно нікого стріляти.

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

Гей, принаймні я зв’язав з Явою.

Спробуйте в Інтернеті!