Desenvolva um programa que realize n (entrada) sorteios de um número inteiro pertencente ao intervalo de 1 a 100. Seu programa deve ler o valor (valor) a ser sorteado, e em seguida realizar n sorteios verificando se o número sorteado atualmente corresponde com valor. (3)

Passo 1

O enunciado pede que eu desenvolva um programa que:
  • Leia um número inteiro n (quantidade de sorteios a ser realizada).
  • Leia um número inteiro valor (o número que estamos “procurando” nos sorteios).
  • Execute n sorteios de um número inteiro no intervalo de 1 a 100.
  • Em cada sorteio, verificar se o número sorteado corresponde a valor.
Informações relevantes dadas:
  • O intervalo dos sorteios é de 1 até 100 (inclusivo).
  • Há duas entradas que o programa deve ler: n e valor.
  • Deve-se verificar, para cada sorteio, se o sorteado é igual a valor.

Passo 2

Vamos escolher como o programa vai se comportar (sem ambiguidade):
  • O programa vai pedir ao usuário para digitar n e valor.
  • Validações mínimas:
    • n deve ser um inteiro positivo (se o usuário digitar algo inválido, o programa deve avisar).
    • valor deve ser um inteiro entre 1 e 100 (caso contrário, avisar).
  • Para cada sorteio de 1 até n:
    • Gerar um inteiro aleatório uniforme entre 1 e 100.
    • Mostrar qual foi o número sorteado e se houve correspondência com valor.
  • Ao final, mostrar um resumo: quantas vezes valor foi sorteado (ocorrências) e a porcentagem relativa em relação a n.
Motivo da escolha:
  • Esse comportamento cumpre estritamente o enunciado e dá um feedback claro durante a execução (útil para conferir se o código está funcionando). É simples de implementar e fácil de usar na prova/avaliacão.

Passo 3

Conceito importante: geração de números aleatórios inteiros em um intervalo.
  • Para gerar um inteiro aleatório uniforme entre 1 e 100 usa-se, em muitas linguagens, uma função que retorna um inteiro entre os limites inclusive. Em Python, por exemplo, essa função é random.randint(1, 100).
  • “Uniforme” significa que cada número de 1 a 100 tem a mesma probabilidade de ser sorteado (teoricamente 1/100 para cada número em cada sorteio independente).
  • Cada sorteio é independente: o resultado de um sorteio não influencia os outros.

Passo 4

Estrutura geral do programa (pseudocódigo alto nível):
  1. Ler n.
  2. Ler valor.
  3. Validar n e valor.
  4. Inicializar contador de acertos contador = 0.
  5. Repetir para i de 1 até n:
    • gerar sorteado \leftarrow inteiro aleatório em [1,100],
    • comparar sorteado com valor,
    • se igual, incrementar contador,
    • imprimir resultado do sorteio (opcional: indicar “ACERTO” ou “NÃO”).
  6. Ao final, imprimir contador e a porcentagem contador / n \times 100\%.

Passo 5

Detalhamento das partes que podem confundir (explicando como fazer na prova):
  • Leitura e conversão:
    • Ao ler uma entrada textual, converter para inteiro. Garantir que a conversão trate exceções (se possível), ou pelo menos checar se o número está na faixa esperada.
  • Validação de valor:
    • Verificar se 1 \leq valor \leq 100. Se não, informar ao usuário e encerrar ou pedir novamente.
  • Loop:
    • Usar um loop controlado por contador que vai de 1 até n. Em pseudocódigo: para i = 1 até n faça …
  • Contagem:
    • Sempre que sorteado = valor, fazer contador \leftarrow contador + 1.
  • Cálculo da porcentagem:
    • A porcentagem de acertos é \dfrac{contador}{n}\times 100\%. Se quiser mostrar com duas casas decimais, formatar apropriadamente (por exemplo, arredondando).
  • Mensagens ao usuário:
    • É boa prática mostrar cada sorteio para depuração e um resumo no final. Em prova, explique que isso facilita verificar se o programa está correto.

Passo 6

Complexidade e limites práticos:
  • Complexidade de tempo: O(n) (cada sorteio é uma operação constante).
  • Complexidade de memória: O(1) (apenas contadores e variáveis auxiliares).
  • Para n grande (ex.: milhões) o programa ainda funciona, mas pode demorar; para a prova normalmente n será razoável.

Passo 7

Exemplo rápido de execução imaginária (para checar raciocínio):
  • Suponha n=5 e valor=42.
  • Sorteios hipotéticos: 13, 42, 99, 7, 42.
  • Comparações: não, sim, não, não, sim.
  • Resultado: contador = 2. Porcentagem = \dfrac{2}{5}\times 100\% = 40\%.
  • Esse tipo de exemplo ajuda a verificar mentalmente o algoritmo na prova.

Passo 8

Observações finais antes de mostrar o código:
  • Vou implementar em Python porque é conciso e muito usado em provas/listas. A lógica é a mesma em outras linguagens: ler, validar, laço, gerar aleatório, comparar, contar, mostrar resultados.
  • O código abaixo faz validações mínimas e imprime cada sorteio e, ao final, um resumo com número de ocorrências e porcentagem.

Resposta

import random

def main():
    try:
        n = int(input("Digite o número de sorteios (n): ").strip())
    except ValueError:
        print("Entrada inválida: n deve ser um inteiro.")
        return

    try:
        valor = int(input("Digite o valor a ser verificado (entre 1 e 100): ").strip())
    except ValueError:
        print("Entrada inválida: valor deve ser um inteiro.")
        return

    if n <= 0:
        print("Entrada inválida: n deve ser inteiro positivo.")
        return

    if not (1 <= valor <= 100):
        print("Entrada inválida: valor deve estar entre 1 e 100.")
        return

    contador = 0

    for i in range(1, n + 1):
        sorteado = random.randint(1, 100)
        if sorteado == valor:
            contador += 1
            status = "ACERTO"
        else:
            status = "NÃO"
        print(f"Sorteio {i}: {sorteado} -> {status}")

    porcentagem = (contador / n) * 100
    print(f"\nResumo: {contador} ocorrência(s) de {valor} em {n} sorteio(s).")
    print(f"Porcentagem: {porcentagem:.2f}%")

if __name__ == "__main__":
    main()

Exercícios relacionados