1. Como sua estratégia se comporta na média se você repetir a simulação acima 100 vezes, 1.000 vezes? Como testar isso em Python? Implemente. Dica: encapsule o código da questão anterior em uma função chamada simulacao que retorne o lucro final. Com esta função, poderá chamá-la quantas vezes desejar e calcular o lucro médio das simulações executadas.

Passo 1

O que a questão pede (resumido, bem claro):
  • Você já tem uma simulação (da “questão anterior”) que produz um único valor de lucro final quando executada uma vez.
  • A pergunta agora é: como essa sua estratégia se comporta na média se você repetir essa simulação 100 vezes e 1.000 vezes?
  • Você precisa testar isso em Python: encapsular o código da simulação em uma função chamada simulacao que retorne o lucro final, e então chamar essa função várias vezes para calcular a média dos lucros.
Informações relevantes que temos (ou assumimos, conforme dica do enunciado):
  • Existe um código que, quando executado, gera um lucro final (um número real). Vamos colocar esse código dentro de uma função simulacao() que retorna esse número.
  • Queremos repetir a execução dessa função n vezes e calcular estatísticas da amostra (média, desvio padrão, erro padrão, intervalo de confiança).
  • Os valores pedidos explicitamente são para n= 100 e n= 1.000.

Passo 2

Breve aula (didática e direta) sobre por que repetir várias vezes e que estatísticas olhar
  • Por que repetir? Cada execução da sua simulação produz um valor aleatório (lucro) porque o modelo tem componente estocástico. Repetindo muitas vezes obtemos uma amostra \{X_1,X_2,\dots,X_n\} dos lucros.
  • Média amostral: a estatística principal é a média amostral
\bar{X}=\frac{1}{n}\sum_{i=1}^{n} X_i,
que estima o lucro esperado da sua estratégia. Aqui X_i é o lucro da i-ésima simulação e n é o número de repetições.
  • Desvio padrão amostral: mede dispersão
s=\sqrt{\frac{1}{n-1}\sum_{i=1}^{n} (X_i-\bar{X})^2}.
  • Erro padrão da média: quantifica a incerteza na estimativa de \bar{X}
\text{SE}=\frac{s}{\sqrt{n}}.
  • Intervalo de confiança aproximado de 95\% (pela aproximação normal quando n é razoável):
\bar{X}\pm 1,96\cdot \text{SE}.
  • Lei dos grandes números: conforme n cresce, \bar{X} tende a se aproximar do valor esperado verdadeiro. Na prática, ao aumentar de 100 para 1.000 repetições esperamos que a média amostral fique mais estável (menor erro padrão), porque \text{SE}\propto 1/\sqrt{n}.

Passo 3

Como estruturar em Python — ideia geral (passo-a-passo)
    1. Coloque o código que faz UMA simulação dentro de uma função chamada simulacao() que retorne um número (float) — o lucro final.
    1. Escreva uma função run_simulations(n, seed=None) que:
    • opcionalmente seta a semente pseudo-aleatória para reprodutibilidade,
    • chama simulacao() n vezes,
    • guarda os resultados em uma lista ou array,
    • calcula \bar{X}, s, \text{SE} e o intervalo de confiança,
    • retorna essas estatísticas.
    1. Chame run_simulations para n= 100 e n= 1.000 e observe os resultados.
Explicação prática de por que isso funciona:
  • A função simulacao() gera uma amostra independente por execução — chamando-a n vezes obtemos uma amostra de tamanho n.
  • As fórmulas estatísticas acima (média, desvio, SE) são exatamente as medidas que usamos para descrever a média e incerteza.

Passo 4

Código Python explicadinho (vai funcionar como template). Aqui eu mostro o código que você deve inserir no seu ambiente e executar. Observações:
  • Substitua o corpo da função simulacao() pelo código da “questão anterior” — mantendo a assinatura (sem argumentos) e certificando-se de retornar o lucro final como um float.
  • Usei numpy para facilitar cálculos, mas o código é simples e fácil de entender.
