Вызов

Работники завода обычно очень трудолюбивы. Однако их работа в настоящее время обычно заменяется машинами.

Вы должны написать программу, которая принимает число в качестве входных данных. Он будет распечатывать фабрику из 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="")

Попробуйте онлайн!

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 по модулю 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/ вход каждый раз,

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

×- подпись. ноль остается нулем, все, что больше единицы, возвращается к одному.

⍣10 - повторить 10 раз.

Сетчатка , 30 байт

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

Попробуйте онлайн!

Мне очень весело со случайностью в Retina ^^

объяснение

Первый этап устанавливает строку, с которой мы будем работать:

.+
|¶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

Первая строка рабочей строки содержит только 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/10 времени. Таким образом, с !(...)упаковкой Randomмы получим 1примерно 1/inputколичество времени, а другое 1-1/inputколичество времени мы получим $_. Да, это иногда означает, что мы перезаписываем один 1другим 1, но это нормально.

Этот результирующий массив затем сохраняется в $aследующем раунде. Все полученные строки остаются в конвейере, и неявное Write-Outputзавершение программы дает нам новые строки бесплатно.

-2 байта благодаря Вескам.
-11 байт благодаря ASCII-только.

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.
(В качестве монадической ссылки возвращается список символов и целых чисел.)

Попробуйте онлайн!

Как?

Эффективно решает на каждом этапе, если каждый работник (включая любые машины) потеряет свою работу (с вероятностью один в 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);}

Попробуйте онлайн!

Перебирает список символов для каждого раунда замен.

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 - Дублируйте текущий элемент и присоединитесь к нему.
  • '|.ø=- Окружите его двумя |секундами и напечатайте 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>

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раз, добавьте 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 байта

Подсказки для экранного ввода номера

'|',(⍕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 Arrays по умолчанию будет иметь базовую 0 ( w(9)то же самое, что и w(0 to 9)), а создание массива как Long автоматически инициализирует его равным 0.

(К сожалению, 20 байтов автоматически форматируются, что VBA добавляет, но фактически не требуется - 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

Попробуйте онлайн!

Рубин, 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или попробуйте онлайн .

edit 1: фиксированный формат и первый вывод (без изменения количества байтов благодаря дополнительной игре в гольф)
edit 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.

Попробуйте онлайн!