Desenvolva um programa que realize
(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
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
(quantidade de sorteios a ser realizada). - Leia um número inteiro
(o número que estamos “procurando” nos sorteios). - Execute
sorteios de um número inteiro no intervalo de a . - Em cada sorteio, verificar se o número sorteado corresponde a
.
Informações relevantes dadas:
- O intervalo dos sorteios é de
até (inclusivo). - Há duas entradas que o programa deve ler:
e . - Deve-se verificar, para cada sorteio, se o sorteado é igual a
.
Passo 2
Vamos escolher como o programa vai se comportar (sem ambiguidade):
- O programa vai pedir ao usuário para digitar
e . - Validações mínimas:
-
deve ser um inteiro positivo (se o usuário digitar algo inválido, o programa deve avisar). -
deve ser um inteiro entre e (caso contrário, avisar).
-
- Para cada sorteio de
até : - Gerar um inteiro aleatório uniforme entre
e . - Mostrar qual foi o número sorteado e se houve correspondência com
.
- Gerar um inteiro aleatório uniforme entre
- Ao final, mostrar um resumo: quantas vezes
foi sorteado (ocorrências) e a porcentagem relativa em relação a .
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
e 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
a tem a mesma probabilidade de ser sorteado (teoricamente 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):
- Ler
. - Ler
. - Validar
e . - Inicializar contador de acertos
. - Repetir para
de até : - gerar
inteiro aleatório em , - comparar
com , - se igual, incrementar
, - imprimir resultado do sorteio (opcional: indicar “ACERTO” ou “NÃO”).
- gerar
- Ao final, imprimir
e a porcentagem .
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
: - Verificar se
. Se não, informar ao usuário e encerrar ou pedir novamente.
- Verificar se
- Loop:
- Usar um loop controlado por contador que vai de
até . Em pseudocódigo: para até faça …
- Usar um loop controlado por contador que vai de
- Contagem:
- Sempre que
, fazer .
- Sempre que
- Cálculo da porcentagem:
- A porcentagem de acertos é
. Se quiser mostrar com duas casas decimais, formatar apropriadamente (por exemplo, arredondando).
- A porcentagem de acertos é
- 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:
(cada sorteio é uma operação constante). - Complexidade de memória:
(apenas contadores e variáveis auxiliares). - Para
grande (ex.: milhões) o programa ainda funciona, mas pode demorar; para a prova normalmente será razoável.
Passo 7
Exemplo rápido de execução imaginária (para checar raciocínio):
- Suponha
e . - Sorteios hipotéticos:
. - Comparações: não, sim, não, não, sim.
- Resultado:
. Porcentagem . - 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()