Objetivo: classificar elementos.
Descrição: leia 10 inteiros. Conte quantos são pares e ímpares. Depois, imprima apenas os pares na ordem de entrada.
Critérios:
  • Um for para ler; outro para contar e imprimir filtrado.
  • Usar if ( \mathrm{v}[\mathrm{i}] \% 2 == 0 ).
Extensão: criar um vetor só com pares (sem “buracos”).

Passo 1

O enunciado pede o seguinte: ler 10 inteiros, contar quantos são pares e quantos são ímpares, e depois imprimir apenas os pares na ordem em que foram lidos. Informações relevantes fornecidas:
  • Devemos ler exatamente 10 números inteiros.
  • Precisamos contar dois valores: o número de pares e o número de ímpares.
  • Devemos imprimir apenas os pares, na mesma ordem de entrada.
  • Critério de implementação: usar um laço for para ler; outro laço for para contar e imprimir filtrado. Usar a condição if ( v[i] \% 2 == 0).
  • Extensão: construir um vetor que contenha somente os pares, sem “buracos” (ou seja, compactar os pares em um vetor separado).

Passo 2

Estrutura de dados e variáveis necessárias (explicação simples):
  • Vetor de entrada: vou chamar de v com tamanho 10. Em C: int v[10];. Cada posição guarda um inteiro lido.
  • Contadores: int npares = 0; e int nimpares = 0; para contar quantos são pares e ímpares, respectivamente.
  • Vetor só com pares (extensão): int pares[10]; e um índice int j = 0; que indica quantos pares já foram armazenados em pares. Esse vetor tem tamanho 10 porque no pior caso todos os 10 números são pares.

Passo 3

Como ler os 10 inteiros com um for (explicação didática):
  • Usamos um laço for com índice i variando de 0 até 9 (inclusive) — são 10 iterações.
  • Em cada iteração fazemos scanf("%d", &v[i]);.
  • Por que 0 a 9? Porque índices de vetores em C começam em 0 e o último índice de um vetor de tamanho 10 é 9.
    Exemplo de pseudocódigo da leitura:
    for i = 0 até 9: leia v[i].

Passo 4

Conceito de par/ímpar e operador módulo (a parte teórica mastigada):
  • Um inteiro x é par se é divisível por 2, ou seja, se o resto da divisão por 2 é 0.
  • Em programação usamos o operador resto \% (módulo). Teste: x é par se x \% 2 == 0.
  • Exemplos simples:
    • 4 \% 2 = 0 4 é par.
    • 7 \% 2 = 1 7 é ímpar.
  • No enunciado foi sugerido usar exatamente a condição if (v[i] % 2 == 0). Em TeX isso fica v[i] \% 2 == 0 (observe que o símbolo de porcentagem no TeX é escrito \%).

Passo 5

O segundo for (contagem e impressão filtrada) — estratégia e passo a passo:
  • Percorremos novamente o vetor v com um for i = 0 até 9.
  • Em cada iteração avaliamos a condição v[i] \% 2 == 0.
    • Se for verdadeira:
      • incrementamos npares (por exemplo npares++);
      • guardamos o valor em pares[j] e incrementamos j (pares[j++] = v[i];) — isso faz o vetor pares ficar compacto, sem “buracos”;
      • imprimimos o valor v[i] (assim garantimos que os pares saem na ordem de entrada).
    • Caso contrário:
      • incrementamos nimpares.
  • Nota sobre ordem de saída: esse laço imprime cada par assim que o encontra, portanto a saída dos pares preserva a ordem de entrada.

Passo 6

Por que o vetor pares não terá “buracos” (explicação concreta):
  • Começamos com j = 0.
  • Sempre que encontramos um par, fazemos pares[j] = v[i]; e logo em seguida j = j + 1;.
  • Isso coloca os pares em pares[0], pares[1], ..., pares[j-1] de maneira contígua, sem posições vazias entre eles.
  • Ao final, j é exatamente o número de pares armazenados — que coincide com npares.

Passo 7

Formato de saída sugerido e flexibilidade:
  • O enunciado não impôs formato de impressão exato, então uma saída clara pode ser:
    • Imprimir os pares (um por linha ou todos na mesma linha separados por espaço) na ordem de entrada;
    • Depois (ou antes — veja critério de laços) imprimir a quantidade de pares e ímpares.
  • Segui a ideia de imprimir cada par quando encontrado (no segundo for) e depois mostrar npares e nimpares. Isso respeita o critério “um for para ler; outro para contar e imprimir filtrado” e ainda preserva o vetor pares compacto.

Passo 8

Exemplo rápido para checar mentalmente:
  • Entrada (10 números): 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
  • Durante o segundo for:
    • Pares encontrados, na ordem: 2, 4, 6, 8, 10 → serão impressos nessa ordem.
    • npares = 5, nimpares = 5.
  • Vetor pares terá pares[0]=2, pares[1]=4, pares[2]=6, pares[3]=8, pares[4]=10 e j = 5.

Passo 9

Dicas rápidas para a prova (tom amigável):
  • Lembre-se: primeiro laço só para ler; segundo laço faz a lógica de par/ímpar. Isso é exatamente o que o professor pediu.
  • Use v[i] \% 2 == 0 para testar paridade — memorize essa condição.
  • Para criar um vetor sem “buracos”, controle um índice j separado e incremente-o somente quando armazenar um par.
  • Se der nervoso, escreva primeiro a leitura, depois esqueleto do segundo laço e só então preencha o if/else.

Resposta

#include <stdio.h>
int main(void) {
int v[10];
int pares[10];
int npares = 0;
int nimpares = 0;
/* Leitura: um for para ler os 10 inteiros */
for (int i = 0; i < 10; i++) {
    if (scanf("%d", &v[i]) != 1) return 0;
}

/* Contagem, impressão filtrada e construção do vetor de pares:
   um for que faz as três coisas conforme solicitado */
printf("Pares (na ordem de entrada):\n");
for (int i = 0; i < 10; i++) {
    if (v[i] % 2 == 0) {
        pares[npares] = v[i]; /* armazena sem 'buracos' */
        npares++;
        printf("%d\n", v[i]);  /* imprime o par assim que encontrado */
    } else {
        nimpares++;
    }
}

printf("Quantidade de pares: %d\n", npares);
printf("Quantidade de impares: %d\n", nimpares);

return 0;
}

Exercícios relacionados