Пока толстый сохнет, худой сдохнет
Старинная русская поговорка

Недавно хабраюзер @TraPhro опубликовал хорошую статью на тему Санкт-Петербургского парадокса, придуманного когда-то Даниилом Бернулли для иллюстрации фундаментального ограничения классической теории вероятности с точки зрения рисковых решений, принимающихся людьми.

Перед тем, как читать эту статью, рекомендуем ознакомиться с предложенными ссылками, дабы освежить в памяти суть предмета.

Назовем игрой Бернулли следующее. Игрок платит денежную сумму S (серебряных рублей Российской Империи) за игру, после чего подбрасывает честную математическую монетку до тех пор, пока не выпадет решка. Выигрыш игрока составляет 2^H, где H - число выпавших подряд орлов.

Легко показать, что матожидание такой игры стремится к бесконечности. С вероятностью 1/2 в последовательности не будет орлов и мы получим за неё 1 рубль. С вероятностью 1/4 выпадет один орел, и это 2 рубля. С вероятностью 1/8 вы получите 4 рубля, и так далее. Матожидание всех этих исходов: 1/2 + 2/4 + 4/8 + ... -> \infty.

Однако вряд ли найдется человек, который согласился бы играть в эту игру даже при S=20.

Какова же справедливая цена игры?

В статье @TraPhro дается одно из возможных разрешений парадокса: через так называемую "Функцию полезности". Предполагается, что люди интуитивно оценивают свой потенциальный выигрыш не линейно, а согласно некой монотонно возрастающей функции со стремящейся к нулю производной. @TraPhro не дает явного выражения для функции полезности, в Википедии же в качестве простейшей модели предлагается логарифмическая функция f_{utility} = ln (\frac{Y}{S}), где Y - выигрыш, S - стоимость игры. Можно показать, и в статье в Википедии показывается, что в этом случае справедливая цена игры S=2.

Логарифмическая функция полезности предполагает, что люди воспринимают приращения или убытки своего капитала не в абсолютных, а в относительных величинах. Радость богача, что ему удалось накопить $10 000 000 в то время, когда год назад у него было всего лишь $1000 000 схожа с радостью не столь обеспеченного человека, наблюдающего увеличение своего капитала с $1000 до $10 000 , хотя в абсолютных величинах прирост капитала миллионера гораздо больше.

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

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

Ограничение банка казино

Когда мы играем в игру Бернулли, например, с S=20, мы закладываем в эту игру возможность того, что с очень низким шансом, но всё-таки может случиться так, что игрок выбросит 20 и более орлов подряд, после чего казино окажется должно игроку 2^{20} = 1 048 576 рублей.

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

Таким образом, мы получаем ограничение банка казино.

S_{K} = \frac{log_2 K}{2}

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

Готовы сыграть в эту игру при S = 20? Чтобы выйти в плюс, вам нужно всего лишь выкинуть пять орлов подряд, а дальше - экспоненциальный рост вплоть до максимума в миллион с лишним! Кажется выгодной сделкой?

Ограничение длительности игры

Возьмем длинную случайную цепочку B[T] из T = 2^{32} последовательностей из серии орлов, оканчивающихся решкой. Перед нами больше четырех миллиардов игр Бернулли, случившихся подряд - достойная выборка, на которой должны проявиться все основные статистические эффекты нашей модели.

def generate_B(T, seed=42):
    """
    Генерирует массив B длины T (uint8),
    где B[i] — число орлов в i-й игре Бернулли.
    """
    rng = np.random.default_rng(seed)

    B = np.empty(T, dtype=np.uint8)

    chunk_size = 2**24

    offset = 0
    while offset < T:
        size = min(chunk_size, T - offset)

        B[offset:offset + size] = -np.log2(rng.random(size))
        offset += size

    return B

Сгенерируем случайную последовательность:

B = generate_B(T) # Генерация идет у меня около 40 секунд

С такой длинной последовательностью у нас возникают проблемы даже при попытке посчитать её среднее арифметическое. Написав что-то вроде

np.mean(2 ** B) # 3.9998945547267795

мы получаем результат, близкий к 4, что совершенно не согласуется с теорией. Проблема в арифметике малых целых чисел. При возведении 2^B numpy пытается сохранить тип, что при значениях больше 256 дает ошибку переполнения, которую numpy просто обращает в 0. Отказаться от np.uint8 же мы не хотим; уже при int64 хранение последовательности займет 32 Gb RAM, а оперативная память нынче дорогая.

Нам повезло: если бы мы работали с int32, мы могли бы легко попасться в этом численном эксперименте на ту же ошибку в гораздо более редком сценарии и не заметили бы её.

