Давайте посмотрим, насколько хорош ваш выбор языка на выборочной случайности.

С учетом 4 -х символов, A, B, C, и D, или строка 4 символов в ABCD качестве входных данных , вывод одного из символов со следующими вероятностями:

• A должен иметь шанс 1/8 (12,5%) быть выбранным
• B должен иметь шанс 3/8 (37,5%) быть выбранным
• C должен иметь шанс 2/8 (25%) быть выбранным
• D должен иметь шанс 2/8 (25%) быть выбранным

Это соответствует следующей схеме машины Плинко :

   ^
  ^ ^
 ^ ^ ^
A B \ /
     ^
    C D

В вашем ответе должна быть предпринята искренняя попытка соблюдения описанных вероятностей. Достаточно правильного объяснения того, как вероятности вычисляются в вашем ответе (и почему они уважают спецификации, не учитывая проблемы псевдослучайности и больших чисел).

счет

Это код-гольф, поэтому побеждает меньше байтов на каждом языке !

Lean Mean Bean Machine , 55 43 42 байта

-13 байт благодаря Алексу Варге

  O
  i
  ^
 ^ ^
\ ^ ^
 i / U
 ii
 ^
i U
U

Надеюсь, вы, ребята, не возражаете, чтобы я ответил на свой вопрос всего через 2 часа, но я очень сомневаюсь, что кто-то еще планировал опубликовать ответ в LMBM.

Это буквально отражает макет Plinko, показанный в OP, перевернутый горизонтально, чтобы сократить ненужные пробелы.

Желе , 6 байт

Ḋṁ7;ḢX

Монадическая ссылка, содержащая список из четырех символов и возвращающая одну с описанным распределением вероятности.

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

Как?

Ḋṁ7;ḢX - Link: list of characters, s  e.g. ABCD
Ḋ      - dequeue s                         BCD
 ṁ7    - mould like 7 (implicit range)     BCDBCDB
    Ḣ  - head s                            A
   ;   - concatenate                       BCDBCDBA
     X - random choice                     Note that the above has 1*A, 3*B, 2*C, and 2*D

Cubix , 39 24 22 21 19 байт

.<.^iD>D|@oioi.\i;U

Посмотреть в онлайн переводчике!

Это соответствует следующей сети кубов:

    . <
    . ^
i D > D | @ o i
o i . \ i ; U .
    . .
    . .

Объяснение реализации случайного распределения

Cubix - это язык, на котором указатель команд перемещается по граням куба, выполняя команды, с которыми он сталкивается. Единственной формой случайности является команда D, которая отправляет IP в случайном направлении: равные шансы с 1/4каждой стороны.

Однако мы можем использовать это для генерации правильных взвешенных вероятностей: используя Dдважды. Первый Dимеет 1/4заголовок ко второму D. Эта секунда D, однако, имеет два направления, заблокированных стрелками ( > D <), которые отправляют указатель команды обратно в, Dчтобы выбрать другое направление. Это означает, что оттуда есть только два возможных направления, каждое из которых имеет 1/8общий шанс. Это может быть использовано для генерации правильного символа, как показано на схеме ниже:

(Обратите внимание, что в реальном коде стрелка справа заменяется зеркалом, |)

Код Объяснение

        . <
        . ^
IP> i D > D | @ o i
    o i . \ i ; U .
        . .
        . .

Указатель инструкций начинается справа от символа iлицом вправо. Он выполняет это i, беря первый символ в качестве ввода, а затем переходит к D, начиная случайный процесс, показанный выше.

• Char A: В случае, когда первый Dотправляет нас на восток, а второй на юг, нам нужно напечатать символ A. Он уже находится в стеке от первого i. Выполнено следующее:

  • \ - Отразите IP, чтобы он направлялся на восток
  • i; - Возьмите ввод, затем вставьте его снова (без операции)
  • U - Выполните разворот, повернув IP влево дважды
  • o - Вывести TOS, символ A
  • @ - прекратить программу

• Символ B: если первый или второй направлен на Dсевер, нам нужно сгенерировать символ B, который будет следующим входом. Оба пути выполняют следующие команды:

  • ^ - Направляйся на север
  • < - Идите на запад, оборачиваясь к ...
  • i - Возьмите другой ввод, символ B
  • o - Вывести TOS, символ B
  • ; - Pop TOS
  • @ - прекратить программу

