Crie um algoritmo que leia uma matriz de ordem 3 \times 3 de números inteiros e a seguir calcule e escreva (Utilizar a estrutura WHILE).:
a) a soma dos elementos pares da matriz;
b) a média de todos os elementos da matriz;
c) a quantidade de elementos ímpares da matriz.

Passo 1

O que o enunciado pede e o que nos é dado:
  • Ler uma matriz de ordem 3\times 3 contendo números inteiros.
  • Calcular e escrever:
    • (a) a soma dos elementos pares da matriz;
    • (b) a média de todos os elementos da matriz;
    • (c) a quantidade de elementos ímpares da matriz.
  • Restrição: usar a estrutura de repetição WHILE para percorrer a matriz.
  • Informação útil: uma matriz 3\times 3 tem 9 elementos no total.

Passo 2

Definição das variáveis que vamos usar (com significado claro) e inicialização:
  • A — matriz 3\times 3 onde serão armazenados os inteiros lidos (opcional: podemos processar cada valor ao ler, sem armazenar).
  • i — índice da linha (vai de 0 até 2 ou de 1 até 3, conforme convenção). Vou usar aqui 0 a 2.
  • j — índice da coluna (vai de 0 até 2).
  • S_{\text{pares}} — soma acumulada apenas dos elementos pares. Inicializar S_{\text{pares}}=0.
  • S_{\text{total}} — soma acumulada de todos os elementos. Inicializar S_{\text{total}}=0.
  • C_{\text{impares}} — contador de elementos ímpares. Inicializar C_{\text{impares}}=0.
  • N — número total de elementos, aqui N=9.
  • x — variável temporária que guarda o elemento lido da matriz.
Inicializações que faremos no algoritmo:
  • i=0, S_{\text{pares}}=0, S_{\text{total}}=0, C_{\text{impares}}=0.

Passo 3

Explicar a lógica de percorrer a matriz com WHILE (aninhamento) e o que fazer em cada elemento:
  • Usamos dois loops WHILE aninhados: o externo para as linhas ( i) e o interno para as colunas ( j). Assim garantimos visitar todas as 3\times 3 posições.
  • Em cada iteração do loop interno:
    1. Ler o valor inteiro e armazenar em x.
    2. Atualizar a soma total: S_{\text{total}} \leftarrow S_{\text{total}} + x.
    3. Testar se x é par ou ímpar. Para isso usamos o operador resto (módulo): x \bmod 2.
      • Se x \bmod 2 = 0, então x é par → atualizar S_{\text{pares}} \leftarrow S_{\text{pares}} + x.
      • Caso contrário, x é ímpar → incrementar C_{\text{impares}} \leftarrow C_{\text{impares}} + 1.
  • Após terminar os dois loops, teremos S_{\text{pares}}, S_{\text{total}} e C_{\text{impares}} corretos.
Explicando o operador módulo de forma didática:
  • O operador a \bmod b dá o resto da divisão inteira de a por b.
  • Para verificar paridade: um inteiro x é par se e somente se x \bmod 2 = 0. Caso contrário ( x \bmod 2 = 1 ou -1 em algumas linguagens para negativos), é ímpar. Em implementações típicas em C/Java/Python, x \bmod 2 devolve 0 ou 1 para inteiros não-negativos; para negativos a condição x \bmod 2 = 0 continua correta para detectar pares.

Passo 4

Calcular a média e cuidados com tipo numérico:
  • Fórmula da média aritmética de todos os elementos:
\text{média} = \dfrac{S_{\text{total}}}{N}.é
  • Aqui N=9. Importante: converter para tipo que permita casas decimais (por exemplo ponto flutuante) se quiser a média com fração, caso a linguagem faça divisão inteira por padrão. Ou seja, em pseudocódigo use divisão real: \text{média} \leftarrow S_{\text{total}} / 9é.
  • Exemplo: se S_{\text{total}}=45, então \text{média}=45/9=5é. Se S_{\text{total}}=46, então \text{média}=46/9 \approx 5{,}111\ldotsé.

Passo 5

Exemplo prático pequeno para fixar (não é a saída final do algoritmo, apenas demonstração):
  • Suponha que os 9 valores lidos, por linhas, sejam:
    1, 2, 3;\;4, 5, 6;\;7, 8, 9.
  • Soma total: S_{\text{total}} = 1+2+3+4+5+6+7+8+9 = 45.
  • Elementos pares: 2,4,6,8 S_{\text{pares}} = 2+4+6+8 = 20.
  • Elementos ímpares: 1,3,5,7,9 C_{\text{impares}} = 5.
  • Média: \text{média} = \dfrac{45}{9} = 5é.
  • Esse exemplo confirma que a lógica dá os resultados esperados.

Passo 6

Dicas práticas para implementação em linguagens comuns:
  • Em muitas linguagens o índice de arrays começa em 0; se preferir começar em 1, adapte os limites dos WHILE para 1 a 3.
  • Cuidado com a leitura de valores: pode-se processar cada valor imediatamente ao ler, sem necessidade de guardar a matriz inteira.
  • Para garantir média com casas decimais, em linguagens com divisão inteira, faça conversão para float/double antes da divisão (ex.: em pseudocódigo use divisão real explicitamente).

Resposta

Algoritmo (pseudocódigo usando WHILE; lê 9 inteiros e ao final escreve a soma dos pares, a média e a quantidade de ímpares):
Início
\n Ler/Inicializar:
\n i \leftarrow 0
\n S_{\text{pares}} \leftarrow 0
\n S_{\text{total}} \leftarrow 0
\n C_{\text{impares}} \leftarrow 0
\n Enquanto i < 3 faça
\n\quad j \leftarrow 0
\n\quad Enquanto j < 3 faça
\n\quad\quad Ler inteiro x // entrada do elemento da matriz na posição i,j
\n\quad\quad S_{\text{total}} \leftarrow S_{\text{total}} + x
\n\quad\quad Se x \bmod 2 = 0 então
\n\quad\quad\quad S_{\text{pares}} \leftarrow S_{\text{pares}} + x
\n\quad\quad Senão
\n\quad\quad\quad C_{\text{impares}} \leftarrow C_{\text{impares}} + 1
\n\quad\quad FimSe
\n\quad\quad j \leftarrow j + 1
\n\quad FimEnquanto
\n\quad i \leftarrow i + 1
\n FimEnquanto
\n Calcular média:
\n \text{média} \leftarrow S_{\text{total}} / 9é // usar divisão real
\n Escrever "Soma dos elementos pares = ", S_{\text{pares}}
\n Escrever "Média de todos os elementos = ", \text{média}é
\n Escrever "Quantidade de elementos ímpares = ", C_{\text{impares}}
Fim.

Exercícios relacionados