Ваша программа / функция должна

• вывести ровно одно целое число
• выведите любое целое число с положительной вероятностью
• выведите целое число больше 1.000.000 или меньше -1.000.000 с вероятностью не менее 50%.

Пример выходов (все должно быть возможно):

59875669123
12
-42
-4640055890
0
2014
12
24
-7190464664658648640055894646646586486400558904644646646586486400558904646649001

Разъяснения:

• Разрыв трейлинга разрешен.
• Ведущие нули не допускаются.
• -0 разрешено

Самый короткий код выигрывает.

CJam, 16 14 13 байт

0{Kmr(+esmr}g

Это будет выполняться очень долго, потому что он использует текущую временную метку (порядка 10 ¹² ), чтобы определить, должен ли цикл завершиться. Я использую это как представление, поскольку оно самое короткое, но есть две 14-байтовые альтернативы, которые имеют свои достоинства:

0{esmr(+esmr}g

Этот не ограничен периодом PRNG, так как диапазон всех случайных чисел зависит от текущей метки времени. Следовательно, это должно быть в состоянии произвести любое число, хотя вероятность отрицательных или даже небольших положительных чисел исчезающе мала.

Ниже приведена эквивалентная версия, которая использует 3e5вместо отметки времени. И 20для первого диапазона (как 13-байтовое представление). Это намного быстрее, а также соответствует всем правилам. Это своего рода ограничивающий случай - получить 50% вероятности для чисел, превышающих 1 000 000, при сохранении разумного времени выполнения и небольшого размера кода. Объяснение и математическое обоснование относятся к этой версии:

0{Kmr(+3e5mr}g

Обычно это занимает несколько секунд, чтобы бежать. Вы можете заменить 5с2 на, чтобы он работал еще быстрее. Но тогда требование о 50% вероятности будет выполнено только для 1000 вместо 1 000 000.

Я начинаю с 0. Затем у меня есть цикл, из которого я вырываюсь с вероятностью 1 / (3 * 10 ⁵ ). В этом цикле я добавляю случайное целое число от -1 до 18 (включительно) к моему промежуточному итогу. Существует конечная (хотя и небольшая) вероятность того, что каждое целое число будет выведено, причем положительные целые числа гораздо более вероятны, чем отрицательные (я не думаю, что вы увидите отрицательное целое в своей жизни). Разрыв с такой малой вероятностью и увеличение в большинстве случаев (и добавление гораздо большего, чем вычитание) гарантирует, что мы, как правило, выйдем за пределы 1 000 000.

0              "Push a 0.";
 {          }g "Do while...";
  Kmr          "Get a random integer in 0..19.";
     (         "Decrement to give -1..18.";
      +        "Add.";
       3e5mr   "Get a random integer in 0..299,999. Aborts if this is 0.";

Некоторое математическое обоснование:

• На каждом этапе мы добавляем в среднем 8,5.
• Чтобы добраться до 1 000 000, нам нужно 117 647 из этих шагов.

• Вероятность того, что мы сделаем меньше этого количества шагов,

  sum(n=0..117,646) (299,999/300,000)^n * 1/300,000
  

  который оценивает 0.324402. Следовательно, примерно в двух третях случаев мы предпримем более 117 647 шагов, и каждый из них легко будет составлять 1 000 000.

• (Обратите внимание, что это не является точной вероятностью, потому что будут некоторые колебания относительно этих средних 8,5, но чтобы достичь 50%, нам нужно пройти значительно дальше 117 646 до примерно 210 000 шагов.)
• Если вы сомневаетесь, мы можем легко взорвать знаменатель вероятности завершения, 9e9не добавляя байтов (кроме лет времени выполнения).

... или 11 байт?

Наконец, есть 11-байтовая версия, которая также не ограничена периодом PRNG, но у которой почти всегда будет не хватать памяти. Он генерирует только одно случайное число (на основе метки времени) каждой итерации и использует его как для увеличения, так и для завершения. Результаты каждой итерации остаются в стеке и суммируются только в конце. Спасибо Деннису за эту идею:

{esmr(}h]:+

Ява, 133 149

void f(){String s=x(2)<1?"-":"";for(s+=x(9)+1;x(50)>0;s+=x(10));System.out.print(x(9)<1?0:s);}int x(int i){return new java.util.Random().nextInt(i);}

Пример выходов

-8288612864831065123773
0
660850844164689214
-92190983694570102879284616600593698307556468079819964903404819
3264

Ungolfed

void f() {
    String s = x(2)<1 ? "-" : "";       // start with optional negative sign
    s+=x(9)+1;                          // add a random non-zero digit
    for(; x(50)>0; )                    // with a 98% probability...
        s+=x(10)                        // append a random digit
    System.out.print(x(9)<1 ? 0 : s);   // 10% chance of printing 0 instead
}

int x(int i) {
    return new java.util.Random().nextInt(i);
}

Старый ответ (до изменения правила)

void f(){if(Math.random()<.5)System.out.print('-');do System.out.print(new java.util.Random().nextInt(10));while(Math.random()>.02);}

Mathematica - 47

Round@RandomVariate@NormalDistribution[0,15*^5]

В основном, просто сгенерируйте случайное число, используя нормальное распределение с дисперсией, равной 1500000. Это даст целое число от -10 ^ 6 до 10 ^ 6 с вероятностью 49,5015%.

Python 2, 75 69 байт

from random import*;s=0;j=randrange
while j(12):s=s*9+j(-8,9)
print s

Тривиально проверить, что цикл while в середине может генерировать все целые числа (хотя и смещенные к нулю). «12» выбирается таким образом, чтобы примерно половина чисел превышала ± 10 ⁶ .

Старое решение:

Python 2, 44 байта

Основано на решении Mathematica .

from random import*;print int(gauss(0,8**7))

На самом деле не работает, потому что Python floatимеет только конечную точность.

Руби, 70

f=->{m=10**6
r=rand -m..m
r<1?(r>-5e5??-:'')+r.to_s+f[][/\d+/]:r.to_s}

Чтобы сделать возможным генерирование очень больших чисел, я возвращаю число в Stringвиде лямбды. Если это не разрешено, считайте 8 дополнительных символов (для puts f[]), чтобы сделать его программой, а не функцией.

объяснение

Генерация числа между -1,000,000и 1,000,000. Если число больше 1или равно , номер возвращается как String.

Если число меньше чем 1, функция вызывается рекурсивно, чтобы вернуть число вне диапазона номеров. Чтобы убедиться, что отрицательные числа также могут быть сгенерированы, -перед результирующим Stringбудет добавлен префикс a, если начальное число больше, чем -500,000.

Надеюсь, я правильно понял задачу!

Р, 38

library(Rmpfr)
round(rnorm(1,2e6,1e6))

Тяги из распределения Гаусса со средним значением 2 000 000, выбранным случайным образом, и стандартным отклонением 1 000 000, так что около 2/3 тиражей будут находиться в пределах 1 000 000 и 3 000 000 Распределение не ограничено, поэтому в теории это может генерировать любое целое число. Пакет Rmpfr заменяет R встроенные двойные числа с произвольной точностью.

Perl, 53 символа

print"-"if rand>.5;do{print int rand 10}while rand>.1

Я, конечно, не вижу смысла работать с целыми числами при печати одного :)

Имеет одинаковую вероятность печати числа с или без начального "-".

Печатает 1-значное число в 10% случаев, 2-значное число в 9% случаев, 3-значное число в 8,1% времени, 4-значное число в 7,29% времени, 5-значное число 6,56% времени, 6-значное число 5,9% времени и т. Д. Возможна любая длина с уменьшающейся вероятностью. Числа, состоящие из одной-пяти цифр, составляют около 41,5% выходных данных, а число 1 000 000 (или -1 000 000) - только 6 миллионов долей процента, поэтому выходное число будет выходить за пределы диапазона от 1 000 000 до 1 000 000, около 54,6. % времени.

И «0», и «-0» являются возможными выходами, что, я надеюсь, не является проблемой.

Perl, 114 символов

use Math::BigInt;sub r{$x=Math::BigInt->new(0);while(rand(99)!=0){$x->badd(rand(2**99)-2**98);}print($x->bstr());}

Сломать:

use Math::BigInt;               -- include BigIntegers
  sub r{                        -- Define subroutine "r"
    $x=Math::BigInt->new(0);    -- Create BigInteger $x with initial value "0"
      while(rand(99)!=0){       -- Loop around until rand(99) equals "0" (may be a long time)
        $x->badd(               -- Add a value to that BigInt
          rand(2**99)-2**98);   -- Generate a random number between -2^98 and +2^98-1
        }print($x->bstr());}    -- print the value of the BigInt

Вероятность получения значения между -1.000.000 и 1.000.000 стремится к нулю, НО это возможно.

Примечание. Эта подпрограмма может выполняться долго и при ошибке «Недостаточно памяти!» ошибка, но технически она генерирует любое целое число, как указано в вопросе.

Perl, 25

sub r{rand(2**99)-2**98;}

Генерирует случайное целое число в диапазоне +/- 2 ^ 99.

Сломать

sub r{                    -- Define subroutine "r"
     rand(2**99)          -- Generate a random integer between 0 and 2^99
                -2**98;}  -- Subtract 2^98 to get negative values as well

Протестировано с 1 миллионом образцов:

~5 are inside the range of +/-1.000.000
~999.995 are outside that range
= a probability of ~99,99% of generating an integer outside that range.
Compare that number to the probability of 2.000.000 in 2^99: It is approx. the same.

Это соответствует всем правилам:

• 1 целое число
• возможно любое целое число
• по крайней мере 50% (в моем случае 99,99%) всех сгенерированных целых чисел находятся вне диапазона +/- 1.000.000.

Это работает, потому что лежащий в основе генератор случайных чисел определяет равную вероятность для каждого сгенерированного бита, тем самым делая это и для сгенерированных целых чисел.
Каждое целое число имеет вероятность 1/2 ^ 99 для генерации.

Редактировать:

Мне пришлось увеличить показатель степени, чтобы генерировались большие целые числа. Я выбрал 99, потому что он делает код максимально коротким.

C #, 126 107 байт

string F(){var a=new System.Random();var b=a.Next(-1E6,1E6+1)+"";while(a.Next(1)>0)b+=a.Next(10);return b;}

Ungolfed:

string F()
{
    System.Random rand = new System.Random();
    string rtn = rand.Next(-1E6, 1E6 + 1) + "";
    while (rand.Next(1) > 0)
         rtn += a.Next(10);
    return rtn;
}

Шанс сгенерировать число n цифр составляет 1/2 ^ (n-10), что больше 0 для всех положительных n и 1/2 для n = 11.Также создает ведущие нули, которые, как представляется, не запрещены в исходном вопросе или в любом из его комментариев.

Perl, 62 байта

print $n=int rand(20)-10;while($n&&rand>.1){print int rand 10}

У меня была та же идея, что и у @Hobbs, - генерировать цифру за раз, но его код не удовлетворял добавленному требованию без ведущих нулей. Создание первой цифры вместо просто знака решило это. И если нет более короткого способа выхода, если мы напечатали ноль, или более короткого способа сгенерировать ведущие от -9 до 9, это должно сделать это для размера.

В цикле оболочки: while perl -e '...'; do echo;done |less

Я думаю, что это один из самых коротких, который не требует бесконечной оперативной памяти для решения проблемы. В качестве бонуса, результат не сильно смещен ни к чему, и время выполнения очень быстрое.

Я попытался использовать побитовое и сохранить символ в состоянии while, но я думаю, что это чаще всего оказывается истиной, поэтому цикл завершается раньше. Потребовалось бы больше символов для корректировки других вещей, чтобы противостоять этому, чтобы поддерживать вероятность генерации abs (выход)> 1M.

Javascript (73)

Это решение использует то, что вы можете построить число с основанием n , умножив предыдущее число на n и добавив цифру в основание n . У нас есть дополнительный, ..?..:..чтобы иметь возможность создавать все отрицательные целые числа. Следующий код должен быть протестирован в консоли браузера.

b=Math.round;c=Math.random;x=0;while(b(c()*99)){x*=b(c())?2:-2;x+=b(c())}

Вероятность получить целое число> = 2^1(или <= -(2^1)) равна вероятности того, что цикл будет выполнен 2 раза. Вероятность этого есть (98/99)^2. Следовательно, вероятность получить число, которое больше 2^20(или <= -(2^20)), составляет (98/99)^21 = 0.80881%. Это все теоретически, и при условии, что Math.random действительно случайный. Это явно не так.

Фрагмент, тестирующий этот код. Также более читабельным способом.

var interval = 0;
var epic_unicorns = 0;
var unicorns = 0;

function gimmerandom() {
  var b = Math.round;
  var c = Math.random;
  var x = 0;
  while( b(c()*99) ) {
    x *= b(c()) ? 2 : -2;
    x += b(c());
  }
  return x;
}

function randomcount() {
  var a = gimmerandom();
  if( a <= -1000000 || a >= 1000000 ) {
    epic_unicorns++;
  }
  unicorns++;
  updatedisplay();
}

function updatedisplay() {
  $('#num_of_epicunicorns').text( epic_unicorns );
  $('#num_of_unicorns').text( unicorns );
  var perc = unicorns > 0 ? Math.round( (epic_unicorns / unicorns) * 1000 ) / 10 : 0;
  $('#perc_of_unicorns').text( perc );
}

$('#a').on( 'click', function() {
  clearInterval( interval );
  interval = setInterval( randomcount, 10 );
} );

$('#b').on( 'click', function() {
  clearInterval( interval );
} );

$('#c').on( 'click', function() {
  epic_unicorns = 0;
  unicorns = 0;
  updatedisplay();
} );

updatedisplay();
  

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<span id="num_of_epicunicorns"></span> / <span id="num_of_unicorns"></span> (<span id="perc_of_unicorns"></span>%) were larger than 1.000.000 or less than 1.000.000.

<br><br>
<input type="button" id="a" value="Start"> 
<input type="button" id="b" value="Stop"> 
<input type="button" id="c" value="Reset">

GolfScript, 20 байт

0{)8.?rand}do.2&(*4/

Да, этот тоже немного медленный.

По сравнению с такими языками, как CJam и Pyth, GolfScript страдает многословным ключевым словом генерации случайных чисел (rand ). Чтобы преодолеть этот недостаток, мне нужно было найти способ использовать его только один раз.

Этот код работает путем многократного выбора случайного числа в диапазоне от 0 до 8 ⁸ -1 = 16 777 215 включительно и увеличения счетчика до тех пор, пока случайное число не окажется равным 0. Полученное значение счетчика имеет геометрическое распределение с медианой приблизительно -1 / log ₂ (1 - 1/8 ⁸ ) ≈ 11 629 080, что соответствует критерию «более 1 000 000, по крайней мере, 50% времени».

Увы, сгенерированное таким образом случайное число всегда строго положительно. Таким образом, дополнительная .2&(*4/часть необходима, чтобы позволить ей стать отрицательной или нулевой. Он работает, извлекая второй младший бит числа (который, таким образом, равен 0 или 2), уменьшая его до значения -1 или 1, умножая его на исходное число и деля результат на 4 (чтобы избавиться от младшие два бита, которые теперь соотносятся со знаком, а также позволяют результату стать нулевым). Даже после деления на 4 абсолютное значение случайного числа по-прежнему имеет медиану -1 / log ₂ (1 - 1/8 ⁸ ) / 4 ≈ 2 907 270, поэтому оно все равно проходит 50% тест.

JavaScript, 81 байт

Этот код выполняет все правила:

• Выведите любое целое число с положительной вероятностью
• Выведите целые числа вне диапазона +/- 1000000 с вероятностью не менее 50%
• Нет лидирующих 0в выводе

В качестве бонуса алгоритм работает с временной сложностью O (log ₁₀ n), поэтому он возвращает целое число почти мгновенно.

for(s="",r=Math.random;r()>.1;s+=10*r()|0);r(s=s.replace(/^0*/,"")||0)<.5?"-"+s:s

Это предполагает среду REPL. Попробуйте запустить приведенный выше код в консоли вашего браузера или используйте приведенный ниже фрагмент стека:

D.onclick = function() {
  for(s="", r=Math.random;r()>.1; s+=10*r()|0);
  P.innerHTML += (r(s=s.replace(/^0*/,"") || 0) <.5 ?"-" + s : s) + "<br>"
}

<button id=D>Generate a random number</button><pre id=P></pre>

Алгоритм :

• Добавляйте случайные цифры в строку sдо тех пор, пока Math.random() > 0.1.
• Исходя из Math.random() > 0.5, сделайте число отрицательным (добавив строку sс -).

Этот алгоритм не имеет равномерного распределения по всем целым числам. Целые числа с большим числом цифр менее вероятны, чем младшие. В каждой итерации цикла есть вероятность 10%, что я остановлюсь на текущей цифре. Я просто должен убедиться, что я останавливаюсь после 6 цифр более 50% времени.

Это уравнение от @nutki объясняет максимальное значение процента вероятности остановки на основе вышеуказанного условия:

1 - 50%^(1/6) ≈ 0.11

Таким образом, 0,1 находится в пределах досягаемости, чтобы удовлетворить все три правила вопроса.

TI-BASIC, 14 байтов

1-2int(2rand:randNorm(AnsE6,9

Подобно R-ответу @ ssdecontrol, он основан на гауссовском распределении со средним значением -1 000 000 или 1 000 000, выбранным случайным образом, и стандартным отклонением 9. Распределение не ограничено, поэтому в теории это может генерировать любое целое число.

Пояснение :

1-2int(2rand     - get a random integer 0 or 1, then multiply by 2 and subtract 1
:                - this gives the number 1 or -1 (with equal probability) to Ans
randNorm(AnsE6,9 - displays Gaussian distribution with mean (Ans * 1,000,000) and std. dev. 9

Баш, 66

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/random

Он почти всегда печатает 5000000. Но если он нашел правильное число в /dev/random , он вместо этого напечатает это число.

И этот быстрее:

LANG=C sed -r '/^-?(0|[1-9][0-9]*)$/q;s/.*/5000000/;q'</dev/urandom

C ++, 95 байт

void f(){int d=-18,s=-1;while(s<9){d=(rand()%19+d+9)%10;cout<<d;s=9-rand()%10*min(d*d+s+1,1);}}

Expanded:

void f() {
    int d=-18,s=-1;
    while(s<9) {
        d=(rand()%19+d+9)%10;
        cout<<d;
        s=9-rand()%10*min(d*d+s+1,1);
    }
}

Объяснение:

Функция продолжает печатать последовательные случайные цифры, пока переключатель со случайным значением не примет необходимое значение для остановки функции. d - это переменная, в которой хранится значение следующей цифры для печати. s - переменная переключения, которая принимает случайные целочисленные значения в интервале [0, 9], если s == 9, то больше никаких цифр не печатается, и функция заканчивается.

Переменные d и s инициализируются, чтобы дать специальную обработку первой цифре (беря ее из интервала [-9, 9], и если первая цифра равна нулю, то функция должна заканчиваться, чтобы избежать начальных нулей). Значение d может быть назначено как d = rand ()% 10, но тогда первая цифра не может быть отрицательной. Вместо этого d присваивается как d = (rand ()% 19 + d + 9)% 10 и инициализируется в -18, поэтому первое значение d будет варьироваться от [-9, 9], а следующие значения всегда будут в диапазоне от [0 9].

Переменная s варьируется случайным образом от [0, 9], и если s равно 9, функция завершается, поэтому после печати первой цифры следующая будет напечатана с вероятностью 90% (при условии, что rand () действительно случайна, и чтобы удовлетворить третье условие). s можно легко назначить как s = rand ()% 10, однако, есть исключение: если первая цифра равна нулю, функция должна завершиться. Для обработки такого исключения s был назначен как s = 9-rand ()% 10 * min (d * d + s + 1,1) и инициализирован как -1. Если первая цифра равна нулю, min вернет 0, а s будет равно 9-0 = 9. Назначение переменной s всегда будет в диапазоне от [0, 9], поэтому исключение может произойти только в первой цифре.

Характеристики (при условии, что rand () действительно случайный)

• Целое число печатается цифра за цифрой с фиксированной вероятностью 90% печати другой цифры после печати последней.

• 0 - это целое число с наибольшей вероятностью печати, с вероятностью приблизительно 5,2%.

• Вероятность печати целого числа на интервале [-10 ^ 6, 10 ^ 6] составляет примерно 44% (расчет здесь не написан).

• Положительные и отрицательные целые числа печатаются с одинаковой вероятностью (~ 47,4%).

• Не все цифры печатаются с одинаковой вероятностью. Например: в середине печати целого числа, если последняя цифра была 5, цифра 3 будет иметь немного меньшую вероятность быть напечатанной следующей. В общем, если последняя цифра была d, цифра (d + 18)% 10 будет иметь немного меньшую вероятность быть напечатанной следующей.

Пример выходов (10 исполнений)

-548856139437
7358950092214
507
912709491283845942316784
-68
-6
-87614261
0
-5139524
7

Process returned 0 (0x0)   execution time : 0.928 s
Press any key to continue.

Баш, 42 байта

printf "%d\n" 0x$(xxd -p -l5 /dev/random)
/ dev / random в OSX - это случайные байты, которые xxd -p -l5преобразуют 5 символов ascii в шестнадцатеричные и преобразуют printfих в десятичный формат.

Pyth , 11 байт

WOyG~ZtOT)Z

Примечание: эта программа, вероятно, завершится с ошибкой памяти на любом реальном компьютере. Чтобы проверить это, попробуйте заменить Gболее короткой строкой, такой как в этом коде, которая генерирует числа в среднем около 28000:

pyth -c 'WOy"abcdefghijklm"~ZtOUT)Z'

Этот код зацикливается, добавляя случайное число от -1 до 8 Zс вероятностью 2 ^ -26 выхода из цикла при каждом повторении. Вероятность 2 ^ -26 достигается выбором случайного элемента ( O) из набора всех подмножеств ( y) алфавита ( G).

Технические детали и обоснование:

Вероятность 2 ^ -26 определяется двумя фактами: yпри вызове последовательностей это функция набора мощности, которая строит список всех подмножеств входных данных. Поскольку Gдлина входного файла составляет 26 символов, в этом наборе мощности yGсодержится 2 ^ 26 записей. OyGвыбирает случайный элемент из этих 2 ^ 26 записей. Именно одна из этих записей, пустая строка, при передачеW в цикл while. Таким образом, существует вероятность 2 ^ -26 выхода из цикла каждый раз.

В любом фиксированном количестве циклов цикла K вероятность получения числа K * 3,5 + m и получения K * 3,5 - m равна, потому что каждая последовательность суммирований, которая достигает одного итога, может быть инвертирована, -1 -> 8, 0 -> 7 и т. Д., Чтобы добиться другого. Кроме того, числа ближе к K * 3.5 явно более вероятны, чем числа дальше. Таким образом, если K> 2000000 / 3.5 = 571428.5, вероятность получения числа свыше 1000000 превышает 75%, поскольку некоторые из результатов, превышающих это число, можно сопоставить один к одному со всеми результатами ниже этого число, а верхняя половина меньше, может быть приведено в соответствие один к одному с теми, кто меньше 1000000. Вероятность получения не менее 571429 циклов составляет (1-2 ^ -26) ^ 571429, что не менее чем (1-2 ^ -26 * 571429), ожидаемое количество выходов из цикла за первые 571429 попыток, что составляет 99,1%. Таким образом, в 99,1% или более испытаний существует 75% или более шансов получить как минимум 1000000, так что существует более 50% шансов получить более 1000000.

Этот код основан на поведении, Oкогда ошибка была случайно введена 3 дня назад и была исправлена ​​сегодня. Он должен работать на любой версии Pyth 3 до 22 декабря или после сегодняшнего дня. Следующий код эквивалентен и всегда работал:

WOyG~ZtOUT)Z

Java, 113 байт

void g(){String a=Math.random()>0?"10":"01";for(;Math.random()>0;)a+=(int)(Math.random()*2);System.out.print(a);}

Эта программа печатает двоичное число в стандартный поток вывода. Возможно, вам придется подождать некоторое время, потому что вероятность того, что число закончится (или оно будет положительным), равна приблизительно 0. Идея, что абсолютное значение сгенерированного числа составляет менее 1 миллиона, забавна, но возможна.

Ungolfed:

void g(){
    String a=Math.random()>0?"10":"01";             //Make sure there are no trailing zeroes.
    for(;Math.random()>0;)a+=(int)(Math.random()*2);//Add digits
    System.out.print(a);                            //Print
}

Образец вывода: будет публиковаться, когда число будет сделано, генерируется.

Ява (JDK) , 140 127 байт

()->{int i;var o=System.out;for(o.print(i=(int)(19*Math.random())-10);i!=0&Math.random()<.9;)o.print((int)(11*Math.random()));}

-13 bytes добавив больше логики в заголовок цикла - благодаря @ceilingcat

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