Правильный путь такой:

B_values, B_counts = np.unique(B, return_counts=True)

B_summ = 0

for i in range(len(B_values)):
    B_value = B_values[i]
    B_count = B_counts[i]

    B_summ += B_count*(2**int(B_value))

B_mean = B_summ/T # 16.525583560578525

Построим гистограмму распределения длин серий орлов:

Гистограмма распределения длин серий орлов
Гистограмма распределения длин серий орлов

Видно, что за исключением последовательностей длиной 30, 31, 32, которых нам повезло получить по одной штуке, распределение очень близко к экспоненциальному. Ничего необычного в этом нет: мы убедились, что всё корректно работает.

Откуда берется число B_mean = 16.52 ? Попробуем взять T поменьше:

log_2(T)

B_mean

32

16.52

30

19.05

28

13.49

26

13.80

24

12.78

22

11.59

20

13.76

16

11.00

12

5.96

Видно, что средний выигрыш "гуляет" где-то в районе log_2(T)/2 , отклоняясь в ту или иную сторону на несколько пунктов при удаче или неудаче игрока. Это легко объяснить математически.

Шанс на выпадение на 2^{32} серии игр события, которое происходит с вероятностью 2^{-40}, составляет всего 2^{-8}. Это событие с высокой вероятностью не выпадет и не внесет свой вклад в общую сумму. Наш статистический аппарат качественно работает с теми событиями, которые выпадают много раз, то есть состоящими из относительно малого числа орлов. Мы видим, что в той серии, где мы бросали 2^{30}, нам очень повезло, и среднее оказалось аж 19 - но у любого везения есть ограничения, и шансы на получение в такой серии среднего, отклонящегося от половины логарифма экспоненциально падают с ростом этого отклонения.

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

S_{T} = \frac{log_2 T}{2}

Ограничение риска игры

Будем считать банк казино условно-неограниченным. Также будем считать, что агент имеет 0 рублей начального капитала, однако может неограниченно брать кредит под игру.

Промоделируем историю игр 16 агентов, которые играют в одну и ту же ранее сгенерированную цепочку игр B, однако условия по S для них различаются: стоимость игры растет от 1 до 16 рублей. На серии игр в 2^{32} с S>16 игра не выгодна из-за отсечения низковероятных хвостов.

Введем функцию C(S) как максимальный долг банку со стороны агента S за всю историю. Можно воспринимать C(S) как стартовый капитал на игру, при котором агент никогда не уйдет в минус и не будет вынужден брать кредит.

def calc_C(S, B, chunk_size=2**24):
    """
    Быстро вычисляет C(S) для массива B (uint8),
    обрабатывая данные чанками.
    """
    capital = 0
    min_capital = 0

    T = len(B)
    offset = 0

    while offset < T:
        size = min(chunk_size, T - offset)

        # Небольшая оптимизация
        cs = np.cumsum((1 << B[offset:offset + size].astype(np.int64)) - S)

        local_min = capital + cs.min()
        if local_min < min_capital:
            min_capital = local_min

        capital += cs[-1]
        offset += size

    return -min_capital

C_values = []
S_values = np.arange(1, 17)

for S in S_values:
    C = calc_C(S, B)
    C_values.append(C)
Графики C(S) для B(2^32, seed=42)
Графики C(S) для B(2^32, seed=42)

При S < S_{T} C(S) не зависит от длины последовательности T, поскольку агент с высокой долей вероятности либо сливается в начале игры, либо ему удается заработать достаточный капитал, чтобы уверенно чувствовать себя при заданном S всю дальнейшую игру.

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

Характер экспоненциального роста близок к R\cdot 4^S где R - коэффициент где-то от 0 до 1.

График колебания коэффициента
График колебания коэффициента

Таким образом, мы получаем ограничение риска игры.

S_{С} = log_4(С/R)

Коэффициент риска R подбирается исходя из готовности игрока рисковать. Можно предположить R=0.5.

Откуда берется 4 в основании логарифма?

Типичный сценарий выживания игрока подразумевает каскад редких событий, до которых он стремится дожить, растрачивая капитал за счет S и лишь частично компенсируя дрейф в полной мере за счет частых событий. К примеру, если S = 10, то для выживания игроку нужно дождаться хотя бы одного события один-на-миллион с двадцатью и более орлами. В противном случае, матожидание прибыли от более частых событий не перекрывает дрейф S. Среднее время ожидания для такого события: T = 2^{2 S}

Во время ожидания капитал игрока будет тратиться, в среднем, со скоростью 0.5 (более частые, но не спасающие игрока в полной мере события вроде 19 орлов он, вероятно, дождется).

