1-) Escrever um algoritmo que faça a tabuada de um número informado pelo usuário (Utilizar a estrutura WHILE).

Passo 1

O enunciado pede que eu escreva um algoritmo que faça a tabuada de um número informado pelo usuário, usando a estrutura de repetição WHILE.\n
Informações dadas e o que o algoritmo deve fazer:
  • Receber do usuário um número (vou chamar esse número de n).
  • Usar um laço do tipo WHILE (enquanto) para gerar a tabuada.
  • Mostrar na tela os produtos de n por uma sequência de multiplicadores (por padrão vou usar os multiplicadores de 1 até 10, que é a tabuada tradicional).
  • O algoritmo deve imprimir cada linha no formato: " n x i = p" onde i é o multiplicador atual e p é o produto.
Nada mais foi especificado (por exemplo, se a tabuada vai até outro número), então vou assumir o caso padrão de i indo de 1 até 10.

Passo 2

Entendendo a estrutura WHILE (explicação didática e simples):
  • Um laço WHILE repete um bloco de instruções enquanto uma condição for verdadeira.
  • Três partes essenciais numa estrutura WHILE:
    1. Inicialização: criar e definir a variável de controle do laço (por exemplo i\leftarrow 1).
    2. Condição: a expressão booleana que é verificada antes de cada iteração (por exemplo i\le 10). Se for verdadeira, o corpo do laço executa; se for falsa, o laço termina.
    3. Atualização: dentro do corpo do laço devemos atualizar a variável de controle (por exemplo i\leftarrow i+1) para evitar loop infinito.
  • Exemplo simples (não a tabuada, só pra fixar):
    • Inicialização: i\leftarrow 1
    • Enquanto i\le 3 faça: imprimir i; i\leftarrow i+1
    • Isso imprime 1,2,3.
Pense no WHILE como: “enquanto a condição for verdadeira, continue”.

Passo 3

Planejamento do algoritmo da tabuada (escolhas concretas):
  • Nome das variáveis: n para o número do usuário, i para o multiplicador, p para o produto.
  • Intervalo do multiplicador: i=1 até i=10 (inclusive).
  • Estrutura: ler n, inicializar i\leftarrow 1, enquanto i\le 10 calcular p\leftarrow n\cdot i, imprimir a linha formatada, incrementar i.
Agora vou montar o pseudocódigo e depois explico linha a linha.

Passo 4

Pseudocódigo (comentado linha a linha):
Ler \(n\) do usuário
\(i \leftarrow 1\)                        // inicialização do contador
enquanto \(i \le 10\) faça               // condição do laço WHILE
    \(p \leftarrow n \cdot i\)          // calcula o produto atual
    imprimir "\(n\) x \(i\) = \(p\)"     // mostra a linha da tabuada
    \(i \leftarrow i + 1\)              // atualização do contador
fim enquanto
Explicação das linhas:
  • “Ler n do usuário”: pedir que o usuário entre com um número inteiro (ou real, se quiser permitir). Essa é a entrada do algoritmo.
  • i \leftarrow 1”: começamos a tabuada pelo multiplicador 1. Sempre inicialize o contador antes do laço.
  • “enquanto i \le 10 faça”: verifica antes de cada iteração se ainda devemos continuar (para i=1,2,\dots,10 a condição é verdadeira).
  • p \leftarrow n \cdot i”: operação de multiplicação entre n e i. Aqui explico rápido o que é multiplicar: multiplicar n por i é somar n consigo mesmo i vezes (conceito básico), mas em programação usamos o operador de multiplicação direto.
  • “imprimir …”: imprimir com formatação legível. Por exemplo, se n=7 e i=3 imprimimos “7 x 3 = 21”.
  • i \leftarrow i + 1”: passo crucial para avançar o contador; sem isso o laço seria infinito.
Dica prática: sempre verifique se a condição do WHILE eventualmente se torna falsa — aqui isso ocorre porque i cresce e terminará quando passar de 10.

Passo 5

Exemplo de execução passo a passo para n=7 (isso ajuda a entender o laço):
  • Inicialmente: n=7, i=1. Condição 1\le 10 é verdadeira.
    • p\leftarrow 7\cdot 1 = 7. Imprime: “7 x 1 = 7”. Atualiza i\leftarrow 2.
  • Agora i=2. Condição 2\le 10 verdadeira.
    • p\leftarrow 7\cdot 2 = 14. Imprime: “7 x 2 = 14”. Atualiza i\leftarrow 3.
  • Repetindo até i=10, as impressões serão:
    • “7 x 3 = 21” (quando i=3)
    • “7 x 10 = 70” (quando i=10)
  • Depois de atualizar i\leftarrow 11, a condição 11\le 10 é falsa e o laço termina. Resultado final: linhas de 7 \times 1 até 7 \times 10.

Passo 6

Possíveis variações e melhorias (idéias rápidas que você pode usar na prova se pedirem):
  • Permitir que o usuário escolha o limite superior da tabuada, por exemplo ler também m e usar "enquanto i \le m".
  • Validar entrada: se você quer só inteiros, pode usar um WHILE para repetir a leitura enquanto a entrada não for válida.
  • Aceitar números negativos ou zero: o algoritmo funciona do mesmo jeito; a tabuada de 0 será sempre 0.
  • Formatação: é legal alinhar números se quiser um visual mais bonito, mas não é necessário em prova.
  • Complexidade: o laço executa um número fixo de iterações (aqui 10), então é rápido — em prova não precisa justificar muito, só conte as iterações se pedirem.

Passo 7

Implementação prática em Python (exemplo concreto, caso você precise submeter código). Em provas de algoritmos costuma-se aceitar pseudocódigo, mas segue um exemplo real para você testar e entender na prática:
n = int(input("Digite o número para a tabuada: "))   # ler n
i = 1
while i <= 10:
    p = n * i
    print(f"{n} x {i} = {p}")
    i = i + 1
Explicação rápida do código:
  • int(input(...)) converte a entrada em inteiro e guarda em n.
  • i = 1 inicializa o contador.
  • while i <= 10: é a condição do laço.
  • p = n * i calcula o produto.
  • print(...) mostra a linha da tabuada.
  • i = i + 1 incrementa o contador.
Força aí — com esse passo a passo você já consegue entender o WHILE e construir a tabuada na prova. Repete o raciocínio na mão se precisar e, se quiser, treina com outros limites (por exemplo até 12 ou até 20).

Resposta

Ler n do usuário\n
i \leftarrow 1\n
enquanto i \le 10 faça\n
\quad p \leftarrow n \cdot i\n
\quadimprimir " n x i = p"\n
\quad i \leftarrow i + 1\n
fim enquanto

Exercícios relacionados