• Char C: Если первый Dотправляет нас на запад, выполняется следующее:

  • i - Возьмите другой ввод, символ B
  • i - Возьмите другой ввод, символ C
  • o - Вывод TOS, символ C
  • @ - прекратить программу

• Char D: Если первый Dотправляет нас на юг, выполняется следующее:

  • i - Возьмите другой ввод, символ B
  • .. - Два ноута
  • i - Возьмите другой ввод, символ C
  • | - Это зеркало отражает восток-запад, но IP движется на север, поэтому мы проходим через него.
  • ^ - Это соединяется с путем, выбранным для символа B. Однако, поскольку мы уже взяли два ввода, четвертый символ (символ D) будет напечатан.

Python , 50 байт

lambda x:choice(x[:2]+x[1:]*2)
from random import*

Безымянная функция, принимающая и возвращающая строки (или списки символов).

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

Как?

random.choiceвыбирает случайный элемент из списка, поэтому функция формирует строку с правильным распределением, то есть заданным "ABCD", "ABCD"[:2] = "AB"плюс, "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"который есть "ABBCDBCD".

R , 31 байт

sample(scan(,''),1,,c(1,3,2,2))

Читает символы из stdinразделенных пробелами. sampleрисует случайные выборки из своего первого входа в количестве второго входа (so 1), (необязательный аргумент замены), с весами, заданными последним аргументом.

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

Попробуйте это nраз!

Для последнего кода я выбираю nвремя (установленное nв заголовке) с заменой, Tравной rue (по умолчанию это false), табулирую результаты и делю на, nчтобы увидеть относительные вероятности входных данных.

PHP, 28 байт

<?=$argn[5551>>2*rand(0,7)];

Беги как труба с -nR.

01112233в базе-4 5551в десятичном формате ...

Java 8, 53 44 байта

s->s[-~Math.abs((int)(Math.random()*8)-6)/2]

Это Function<char[], Character>.

Попробуйте онлайн! (это тестовая программа работает вышеприведенной функции 1000000 раз и выводит экспериментальные вероятности выбора A, B, Cи D).

Основная идея здесь , чтобы найти какой - то способ отображения 0-7на 0-3такое , что 0появляется 1/8раз, 1появляется 3/8раз, 2появляется 2/8раз, и 3появляется 2/8раз. round(abs(k - 6) / 2.0))работает для этого, где kслучайное целое число в диапазоне [0,8). Это приводит к следующему отображению:

k -> k - 6 -> abs(k-6) -> abs(k-6)/2 -> round(abs(k-6)/2)

0 -> -6 -> 6 -> 3   -> 3
1 -> -5 -> 5 -> 2.5 -> 3
2 -> -4 -> 4 -> 2   -> 2
3 -> -3 -> 3 -> 1.5 -> 2
4 -> -2 -> 2 -> 1   -> 1
5 -> -1 -> 1 -> 0.5 -> 1
6 -> 0  -> 0 -> 0   -> 0 
7 -> 1  -> 1 -> 0.5 -> 1

Что, как вы можете видеть, результаты в показателях 0 111 22 33, которые производят требуемые вероятности 1/8, 3/8, 2/8и 2/8.

Но ждать! Как в мире -~Math.abs(k-6)/2достигается тот же результат (опять же, где kслучайное целое число в диапазоне [0,8])? Это довольно просто на самом деле ... (x+1)/2(целочисленное деление) это то же самое , как round(x/2)и x + 1в то же самое -~x. Хотя x+1и -~xимеют одинаковую длину, в вышеуказанной функции ее лучше использовать, -~xпоскольку она -~имеет приоритет и, следовательно, не требует скобок.

APL, 14 байтов

(?8)⊃1 3 2 2\⊢

Ввод в виде строки.

Как?

1 3 2 2\⊢- повторите каждую букву х раз ( 'ABCD'→ 'ABBBCCDD')

⊃ - взять элемент по индексу ..

(?8) - случайный 1-8

Древесный уголь , 11 байт

‽⟦εεζζηηηθ⟧

Попробуйте онлайн! Ссылка на подробную версию кода, хотя она вам вряд ли понадобится; ‽выбирает случайный элемент, ⟦⟧создает список, и переменные - это те, которые получают соответствующие входные буквы (в обратном порядке, потому что мне так хотелось).

Pyth , 8 7 байтов

O+@Q1t+

Использует тот же алгоритм, что и в моем ответе на Python.

Попробуй это здесь!

