Python: Prática de Ramificações e Laços

1. Jogador seleciona dificuldade: Fácil (1-50, ilimitado), Normal (1-100, 10 tentativas), Difícil (1-200, 7 tentativas)
2. Sistema gera aleatoriamente um número alvo
3. Após cada palpite, dica "muito alto" ou "muito baixo" e exibe tentativas restantes
4. Após acertar ou esgotar tentativas, pergunte "jogar novamente?"
5. Digite q para sair

import random

print("=" * 30)
print("Jogo de Adivinhação (Melhorado)")
print("=" * 30)

while True:  # Laço externo: controla "jogar novamente"
    # Seleciona dificuldade
    print("\nSelecione a dificuldade:")
    print("1. Fácil (1~50, ilimitado)")
    print("2. Normal (1~100, 10 tentativas)")
    print("3. Difícil (1~200, 7 tentativas)")

    choice = input("Digite 1/2/3: ")

    if choice == "1":
        max_num = 50
        max_attempts = float("inf")  # Ilimitado
    elif choice == "2":
        max_num = 100
        max_attempts = 10
    elif choice == "3":
        max_num = 200
        max_attempts = 7
    else:
        print("Escolha inválida, usando Normal como padrão")
        max_num = 100
        max_attempts = 10

    # Gera número alvo
    target = random.randint(1, max_num)
    attempts = 0
    print(f"\nNúmero gerado entre 1~{max_num}. Comece a adivinhar!")

    # Laço interno: lógica principal do jogo
    while True:
        # Verifica se as tentativas acabaram
        if attempts >= max_attempts:
            print(f"\nTentativas esgotadas! A resposta era {target}")
            break

        # Obtém palpite do jogador
        guess_str = input(f"{max_attempts - attempts} tentativas restantes, digite seu palpite: ")

        if guess_str.lower() == "q":
            print("Saindo do jogo.")
            max_attempts = -1  # Flag para notificar laço externo
            break

        # Valida entrada
        if not guess_str.isdigit():
            print("Por favor, digite um número válido!")
            continue

        guess = int(guess_str)
        attempts += 1

        # Verifica palpite
        if guess < target:
            print("Muito baixo, tente mais alto!")
        elif guess > target:
            print("Muito alto, tente mais baixo!")
        else:
            print(f"\nParabéns! A resposta era {target}!")
            print(f"Você acertou em {attempts} tentativas.")
            break

    # Verifica se devemos sair completamente
    if max_attempts == -1:  # Jogador digitou q
        break

    # Pergunta por outra rodada
    again = input("\nJogar novamente? (s/n): ")
    if again.lower() != "s":
        print("Obrigado por jogar, até logo!")
        break

=== Triângulo Inferior Padrão ===

=== Retângulo Completo ===

=== Triângulo Superior ===
1x1=1    1x2=2    1x3=3    ...    1x9=9
          2x2=4    2x3=6    ...    2x9=18
                    3x3=9    ...    3x9=27
                              ...
                                        9x9=81

1. Começa com resultado atual = 0
2. Usuário digita: operador número, ex.: "+ 5"
3. Operadores suportados: + - * / ** // % clear exit
4. clear redefine o resultado para 0
5. exit sai do programa
6. Após cada operação, mostre o resultado atual e o histórico

print("=" * 40)
print("Calculadora Melhorada")
print("Formato: operador número, ex.: + 5")
print("Suportados: + - * / ** // %")
print("Comandos especiais: clear reset exit quit")
print("=" * 40)

result = 0.0
history = []  # Armazena histórico de operações

while True:
    # Exibe resultado atual
    print(f"\nResultado atual: {result}")

    # Obtém entrada do usuário
    cmd = input(">>> ").strip()

    # Trata comandos especiais
    if cmd.lower() in ("exit", "quit"):
        print("Obrigado por usar!")
        break

    if cmd.lower() == "clear":
        result = 0.0
        history.clear()
        print("Redefinido para 0")
        continue

    # Analisa comandos de operação regulares
    parts = cmd.split()
    if len(parts) != 2:
        print("Formato inválido! Digite: operador número")
        continue

    op, num_str = parts

    # Valida número
    if not num_str.replace(".", "").isdigit() or num_str.count(".") > 1:
        print("Número inválido!")
        continue

    num = float(num_str)

    # Executa operação
    old_result = result
    if op == "+":
        result += num
    elif op == "-":
        result -= num
    elif op == "*":
        result *= num
    elif op == "/":
        if num == 0:
            print("Erro: Não é possível dividir por zero!")
            continue
        result /= num
    elif op == "**":
        result **= num
    elif op == "//":
        if num == 0:
            print("Erro: Não é possível dividir por zero!")
            continue
        result //= num
    elif op == "%":
        if num == 0:
            print("Erro: Não é possível dividir por zero!")
            continue
        result %= num
    else:
        print(f"Operador inválido: {op}")
        continue

    # Registra histórico
    history.append(f"{old_result} {op} {num} = {result}")

    # Exibe resultado
    print(f"= {result}")

    # Mostra últimas 3 entradas do histórico
    if len(history) >= 1:
        print("--- Histórico Recente ---")
        for item in history[-3:]:
            print(f"  {item}")

