Ler um vetor de 100 posições e verifique se todos os valores são iguais.

Passo 1

O enunciado pede que se leia um vetor com exatamente 100 posições e verifique se todos os valores desse vetor são iguais. Informações dadas e o que é pedido:
  • Dado: um vetor de tamanho 100. Vou chamar esse vetor de V.
  • Cada posição contém um valor (pode ser número inteiro, real, caractere — o método não muda).
  • Saída pedida: dizer se “todos os valores são iguais” ou “nem todos os valores são iguais”.

Passo 2

Ideia simples e eficiente (explicação intuitiva): pegar um valor de referência (por exemplo, o valor da primeira posição V_1) e comparar cada uma das outras posições com esse valor. Se alguma posição tiver valor diferente, então nem todos são iguais e podemos parar imediatamente. Se passarmos por todas as posições sem encontrar diferença, então todos são iguais. Essa ideia evita comparações desnecessárias quando aparece a primeira diferença.

Passo 3

Definição clara das variáveis que vamos usar:
  • V: o vetor com 100 elementos, indexados por 1,2,\dots,100.
  • ref: variável que guarda o valor de referência, definida por ref = V_1.
  • i: índice inteiro usado no laço, que vai percorrer i=2,\dots,100.
  • igual: variável booleana que indica se todos os elementos até agora coincidem com ref. Inicialmente igual = \text{verdadeiro}.
Explicando cada uma:
  • V é a sequência que lemos da entrada.
  • ref é o valor que escolhemos para comparar com os demais.
  • i é só o contador do laço.
  • igual começa verdadeiro; se encontrarmos qualquer diferença definimos igual := falso e saímos do laço.

Passo 4

Pseudocódigo passo a passo (cada linha explicada em linguagem simples):
  1. Ler o vetor V de 100 posições. (Significa: ler os 100 valores e armazenar em V_1,V_2,\dots,V_{100}.)
  2. Definir ref \leftarrow V_1. (Escolher o primeiro elemento como referência.)
  3. Definir igual \leftarrow \text{verdadeiro}.
  4. Para i \leftarrow 2 até 100 faça:
    • Se V_i \neq ref então:
      • igual \leftarrow \text{falso}.
      • Interromper o laço (porque já sabemos que nem todos são iguais).
    • Fim-se
  5. Fim-para
  6. Se igual for verdadeiro então imprimir “Todos iguais” senão imprimir “Nem todos iguais”.
Comentário: essa versão compara cada elemento com o mesmo ref, por isso precisa de até 99 comparações no pior caso.

Passo 5

Exemplo prático (todos iguais): suponha que V seja [5,5,5,\dots,5].
  • Leio o vetor.
  • ref = V_1 = 5.
  • i=2: comparar V_2(=5) com ref(=5) → igual, continuar.
  • i=3: comparar V_3(=5) com ref → igual, continuar.
  • i=100: comparar V_{100}(=5) com ref → igual.
  • Não houve diferenças → igual = verdadeiro → imprimir “Todos iguais”.

Passo 6

Exemplo prático (há diferença): suponha V seja [2,2,2,\dots,2,7,2,\dots] com V_{37}=7.
  • ref = V_1 = 2.
  • Percorremos i=2,3,\dots,36: todas as comparações dão igual.
  • Chegando em i=37: V_{37}=7 \neq ref=2 → definimos igual := falso e paramos o laço imediatamente.
  • Saída: “Nem todos iguais”.
    Observação importante: parar cedo economiza tempo no caso em que a diferença aparece antes do final.

Passo 7

Correção e complexidade (por que esse método funciona e quanto custa):
  • Correção: se existe alguma posição j tal que V_j \neq V_1, ela será detectada quando i=j; se não existe nenhuma, então nenhum teste de desigualdade será verdadeiro e concluímos corretamente que todos os elementos são iguais.
  • Complexidade temporal: no pior caso (quando todos são iguais) fazemos 99 comparações, ou seja, (100-1) comparações. Em termos assintóticos: O(n) com n=100. Em média, se a primeira diferença aparece cedo, o custo é menor.
  • Complexidade espacial: O(1) espaço extra além do vetor (só guardamos ref, i, e igual).

Passo 8

Variações e observações para a prova (o que o examinador pode pedir e por que esse método costuma ser o preferido):
  • Alternativa 1: usar uma estrutura de conjuntos. Inserir cada V_i em um conjunto e ao final verificar se o tamanho do conjunto é 1. Isso funciona bem e é simples, mas depende da disponibilidade de estruturas (hash set) e pode usar mais memória; tempo típico O(n) também, mas com custo de hash/insert.
  • Alternativa 2: ordenar o vetor e comparar primeiro e último elemento. Se após ordenar V_1 = V_{100} então todos são iguais. Mas ordenar custa \,O(n\log n) e é desnecessário para esse problema.
  • Conclusão: a comparação com V_1 é a forma mais direta, usa pouco espaço e tem tempo linear.

Passo 9

Exemplos de implementação (sintaxe simples para usar na prova ou no laboratório)
Exemplo em Python (curto e direto):
# ler 100 valores em uma lista V
V = [float(input()) for _ in range(100)]
ref = V[0]
igual = True
for i in range(1, 100):
    if V[i] != ref:
        igual = False
        break
if igual:
    print("Todos iguais")
else:
    print("Nem todos iguais")
Exemplo em C (estrutura clássica):
#include <stdio.h>
int main() {
    double V[100];
    for (int i = 0; i < 100; i++) scanf("%lf", &V[i]);
    double ref = V[0];
    int igual = 1; // 1 = verdadeiro, 0 = falso
    for (int i = 1; i < 100; i++) {
        if (V[i] != ref) { igual = 0; break; }
    }
    if (igual) printf("Todos iguais\n"); else printf("Nem todos iguais\n");
    return 0;
}
Observação sobre comparações de ponto flutuante: se os valores forem reais (float/double) e houver risco de erros de precisão, compare com uma tolerância, por exemplo verificar se |V_i - ref| < \varepsilon para um pequeno \varepsilon.

Passo 10

Dicas finais e incentivo:
  • Na prova, escreva primeiro a ideia em palavras (usar V_1 como referência) e depois o pseudocódigo. Isso mostra clareza.
  • Se o enunciado pedir análise de complexidade, explique que são no máximo 99 comparações e espaço adicional constante.
  • Respire fundo: é um problema direto — a maior armadilha é esquecer de parar o laço quando encontra uma diferença ou negligenciar precisão de floats. Você consegue resolver isso na prova!

Resposta

Imprimir “Todos iguais” se todos os elementos do vetor V_1,\dots,V_{100} forem iguais; caso contrário imprimir “Nem todos iguais”.

Exercícios relacionados