Pyth , 10 8 байт

O+<Q2*2t

Использует тот же алгоритм, что и ответ Джонатана Аллана на Python.

Попробуй это здесь!

объяснение

• O- берет случайный элемент строки, сделанный добавлением (с +):

  • <Q2 - первые два символа строки.
  • *2tУдвойте полную строку ( *2) за исключением первого символа ( t).

Применяя этот алгоритм для ABCD:

• <Q2берет AB.
• *2tберет BCDи удваивает это BCDBCD.
• +соединяет две строки: ABBCDBCD.
• O принимает случайный характер

-2 благодаря Leaky Nun (второе решение)

-1 благодаря мнемонике (первое решение)

Желе , 8 байт

122b4⁸xX

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

Выньте Xчтобы увидеть "ABBBCCDD". XВыбирает случайный элемент.

C # (.NET Core) , 76 55 байт

s=>(s+s[1]+s[1]+s[2]+s[3])[new System.Random().Next(8)]

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

Мой первый ответ написан прямо на TIO с помощью моего мобильного телефона. Уровень повышен!

Объяснение: если исходная строка - «ABCD», функция создает строку «ABCDBBCD» и берет из нее случайный элемент.

JavaScript 35 байт

Принимает строку в ABCDкачестве входных данных, выводит A1 / 8th времени, B3 / 8ths того времени, C1/4 - ое время, и D1/4 - ое время.

x=>x[5551>>2*~~(Math.random()*8)&3]

объяснение

x=>x[                     // return character at index
    5551                  // 5551 is 0001010110101111 in binary
                          // each pair of digits is a binary number 0-3
                          // represented x times
                          // where x/8 is the probability of selecting
                          // the character at the index 
    >>                    // bitshift right by
    2 *                   // two times
    ~~(                   // double-bitwise negate (convert to int, then 
                          // bitwise negate twice to get the floor for
                          // positive numbers)
        Math.random() * 8 // select a random number from [0, 8)
    )                     // total bitshift is a multiple of 2 from [0, 14]
    &3                    // bitwise and with 3 (111 in binary)
                          // to select a number from [0, 3]
]

05AB1E , 5 байтов

¦Ćì.R

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

объяснение

¦Ćì.R   Argument s                      "ABCD"
¦       Push s[1:]                      "BCD"
 Ć      Enclose: Pop a, Push a + a[0]   "BCDB"
  ì     Pop a, Concatenate a and s      "ABCDBCDB"
   .R   Random pick

> <> , 25 22 19 байт

i_ixio;o
ox</;
;\$o

Попробуйте онлайн! Или посмотрите на рыбную площадку !

Краткий обзор> <>: это двумерный язык с рыбой, которая плавает по коду, выполняя инструкции по ходу дела. Если он достигает края кода, он переносится на другую сторону. Рыба начинается в верхнем левом углу, двигаясь вправо. Случайность сложна в> <>: единственная случайная инструкция x, которая произвольно устанавливает направление рыбы вверх, вниз, влево и вправо (с равной вероятностью).

В начале программы рыба читает два символа ввода i_i(каждый iчитает символ из STDIN в стек и _является горизонтальным зеркалом, которое рыба теперь игнорирует). Затем он достигает x.

Если xрыба отправляет рыбу вправо, она читает еще один символ (третий), печатает его с помощью oи останавливает с помощью ;. Левое направление аналогично: рыба читает еще два символа (так что мы до четвертого), оборачивается вправо, печатает четвертый символ и останавливается. Если рыба всплывает, она оборачивает и печатает второй символ, прежде чем отражается /и останавливается. Если он плавает вниз, он отражается слева /и ударяет другого x.

На этот раз два направления просто отправляют рыбу назад x(справа со стрелкой <и вверх с зеркалом _). Следовательно, у рыбы есть 1/2 шанс избежать этого xв каждом из двух других направлений. Влево печатает верхний символ в стеке, который является вторым, но вниз сначала меняет местами два элемента в стеке $, поэтому в этом направлении печатается первый символ.

Таким образом, третий и четвертый символы печатаются с вероятностью 1/4 каждый; первый символ имеет вероятность 1/2 х 1/4 = 1/8; а второй символ имеет вероятность 1/4 + 1/2 x 1/4 = 3/8.

05AB1E , 8 байтов

ìD1è0ǝ.R

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

         # Implicit input                            | [A,B,C,D]
