3 вложенных цикла: оптимизация простой симуляции для скорости

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

while...: 
    #population changes by (-1, 0, +1, +2) for each alien
    n += np.random.randint(-1,3, size=n).sum()

Используя ваш точный код для всего остального (вы, вероятно, могли бы найти другие оптимизации в другом месте), я пошел с 21,2 секунды до 4,3 секунды, используя это одно изменение.

Без изменения алгоритма (то есть решения с помощью метода, отличного от Монте-Карло), я не вижу никаких других радикальных изменений, которые могли бы сделать это намного быстрее, пока вы не начнете компилировать в машинный код (что, к счастью, очень легко, если у вас установлена numba),

Я не буду давать полное руководство по своевременной компиляции, которую выполняет numba, но вместо этого я просто поделюсь своим кодом и запомню изменения, которые я сделал:

from time import time
import numpy as np
from numpy.random import randint
from numba import njit, int32, prange

@njit('i4(i4)')
def simulate(pop_max): #move simulation of one population to a function for parallelization
    n = 1
    while 0 < n < pop_max:
        n += np.sum(randint(-1,3,n))
    return n

@njit('i4[:](i4,i4)', parallel=True)
def solve(pop_max, iter_max):
    #this could be easily simplified to just return the raio of populations that die off vs survive to pop_max
    # which would save you some ram (though the speed is about the same)
    results = np.zeros(iter_max, dtype=int32) #numba needs int32 here rather than python int
    for i in prange(iter_max): #prange specifies that this loop can be parallelized
        results[i] = simulate(pop_max)
    return results

pop_max = 100
iter_max = 100000

t = time()
print( np.bincount(solve(pop_max, iter_max))[0] / iter_max )
print('time elapsed: ', time()-t)

Компиляция с распараллеливанием снижает скорость оценки примерно до 0,15 секунды в моей системе.

Без проблемного решения, требуется около 5 с для моделирования 100 КБ:

from random import choices

def simulate_em():
    def spwn(aliens):
        return choices(range(-1,3), k=aliens)

    aliens = {1:1}
    i = 1
    while aliens[i] > 0 and aliens[i] < 100:    
        i += 1
        num = aliens[i-1]
        aliens[i] = num + sum(spwn(num))

    # commented for speed
    # print(f"Round {i:<5} had {aliens[i]:>20} alien alive.")
    return (i,aliens[i])

Тестирование (около 5 секунд на pyfiddle.io):

from datetime import datetime

t = datetime.now()    
d = {}
wins = 0
test = 100000
for k in range(test):
    d[k] = simulate_em()
    wins += d[k][1]>=100

print(1-wins/test)         # 0.41532
print(datetime.now()-t)    # 0:00:04.840127

Так что для 100к тестов требуется около 5 секунд...

Выход (из 2 прогонов):

Round 1     had                    1 alien alive.
Round 2     had                    3 alien alive.
Round 3     had                    6 alien alive.
Round 4     had                    9 alien alive.
Round 5     had                    7 alien alive.
Round 6     had                   13 alien alive.
Round 7     had                   23 alien alive.
Round 8     had                   20 alien alive.
Round 9     had                   37 alien alive.
Round 10    had                   54 alien alive.
Round 11    had                   77 alien alive.
Round 12    had                  118 alien alive.

Round 1     had                    1 alien alive.
Round 2     had                    0 alien alive.

С помощью amount_of_aliens + sum по choices(range(-1,3),k=amount_of_aliens) вы упрощаете суммирования и быстрее выполняете свой запрос? Если количество инопланетян падает ниже 0, они вымерли.