>>> + 10
= 10.0
--- Histórico Recente ---
  0.0 + 10.0 = 10.0

>>> * 3
= 30.0
--- Histórico Recente ---
  0.0 + 10.0 = 10.0
  10.0 * 3.0 = 30.0

>>> / 0
Erro: Não é possível dividir por zero!

>>> clear
Redefinido para 0

1. Usuário insere valores inicial e final
2. Programa exibe todos os primos nesse intervalo
3. Exibe 10 por linha, alinhados
4. Mostra a contagem total de primos

print("Localizador de Números Primos")
print("Digite um intervalo, e eu encontrarei todos os primos.")

# Obtém intervalo
start_str = input("Valor inicial (>=2): ")
end_str = input("Valor final: ")

# Valida entrada
if not (start_str.isdigit() and end_str.isdigit()):
    print("Por favor, digite números inteiros positivos válidos!")
else:
    start = int(start_str)
    end = int(end_str)

    if start < 2:
        start = 2
        print("Valor inicial ajustado para 2 (primos começam em 2)")

    if start > end:
        print("Valor inicial não pode ser maior que o value final!")
    else:
        primes = []  # Armazena primos encontrados

        # Verifica cada número no intervalo
        for num in range(start, end + 1):
            # Verifica se num é primo
            is_prime = True
            for i in range(2, int(num ** 0.5) + 1):
                if num % i == 0:
                    is_prime = False
                    break

            if is_prime:
                primes.append(num)

        # Exibe resultados
        print(f"\nEncontrados {len(primes)} primos entre {start} e {end}:")

        for i, prime in enumerate(primes, 1):
            print(f"{prime:5d}", end="")
            if i % 10 == 0:  # Nova linha a cada 10
                print()

        print()  # Nova linha final

Valor inicial (>=2): 50
Valor final: 200

Encontrados 34 primos entre 50 e 200:
   53   59   61   67   71   73   79   83   89   97
  101  103  107  109  113  127  131  137  139  149
  151  157  163  167  173  179  181  191  193  197
  199

=== Índice de Massa Corporal ===
Peso: 68 kg
Altura: 1.75 m
IMC: 22.2
Categoria: Normal

=== Verificador de Força de Senha ===
Senha: Py3#thon
Comprimento: 8
Contém dígito: True
Contém letra: True
Contém caractere especial: True
Força da senha: Média

# Errado
n = 1
while n <= 10:
    print(n)
    # esqueceu n += 1 — nunca termina

# Correto
n = 1
while n <= 10:
    print(n)
    n += 1

# Errado
if score = 100:  # Isto é atribuição, não comparação!
    print("Perfeito!")

# Correto
if score == 100:
    print("Perfeito!")

# Errado — deletar durante iteração causa pulos
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)
print(numbers)  # Pode não ser o que você espera

# Correto — crie uma nova lista
numbers = [1, 2, 3, 4, 5]
odd_numbers = [num for num in numbers if num % 2 != 0]
print(odd_numbers)

# Errado: esperando range(5) exibir 1 2 3 4 5
for i in range(5):
    print(i)  # Saída real: 0 1 2 3 4

# Correto
for i in range(1, 6):
    print(i)  # Saída: 1 2 3 4 5

  *
 ***
*****
 ***
  *

1. Insira notas dos alunos (digite q para parar)
2. Calcule total, média, nota mais alta e mais baixa
3. Conte alunos em cada faixa: 90-100 (Excelente), 80-89 (Bom), 70-79 (Médio), 60-69 (Aprovado), <60 (Reprovado)
4. Exiba notas ordenadas da mais alta para a mais baixa