ì        # Prepend the input to itself               | [A,B,C,D,A,B,C,D]
 D1è     # Get the second character                  | [A,B,C,D,A,B,C,D], B
    0ǝ   # Replace the first character with this one | [B,B,C,D,A,B,C,D]
      .R # Pick a random character from this array   | D

MATL , 12 10 байт

l3HHvY"1Zr

Попробуйте онлайн! Или запустите его 1000 раз (слегка измененный код) и проверьте, сколько раз появляется каждый символ.

объяснение

l3HH   % Push 1, 3, 2, 2
v      % Concatenate all stack contents into a column vector: [1; 3; 2; 2]
Y"     % Implicit input. Run-length decode (repeat chars specified number of times)
1Zr    % Pick an entry with uniform probability. Implicit display

Изменения в модифицированном коде: 1000:"Gl3HH4$vY"1Zr]vSY'

• 1000:"...]это цикл для повторения 1000раз.
• G обеспечивает ввод данных в начале каждой итерации.
• Результаты накапливаются в стеке на протяжении итераций. Поэтому vнеобходимо заменить 4$vна конкатенацию только верхних 4чисел.
• В конце цикла vобъединяет 1000результаты в вектор, Sсортирует их и Y'кодирует по длине прогона. Это дает четыре буквы и количество раз, когда они появились.

05AB1E , 6 байтов

«À¨Ć.R

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

объяснение

Работает как для списков, так и для строк.

«       # concatenate input with itself
 À      # rotate left
  ¨     # remove the last character/element
   Ć    # enclose, append the head
    .R  # pick a character/element at random

C (gcc) , 50 49 байтов

i[8]={1,1,1,2,2,3,3};f(char*m){m=m[i[rand()%8]];}

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

Рубин, 34 33 29 27 байт

Сохранено 2 байта благодаря @Value Inc

Введите как четыре символа

a=$**2
a[0]=a[1]
p a.sample

построить массив [B,B,C,D,A,B,C,D]и сэмплировать его.

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

попробуйте это nраз! (Я преобразовал это в функцию, чтобы повторить это проще, но алгоритм тот же)

Pyth, 7 байт

@z|O8 1

Тестирование

O8генерирует случайное число от 0 до 7. | ... 1применяет логическое или с 1, преобразовывая 0 в 1 и оставляя все остальное таким же. Число на этом этапе составляет 1 2/8 от времени и 2, 3, 4, 5, 6, 7 или 8 1/8 времени.

@zИндексы во входную строку в этой позиции. Индексация выполняется по модулю длины строки, поэтому 4 индекса в позиции 0, 5 в позиции 1 и так далее.

Вероятности:

• Положение 0: случайное число 4. 1/8 времени.

• Положение 1: случайное число 0, 1 или 5. 3/8 времени.

• Положение 2: случайное число 2 или 6. 2/8 времени.

• Положение 3: Случайное число 3 или 7. 2/8 времени.

Javascript, 31 30 байт / 23 байт

Увидев более ранний ответ Javascript от asgallant, я задумался о JS. Как он сказал:

Принимает строку в ABCDкачестве входных данных, выводит A1 / 8th времени, B 3 / 8ths того времени, C1/4 - ое время, и D1/4 - ое время.

Мой это:

x=>(x+x)[Math.random()*8&7||1]

Объяснение:

x=>(x+x)[                 // return character at index of doubled string ('ABCDABCD')
         Math.random()*8  // select a random number from [0, 8]
         &7               // bitwise-and to force to integer (0 to 7)
         ||1              // use it except if 0, then use 1 instead
        ]

Из Math.random()*8&7него разбивается следующее:

A from 4      = 12.5% (1/8)
B from 0,1,5  = 37.5% (3/8)
C from 2,6    = 25%   (1/4)
D from 3,7    = 25%   (1/4)

Версия 2, 23 байта

Но потом спасибо Арно, который отправил после меня, когда он сказал:

Если разрешена зависящая от времени формула, мы можем просто сделать:

что, если это действительно разрешено, привело меня к:

x=>(x+x)[new Date%8||1]

в котором new Date%8используется та же таблица разбивки, что и выше.

И %8также может быть &7; выбирайте. Еще раз спасибо, Арно.

нгн / апл, 10 байт

⎕a [⌈ /? 2 4]

?2 4 случайным образом выбирает пару чисел - первое среди 0 1 и второе среди 0 1 2 3

⌈/ это «максимальное уменьшение» - найти большее число

