Faça um programa que leia um número N que indica quantos valores inteiros e positivos devem ser lidos a seguir. Para cada número lido, mostre uma tabela contendo o valor lido e o fatorial desse valor.

Passo 1

O enunciado pede que a gente faça um programa que:
  • Leia um número N que indica quantos valores inteiros e positivos serão lidos a seguir.
  • Para cada um desses valores lidos, o programa deve mostrar uma tabela contendo o valor lido e o fatorial desse valor.
Informações relevantes dadas:
  • N é um inteiro (quantidade de entradas que virão depois).
  • Em seguida virão exatamente N números inteiros e positivos (cada um deve ter seu fatorial calculado).
  • Para cada número lido devemos imprimir uma linha/tabela com o valor e o seu fatorial (formato exato livre, desde que seja tabela com valor e fatorial).
Observação importante: não foi especificada uma linguagem, então escolhi uma solução simples e robusta que você consegue usar na prova — vou usar Python por ser curto, claro e por lidar bem com fatoriais grandes (inteiros de precisão arbitrária). Não vou perguntar nada; vou apresentar a solução diretamente.

Passo 2

O que é fatorial? Explicando devagar e com carinho para você sentir segurança:
  • O fatorial de um inteiro não-negativo n é denotado por n!.
  • A definição é:
0! = 1
n! = 1 \cdot 2 \cdot 3 \cdots n \quad \text{para } n \ge 1
  • Exemplos concretos:
1! = 1
2! = 1\cdot 2 = 2
5! = 1\cdot 2\cdot 3\cdot 4\cdot 5 = 120
  • Observação prática: n! cresce muito rápido quando n aumenta. Em linguagens sem inteiros de precisão arbitrária isso estoura (overflow). Em Python isso não é problema porque inteiros têm precisão arbitrária.

Passo 3

Escolha do método para calcular o fatorial:
  • Existem formas recursivas ( n! = n \cdot (n-1)!) e iterativas (produto em um loop).
  • Vou usar o método iterativo (loop multiplicativo). Por quê?
    • É mais direto de implementar em prova.
    • Evita problemas de profundidade de recursão.
    • É fácil de demonstrar passo a passo e fácil de depurar.
  • O algoritmo iterativo para calcular n! é: inicializar uma variável \text{fat} \leftarrow 1; para k de 1 até n faça \text{fat} \leftarrow \text{fat} \times k. No final \text{fat} = n!.

Passo 4

Algoritmo geral do programa (visão passo a passo):
  1. Ler N (quantidade de números que serão lidos).
  2. Repetir N vezes:
    a. Ler o próximo inteiro x (valor positivo).
    b. Calcular x! usando um loop multiplicativo.
    c. Imprimir uma linha/tabela contendo o valor x e o fatorial x!.
  3. Encerrar.
Detalhe sobre a leitura: frequentemente em provas de programação os valores vêm um por linha; o código que eu mostro aceita isso. Se vierem na mesma linha, o uso de split() também resolve — o exemplo mais simples lê linha a linha.

Passo 5

Implementação detalhada do cálculo do fatorial (ideia que você poderá usar na prova sem máquina):
  • Suponha que você precisa calcular x!.
  • Faça:
    • Inicialize \text{fat} \leftarrow 1.
    • Para k = 1 até x:
      • \text{fat} \leftarrow \text{fat} \times k.
  • No final, \text{fat} contém x!.
  • Exemplo manual: calcular 5!:
    • \text{fat}=1.
    • k=1 \Rightarrow \text{fat}=1\cdot1=1.
    • k=2 \Rightarrow \text{fat}=1\cdot2=2.
    • k=3 \Rightarrow \text{fat}=2\cdot3=6.
    • k=4 \Rightarrow \text{fat}=6\cdot4=24.
    • k=5 \Rightarrow \text{fat}=24\cdot5=120.
    • Resultado: 5! = 120.

Passo 6

Formato de saída (exemplo de tabela):
  • Uma forma clara é imprimir cada linha assim:
    Valor = X Fatorial = Y
    onde X é o valor lido e Y é X!.
  • Exemplo prático (entrada e saída):
    • Entrada:
      • N = 3
      • Valores: 5, 3, 1
    • Saída esperada:
      Valor = 5 Fatorial = 120
      Valor = 3 Fatorial = 6
      Valor = 1 Fatorial = 1
Você pode ajustar a formatação (por exemplo, separar por tabulação ou usando colunas fixas), mas o importante é que cada valor lido venha acompanhado do seu fatorial.

Passo 7

Cuidados e validações rápidas (coisas que podem cair em prova ou em testes):
  • O enunciado diz “inteiros e positivos”. Se aparecer 0, matematicamente 0! = 1. Decida: aceitar 0 e retornar 1 é correto matematicamente.
  • Se quiser, pode validar: se x < 0 — imprimir mensagem de erro ou ignorar. Em muitos exercícios de prova não é necessário tratar entradas inválidas porque dizem que as entradas seguem as condições.
  • Complexidade: calcular x! por multiplicação leva O(x) multiplicações. Se x for muito grande, custo cresce; mas em provas normalmente x cabe em limites razoáveis.

Passo 8

Implementação em Python (explicando linha a linha sem pular nada):
  • Leitura de N:
    • usar N = int(input()) para ler e converter para inteiro.
  • Loop principal:
    • usar “for i in range(N):” para repetir N vezes.
    • em cada iteração: ler x = int(input()).
  • Cálculo do fatorial:
    • fat = 1
    • for k in range(1, x+1):
      fat *= k
  • Impressão:
    • print(f"Valor = {x} Fatorial = {fat}")
  • Observação: em Python usamos inteiros arbitrariamente grandes, então não se preocupe com overflow.

Passo 9

Exemplo completo de execução mental com o programa:
  • Suponha entrada:
    • Primeira linha: 3
    • Seguem: 5, 3, 1
  • O programa:
    • N=3.
    • Iteração 1: lê x=5, calcula 5! = 120, imprime “Valor = 5 Fatorial = 120”.
    • Iteração 2: lê x=3, calcula 3! = 6, imprime “Valor = 3 Fatorial = 6”.
    • Iteração 3: lê x=1, calcula 1! = 1, imprime “Valor = 1 Fatorial = 1”.
  • Resultado conforme o que esperamos no Passo 6.

Passo 10

Dicas para a prova (o que escrever no papel ou no código para ganhar pontos):
  • Comente brevemente o que faz cada bloco do seu código (leitura, loop, cálculo).
  • Declare claramente a variável que guarda o fatorial e inicialize com 1.
  • Se tiver que apresentar em pseudocódigo, escreva o loop multiplicativo exatamente como mostrado.
  • Se a questão pedir “tabela”, alinhe com espaço ou use o texto “Valor = … Fatorial = …” — assim fica visível e correto.

Resposta

# Programa para ler N números e imprimir o valor e seu fatorial
N = int(input())  # lê a quantidade de valores a serem processados
for _ in range(N):
    x = int(input())  # lê o próximo valor inteiro (positivo)
    fat = 1
    for k in range(1, x + 1):
        fat *= k
    print(f"Valor = {x} Fatorial = {fat}")

Exercícios relacionados