Значит, для выживания необходимо, что бы выполнялось

C > 0.5 \cdot  2^{2 S}, что дает нам R = 0.5 и степень, равную 4. Однако спасительное событие может прийти раньше или позже намеченного срока, что заставляет нас в некоторых случаях калибровать R в ту или иную сторону.

Управление рисками

Мы получили три независимых фундаментальных ограничения на ставку S:

  1. Ограничение банка: S_K = 0.5 \log_2 K (зависит от размера банка казино)

  2. Ограничение времени: S_T = 0.5 \log_2 T (зависит от числа игр, в которых мы готовы участвовать)

  3. Ограничение риска: S_С = \log_4(С/R) (зависит от начального капитала игрока и его склонности рисковать)

Эти ограничения распространяются куда шире игры Бернулли.

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

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

Третье ограничение - самое интересное. Для его иллюстрации взглянем ещё раз на пример из исходной статьи.

Богатый шоумен MrBeast, желая развлечь свою аудиторию, предлагает случайному обывателю выбор: получить $1 000 000 с шансом 100% либо в десять раз больше, но с шансом в 50%. С точки зрения матожидания следует рисковать. Однако многие предпочтут забрать гарантированную сумму.

Закон убывающей полезности говорит нам, что для среднего обывателя как $1 000 000, так и $10 000 000 - огромные, плохо различимые в своей огромности суммы, на которые он может полностью обеспечить свои потребности на текущий момент. Но здесь есть что-то более глубокое.

Предположим, что наш счастливчик, оказавшись на шаге от $1 000 000 , обладал до встречи MrBeast совокупным капиталом в $500 000 , куда включается всё его имущество от трусов до бабушкиной квартиры. MrBeast не раздает людям просто так большие деньги -- они должны служить интересам его шоу -- значит наш герой прошел уже через многое, дабы послужить интересам шоу MrBeast. К моменту, когда нашего героя ставят перед выбором, его виртуальный капитал составляет не $500 000 а $1 500 000 , поскольку он как бы уже "заработал" своей удачей и ловкостью свой приз. В этой ситуации ему требуется рискнуть 2/3 своего капитала.

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

Рассмотрим другой пример, когда тот же самый обыватель выиграл либо $100 либо право побороться с шансом в 50% за $1000 - в этом случае многие предпочли бы журавля синице, поскольку $100 для человека с капиталом в $500 000 - куда менее чувствительная сумма.

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

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

В классической теории инвестиций Келли ставка рассчитывается из общего банка игрока. Данная теория рассматривает ставку как долю от банка игрока; эта доля рассчитывается из оценок события со стороны игрока и со стороны биржи. Теория Келли хороша, но по сюжету Бернулли видно, что она не так уж хорошо работает со сценариями, когда мы обрабатываем редкие шансы.

Мы получили наш результат - логарифмический закон соотношения рисковой ставки с капиталом - через численный эксперимент. Можно ли построить строгое математическое обоснование нашей модели? Оказывается, да!

Непрерывная игра Бернулли

Пусть есть случайная величина, распределенная по закону f(x) = L e^{-L x} где L - некий фиксированный параметр. Предложим игроку заплатить S рублей и сгенерировать число по этому закону; в этом случае он получит e^{L x} выигрыша.

Оказывается, распределение выигрыша не зависит от L:

\mathbb{P}(Y > y)= \mathbb{P}(X > \tfrac{1}{L}\ln y)= e^{-L \cdot \frac{1}{L}\ln y}= \frac{1}{y}, \quad y \ge 1\mathbb{P}(Y > y) = y^{-1}

Отсюда:

  • \mathbb{E}[Y] = \infty,

  • но хвост настолько тяжёлый, что среднее неинформативно.

Мы получили непрерывный аналог Санкт-Петербургской игры.

Рассмотрим процесс, в котором ты раз за разом меняешь величину своего капитала W, играя в эту игру.

W_{n+1} = W_n - S + Y_n

где Y_n - выигрыш.

Ты желаешь никогда не достичь состояния банкротства W < 0. Каков максимальный S, при котором вероятность разорения за разумное время мала?

Закон допустимого риска

Из хвоста:

\mathbb{P}(Y > y) = \frac{1}{y}

Вероятность получить выигрыш \ge z:

\sim \frac{1}{z}

Чтобы компенсировать потери порядка S n, нужен выигрыш:

z \sim S n

Вероятность дождаться его:

\sim \frac{1}{S n}

Среднее время ожидания:

n \sim \frac{C}{S}