⎕a это прописные буквы алфавита

[ ] индексирование

обратите внимание на график для max (a, b), когда a∊ {0,1} и b∊ {0,1,2,3}:

    ┏━━━┯━━━┯━━━┯━━━┓
    ┃b=0│b=1│b=2│b=3┃
┏━━━╋━━━┿━━━┿━━━┿━━━┫
┃a=0┃ 0 │ 1 │ 2 │ 3 ┃
┠───╂───┼───┼───┼───┨
┃a=1┃ 1 │ 1 │ 2 │ 3 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

если a и b выбраны случайно и независимо, мы можем заменить 0123 = ABCD, чтобы получить желаемое распределение вероятностей

Python 3 , 64 55 51 байт

-9 байт благодаря @ovs

lambda s:choice((s*2)[1:]+s[1])
from random import*

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

объяснение

random.choice()получает случайный символ String, в то время как (s*2)[1:]+s[1]создает BCDABCDBдля ввода ABCD, который имеет 1/8 Aс, 2/8 Cс, 2/8 Dс и 3/8 Bс.

QBIC , 27 байт

?_s;+;+B+B+;+C+;+D,_r1,8|,1

объяснение

?           PRINT
 _s         A substring of
   ;+       A plus
   ;+B+B+   3 instances of B plus
   ;+C+     2 instances of C plus
   ;+D      2 instances of D plus
   ,_r1,8|  from position x randomly chosen between 1 and 8
   ,1       running for 1 character

> <>, 56 байт

v
!

"
D
C
B
A ;
" o
! @
! ^<
x!^xv!
@  v<
@  o
o  ;
;
o

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

Чип , 60 байт

)//Z
)/\Z
)\/^.
)\x/Z
)\\\+t
|???`~S
|z*
`{'AabBCcdDEefFGghH

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

Каждый из трех ?производит случайный бит. В первом цикле эти биты запускаются через переключатели выше ( /и \), чтобы определить, какое значение мы собираемся вывести из этой таблицы:

000 a
01_ b
0_1 b
10_ c
11_ d

(где _может быть либо 0или 1). Затем мы идем вдоль ввода по мере необходимости, распечатывая и заканчивая, когда достигается правильное значение.

Большой алфавитный шарик в конце копируется оптом из программы cat, это решение просто подавляет вывод и завершает работу, чтобы получить желаемый эффект.

Рубин, 32 байта

Довольно просто ..?

->s{s[[0,1,1,1,2,2,3,3].sample]}

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

Applesoft, 29 упс, 32 байта

Небольшой «ретрокомпьютерный» пример. Терпите меня, я новичок в этом. Я понимаю, что то, что обозначено как «вход», не должно быть подсчитано байтами. Как указано в OP, ввод будет дан как «ABCD». (Первоначально я не осознавал, что мне нужно указать получаемый ввод, который добавил 4 байта, в то время как остальные оставляли в байте.)

INPUTI$:X=RND(1)*4:PRINTMID$(I$,(X<.5)+X+1,1)

Термины INPUT, RND, PRINT и MID $ каждый кодируются внутренне как однобайтовые токены.

Сначала X присваивается случайное значение в диапазоне 0 <X <4. Это используется для выбора одного из символов из I $ в соответствии с (X <.5) + X + 1. Значение позиции символа принимается как усеченная оценка выражения. X <.5 добавляет 1, если X было меньше, чем .5, в противном случае добавьте 0. Результаты X разбиты следующим образом:

A from .5 ≤ X < 1           = 12.5%
B from X < .5 or 1 ≤ X < 2  = 37.5%
C from 2 ≤ X < 3            = 25%
D from 3 ≤ X < 4            = 25%

Common Lisp , 198 байт

(setf *random-state*(make-random-state t))(defun f(L)(setf n(random 8))(cond((< n 1)(char L 0))((and(>= n 1)(< n 4))(char L 1))((and(>= n 4)(< n 6))(char L 2))((>= n 6)(char L 3))))(princ(f "ABCD"))

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

Удобочитаемый:

(setf *random-state* (make-random-state t))
(defun f(L)
    (setf n (random 8))
    (cond 
            ((< n 1) 
                (char L 0))
            ((and (>= n 1)(< n 4))
                (char L 1))
            ((and (>= n 4)(< n 6))
                (char L 2))
            ((>= n 6)
                (char L 3))
    )
)
(princ (f "abcd"))