(na próxima seção, no campo de resposta, eu entrego o código pronto para copiar/colar)

Passo 5

O que você deve olhar nos resultados e interpretação rápida
  • Compare \bar{X} para n= 100 e n= 1.000: a média para 1.000 geralmente estará mais próxima do valor esperado verdadeiro e será menos “barulhenta”.
  • Compare os erros padrões: se o desvio amostral s for parecido, então \text{SE}_{100}\approx s/\sqrt{100} e \text{SE}_{1.000}\approx s/\sqrt{1.000}. Como \sqrt{1.000}\approx 3,16 e \sqrt{100}=10, o erro padrão diminui quando você aumenta n.
  • Se a média estiver consistentemente positiva (e o intervalo de 95\% não contiver zero), isso sugere que sua estratégia é lucrativa “em média”. Se estiver próxima de zero ou com intervalo incluindo zero, cuidado: pode não ser vantajosa.

Passo 6

Dicas finais rápidas antes do código (motivação + animo)
  • Empolgação curta: isso é exame-prático — siga o template, cole seu código da simulação dentro da função simulacao e execute as repetições. Em 5–10 minutos você terá uma resposta confiável sobre o comportamento médio da sua estratégia.
  • Se ficar lento com 1.000 repetições, verifique se dá para vetorizar partes do código ou usar multiprocessing — mas só faça isso se souber; primeiro faça a versão simples.

Resposta

import numpy as np
import math
import random

def simulacao():
    """
    Substitua o corpo desta função pelo código da sua simulação (questão anterior).
    A função DEVE retornar um único número (float) correspondente ao lucro final daquela execução.
    Exemplo simples de placeholder (comente/remoova quando for substituir):
        - aqui fazemos 100 jogadas, ganho +1 com prob 0.5 e perda -1 com prob 0.5,
        - lucro final = soma das jogadas.
    """
    # EXEMPLO DE PLACEHOLDER (troque por sua simulação real):
    n_rodadas = 100
    resultados = np.random.choice([1.0, -1.0], size=n_rodadas, p=[0.5, 0.5])
    lucro_final = resultados.sum()
    return float(lucro_final)
    # FIM DO EXEMPLO

def run_simulations(n_reps, seed=None, verbose=True):
    """
    Roda a função 'simulacao' n_reps vezes e retorna estatísticas:
    - media: média amostral dos lucros
    - s: desvio padrão amostral
    - se: erro padrão da média
    - ci_low, ci_high: limite inferior e superior do IC aproximado de 95%
    Também retorna o array de lucros (útil para análises adicionais).
    """
    if seed is not None:
        np.random.seed(seed)
        random.seed(seed)

    resultados = np.empty(n_reps, dtype=float)
    for i in range(n_reps):
        resultados[i] = simulacao()

    media = resultados.mean()
    s = resultados.std(ddof=1)          # desvio padrão amostral
    se = s / math.sqrt(n_reps)         # erro padrão da média
    z = 1.96                           # quantil ~95% para distribuição normal
    ci_low = media - z * se
    ci_high = media + z * se

    if verbose:
        print(f"n = {n_reps}")
        print(f"média = {media:.6f}")
        print(f"desvio amostral s = {s:.6f}")
        print(f"erro padrão SE = {se:.6f}")
        print(f"IC 95% aproximado = [{ci_low:.6f}, {ci_high:.6f}]")
    return {
        "media": media,
        "s": s,
        "se": se,
        "ci": (ci_low, ci_high),
        "valores": resultados
    }

if __name__ == "__main__":
    # Exemplo de execução para n = 100 e n = 1000
    # Substitua/rode depois de colocar seu código real em simulacao()
    res_100 = run_simulations(100, seed=123)
    res_1000 = run_simulations(1000, seed=123)

Exercícios relacionados