Мы теряем капитал со скоростью S. Наш запас прочности — время n \approx C/S. Чтобы выжить, нам нужно, чтобы за это время случилось крупное событие, перекрывающее убытки. Вероятность такого события

\mathbb{P}(\text{дожить}) \sim \frac{1}{S} \log C

Отсюда:

\boxed{\text{Допустимый риск } S \sim \log C}

Почему это не психологический феномен, а закон природы процесса?

Потому что:

  • распределение выигрышей — степенное;

  • капитал — конечен;

  • разорение — поглощающее состояние;

  • большие выигрыши редки экспоненциально;

  • дожить до них можно только с логарифмически растущим капиталом.

А значит, мы приходим к главной формуле для любой игры Бернулли:

Риск должен быть долей логарифма капитала.

Вот чему учит нас Санкт-Петербургский парадокс.

Комментарии (13)


  1. sic
    11.01.2026 20:42

    UPD: игнорируйте это, я решал немного другую задачу!

    Скрытый текст

    Вот как раз после исходной статьи стало интересно провести небольшое моделирование, и я удивлен, что у Вас получилось B_mean = 16.52, а у меня в среднем 36 (на 2^32 исходов). Даже для ста миллионов игр, уже в среднем 30 получается. Возможно ошибка в:

    B[offset:offset + size] = -np.log2(rng.random(size))

    log2 не находит положение первого взведенного бита корректно, ну для примера log2(1000b) очень близок к log2(0111b) но вот только в первой игре выигрышь все 32 рубля, а во второй всего 16 (или 0, если считать trailing нули, а не ведущие). На самом деле я не вполне понимаю еще из-за наличия минуса перед логарифмом, но в любом случае 2 ** B не соответствует выигрышу никаким образом. Ожидается что-то похожее на:

    static long PlayGame()
    {
        ulong x = rng.NextUInt64();
        int tosses = TrailingZerosBinary(x);
        return 1L << (tosses + 1); // prize value
    }
    Скрытый текст

    Совсем говнокод, у меня древний .NET и нет нормальной TrailingZeros, но как-то так:

    static int TrailingZerosBinary(ulong x)
        {
            if (x == 0) return 64;
            int n = 63;
            if ((x & 0x00000000FFFFFFFFUL) > 0) { n -= 32; } else x >>= 32;
            if ((x & 0x000000000000FFFFUL) > 0) { n -= 16; } else x >>= 16;
            if ((x & 0x00000000000000FFUL) > 0) { n -= 8; } else x >>= 8;
            if ((x & 0x000000000000000FUL) > 0) { n -= 4; } else x >>= 4;
            if ((x & 0x0000000000000003UL) > 0) { n -= 2; } else x >>= 2;
            return n - (int)(x & 1);
        }

    Еще раз все у себя перепроверил, в среднем B_meanуже после 20000 игр достигает вашего значения (но на таком небольшом количестве игр оно не очень хорошо стабилизируется). По сути конечно мало меняет, а по факту - много.


    1. celen Автор
      11.01.2026 20:42

      Не может быть у вас средний выигрыш 36 для серии из 2^32 исходов. Это невозможный уровень удачи. Может быть, у вас другая модель, например вы "выплачиваете" в своей симуляции агенту вдвое больший выигрыш, чем я? Тогда это то же что и выигрыш у меня 18, что в принципе допустимо.

      На серии в 20000 ~ 2^14 по моей модели ожидается средний выигрыш 7 +- 3. Выход за этот диапазон явно показывает численную несогласованность наших моделей. Но если вы достигли моего значения (16) выплачивая игроку вдвое больше, то на самом деле вы достигли 8.


      1. sic
        11.01.2026 20:42

        Это так, я взял игру из статьи на которую Вы ссылаетесь, а там стартовый выигрыш 2 рубля :) Гоняю теперь с таким же условием, что у Вас, теперь в среднем что-то близкое получается, можно сказать тоже самое, потому что от запуска к запуску в диапазоне 10% гуляет. Теоретически на некоторых запусках совсем все что угодно может быть.

        Скрытый текст

        Буквально на десятый прогон словил джекпот.

        [10^10] Игр: 4 100 000 000
        Средний выигрыш: $153,02
        Максимальный выигрыш: $549 755 813 888

        Если этот выброс исключить (вот насколько реален кстати), то да, средний средний выигрыш это 18 с небольшим.

        Но я не понял этого трюка с логарифмом все равно. Он же вещественный, как-то должен к целому приводиться, отбрасыванием бит? И почему со знаком минус записывается?


        1. celen Автор
          11.01.2026 20:42

          Хехе, it's magic.

          Надеюсь, мой комментарий ниже про гистограмму убеждает в том, что это *работает*.
          Технически, B[offset:offset + size] = -np.log2(rng.random(size)) осуществляет следующую цепочку операций: генерацию случайного числа float64 из равномерного распределения [0;1], взятие от этого логарифма и приведение этого логарифма к целому uint8 (с минусом) через отбрасывание дробной части. Это эквивалентно честной игре Бернулли, но гораздо быстрее. Ещё это эквивалентно тому, что бы взять равномерно распределенный float64 из [0;1], оторвать от его записи экспоненциальную часть и сконвертировать её в uint8. Причем так было бы даже ещё быстрее, но в python я не смог быстро придумать, как эту побитовую операцию грамотно осуществить.


          1. funca
            11.01.2026 20:42

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


            1. celen Автор
              11.01.2026 20:42

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

              А вообще эта новая фича хабра sourcecraft достойно справляется с задачей объяснения кода.


              1. funca
                11.01.2026 20:42

                не сколько для чтения непосредственно кода, сколько для его проверки на вашей стороне

                Зависит от того, что понимать под проверкой кода. В представленном варианте не понятно как этот код вообще согласуется с исходной задачей. В статье нет таких формул, которые бы доказывали эквивалентность оптимизированной версии исходному алгоритму. Что тут можно проверить?

                Смущает ещё то, что сам по себе питон не ограничивает разрядность целых и позволяет работать с бесконечными последовательностями. В самой задаче вроде нет ни чего, что бы вынуждало держать в памяти результаты всех игр. Поэтому описанние возникших проблем с памятью и разряднотстью в numpy выглядит как какой курьез не по делу. Можно-ли было обойтись вообще без numpy?


                1. sic
                  11.01.2026 20:42

                  Ну считайте что я все проверил. У меня по-другому сделано, но результаты совпадают. Вплоть до того, что небольшой недочет и у меня и автора одинаковый, больше 2^64 выигрыши не учитывются. Но, у меня уже больше часа программа работает и только 2^41 выбилось и вот уже триллиарды игр. До 2^64 я все равно не досчитаю никогда (порядка сотен лет с такой скоростью, да и смысла никакого в этом нет, log2(T)/2 там и есть).

                  А в памяти нужно держать из-за того что автор по этим данным несколько исследований делает, и результаты должны быть согласованны. Кроме того питон не ахти как быстро данные игр генерит даже после его оптимизаций, а наивный подход был бы еще на порядки медленее. И если LLM спросить, про трюк с логарифмом она расскажет.


                  1. celen Автор
                    11.01.2026 20:42

                    2^41? Мое уважение.


    1. celen Автор
      11.01.2026 20:42

      Мой оптимизированный код для вычисления B может сбивать с толку, но он дает корректную гистограмму B. Вот какое распределение я получаю :

      >> print(B_values)
      array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
             17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32],
            dtype=uint8)
      >> print(B_counts/T)
      array([4.99996199e-01, 2.50013790e-01, 1.24990516e-01, 6.25037584e-02,
             3.12467129e-02, 1.56276303e-02, 7.81149906e-03, 3.90555570e-03,
             1.95188215e-03, 9.76342708e-04, 4.87847719e-04, 2.44213734e-04,
             1.22004421e-04, 6.09667040e-05, 3.05534340e-05, 1.52424909e-05,
             7.60983676e-06, 3.83588485e-06, 1.91642903e-06, 9.79984179e-07,
             4.75673005e-07, 2.36090273e-07, 1.16880983e-07, 5.98374754e-08,
             2.56113708e-08, 1.39698386e-08, 8.38190317e-09, 3.72529030e-09,
             1.62981451e-09, 6.98491931e-10, 2.32830644e-10, 2.32830644e-10,
             2.32830644e-10])

      То есть, с хорошей точностью, у меня половина - нули, четверть - единицы, восьмая часть - двойки и так далее. Код суммы так же правильный, он согласуется с теорией и достаточно простой.


  1. strikingamaranth
    11.01.2026 20:42

    Пока толстый сохнет, худой сдохнет -- Старинная русская поговорка

    вроде бы все эти поговорки были записаны в конце 19 века на нижегородской ярмарке со слов нетрезвых проституток и в обиходе до этого не были


  1. artptr86
    11.01.2026 20:42

    Астрологи провозгласили день Санкт-Петербургского парадокса?


  1. Femistoklov
    11.01.2026 20:42

    Вероятно, основное здесь - ограничение времени? Необходимость играть бог знает сколько триллионов раз для выигрыша сводит на нет всю практическую пользу игры.