Elabore um algoritmo computacional em Pascal/Delphi que, a partir de um vetor de dados numéricos inteiros, conte quantos números são pares e quantos são impares e apresente ao final o resultado.

Passo 1

O que o enunciado pede e o que ele dá:
  • Pede-se um algoritmo/com programa em Pascal/Delphi que, a partir de um vetor (lista) de números inteiros, conte quantos são pares e quantos são ímpares e mostre os resultados no final.
  • Informação disponível: um vetor de números inteiros (o enunciado não impõe tamanho fixo nem forma de entrada). Então é preciso permitir receber um tamanho n e em seguida n valores inteiros.
  • Resultado esperado: dois números — a quantidade de pares e a quantidade de ímpares.

Passo 2

Definição de par e ímpar (a ideia matemática que vamos usar)
  • Um inteiro é par se for divisível por 2; isto é, se o resto da divisão por 2 for zero.
  • Em notação: \text{um inteiro }a\text{ é par} \iff a \bmod 2 = 0é.
  • Caso contrário, é ímpar: \text{ímpar} \iff a \bmod 2 \neq 0í.
  • Observação prática: para lidar com números negativos de forma segura, é comum testar \text{Abs}(a) \bmod 2 = 0, mas na maioria das implementações de Pascal usar a \bmod 2 funciona se soubermos como a linguagem trata o sinal. Aqui usaremos \text{Abs} por segurança.

Passo 3

Escolha do método e estrutura de dados (por que esse método)
  • Método simples e direto (o melhor para prova): percorrer o vetor uma vez, verificar cada elemento e incrementar dois contadores (um para pares e outro para ímpares).
  • Complexidade: tempo \mathcal{O}(n), memória adicional constante \mathcal{O}(1) além do vetor.
  • Estrutura: vetor dinâmico (array dinâmico) para aceitar qualquer n. Em Pascal/Delphi usa-se SetLength para criar o vetor em tempo de execução.

Passo 4

Variáveis necessárias (explicando tipos e por que cada uma)
  • \text{n}: inteiro — número de elementos do vetor (entrada).
  • \text{arr}: array of Integer — vetor que guarda os n inteiros.
  • \text{i}: inteiro — índice do laço.
  • \text{pares}: inteiro — contador de números pares.
  • \text{impares}: inteiro — contador de números ímpares.
    Explicação breve de tipos: Integer é o tipo inteiro padrão em Pascal/Delphi; ele armazena números inteiros (positivos e negativos).

Passo 5

Pseudocódigo do algoritmo (visão geral passo a passo)
  1. Ler n (quantidade de elementos).
  2. Alocar vetor arr com tamanho n.
  3. Para i de 1 até n: ler arr[i].
  4. Inicializar pares := 0 e impares := 0.
  5. Para i de 1 até n:
    • Se \text{Abs}(arr[i]) \bmod 2 = 0 então pares := pares + 1
    • Senão impares := impares + 1
  6. Imprimir pares e impares.

Passo 6

Explicando o operador mod e a função Abs em Pascal/Delphi
  • x mod y retorna o resto da divisão inteira de x por y. Usamos x mod 2 para saber se x é divisível por 2.
  • Abs(x) retorna o valor absoluto de x (isto é, |x|). Usamos Abs para garantir que o teste de paridade não seja afetado pelo sinal do número (por segurança e clareza).
  • Em Pascal/Delphi a expressão if (Abs(value) mod 2 = 0) then ... indica que value é par.

Passo 7

Detalhando o loop e índices no Pascal/Delphi
  • Em Pascal há duas convenções comuns de índices: usar 0..n-1 ou 1..n. Eu vou usar 0..n-1 porque é muito comum em programação e facilita uso de SetLength(arr, n) — o índice inicial será 0.
  • Laço for i := 0 to n-1 do percorre todos os elementos do vetor.
  • Em cada iteração lemos o elemento e depois fazemos o teste if (Abs(arr[i]) mod 2 = 0) then Inc(pares) else Inc(impares);. Inc(x) é uma forma concisa de x := x + 1.

Passo 8

Programa completo em Pascal/Delphi — linha a linha com explicação (antes de dar o código final)
  • program ContagemParesImpares; — nome do programa (opcional).
  • uses SysUtils; — traz utilitários como Abs (em Delphi/Free Pascal Abs está disponível por padrão, mas SysUtils é seguro).
  • var n, i, value, pares, impares: Integer; arr: array of Integer; — declaração das variáveis e do array dinâmico.
  • Leitura de n com ReadLn(n); — usuário informa quantos números virão.
  • SetLength(arr, n); — aloca n posições no vetor.
  • Primeiro laço para ler os n valores com ReadLn(arr[i]);.
  • Zerar contadores com pares := 0; impares := 0;.
  • Segundo laço para verificar cada elemento e incrementar o contador correspondente.
  • Impressão dos resultados com Writeln('Pares: ', pares); e Writeln('Impares: ', impares);.
  • Tratamento: se n = 0 o programa simplesmente imprime Pares: 0 e Impares: 0.

Passo 9

Exemplo de execução (para fixar)
  • Entrada:
    • n = 6
    • vetor: [2, -3, 0, 7, 10, 11]
  • Passo a passo dos testes:
    • \text{Abs}(2) \bmod 2 = 0 → par
    • \text{Abs}(-3) \bmod 2 = 1 → ímpar
    • \text{Abs}(0) \bmod 2 = 0 → par
    • \text{Abs}(7) \bmod 2 = 1 → ímpar
    • \text{Abs}(10) \bmod 2 = 0 → par
    • \text{Abs}(11) \bmod 2 = 1 → ímpar
  • Resultado final impresso:
    • Pares: 3
    • Impares: 3

Passo 10

Dicas rápidas para usar na prova e cuidados
  • Se o enunciado dá o vetor pronto (por ex. já declarado no código), adapte o programa removendo a leitura e preenchendo o array manualmente.
  • Se estiver usando uma versão antiga de Pascal que não suporta arrays dinâmicos, use um array com tamanho máximo fixo, por exemplo arr: array[1..1000] of Integer; e leia até n (certifique-se de que n <= 1000).
  • Verifique n >= 0 antes de alocar. Em prova, se não disser nada, pode assumir n \ge 0.
  • Teste com n = 0 e com números negativos e zero para garantir comportamento correto.

Passo 11

Complexidade e justificativa final
  • Tempo: \mathcal{O}(n) — percorre o vetor uma vez para ler e outra vez para contar (pode ser feito em um só laço lendo e contando ao mesmo tempo, se preferir).
  • Espaço: \mathcal{O}(n) para armazenar o vetor (ou \mathcal{O}(1) extra se for contar enquanto lê sem guardar).
  • Em prova, se o enunciado só pede contar, pode-se otimizar para não armazenar o vetor: ler cada número, testá-lo e atualizar os contadores imediatamente — assim economiza memória.

Resposta

program ContagemParesImpares;
uses SysUtils;
var
n, i, pares, impares: Integer;
arr: array of Integer;
begin
Write('Quantidade de elementos: ');
ReadLn(n);
if n < 0 then
begin
Writeln(‘Valor de n invalido (precisa ser >= 0).’);
Exit;
end;
SetLength(arr, n);
for i := 0 to n - 1 do
begin
Write('Elemento ', i + 1, ': ');
ReadLn(arr[i]);
end;
pares := 0;
impares := 0;
for i := 0 to n - 1 do
begin
if (Abs(arr[i]) mod 2 = 0) then
Inc(pares)
else
Inc(impares);
end;
Writeln('Pares: ', pares);
Writeln('Impares: ', impares);
end.

Exercícios relacionados