Elabore um algoritmo que leia um valor
e logo após um número
que indicará a quantidade de números a serem lidos após a leitura de
. Em seguida, leia
números (conforme o valor informado anteriormente) e, ao final imprima se o elemento
aparece e sua posição, caso positivo. (2)
Passo 1
O que o enunciado pede e quais dados nos dão.
-
O enunciado pede que seja elaborado um algoritmo que:
- Leia um valor
. - Leia um número
que indica quantos números serão lidos em seguida. - Leia esses
números. - Ao final, imprima se o elemento
aparece entre os números lidos e, caso positivo, imprima a sua posição.
- Leia um valor
-
Informações relevantes (explicitadas):
- O primeiro valor lido é
. - O segundo valor lido é
, um inteiro não-negativo que diz quantos valores virão depois. - Em seguida vêm exatamente
valores (podem ser inteiros ou reais — o enunciado não especifica). - Precisamos indicar se
aparece (sim/não) e, se aparecer, a posição onde ele aparece. - Decisão prática (escolhida aqui): vamos reportar a primeira posição onde
aparece (índice começando em ). Se o professor quiser todas as posições, dá para adaptar o algoritmo fácil — eu explico isso nos próximos passos.
- O primeiro valor lido é
Passo 2
Idéia geral do método (explicação didática, sem código ainda).
- A maneira mais simples e comum é fazer uma varredura linear (um “scan”) pelos
números: ler cada número, comparar com e, se igual, guardar a posição. - Vantagens desse método:
- Simples de entender e implementar.
- Usa pouca memória (não precisa armazenar todos os números).
- Opera em tempo linear
, que é ótimo para este problema.
- Alternativas:
- Guardar todos os números em um vetor e depois buscar: usa mais memória sem vantagem aqui.
- Estruturas avançadas (hash, ordenação) só valem se houver muitas consultas, o que não é o caso.
Passo 3
Definição das variáveis e convenções (ensinando o que cada variável representa).
-
: o valor que queremos localizar. -
: quantidade de valores que serão lidos depois. -
: variável temporária para cada valor lido na sequência. -
: índice do laço, vai de até (usar indexação iniciando em facilita entender a “posição” que o enunciado pede). -
: posição onde foi encontrado; inicializamos com um valor especial que indica “não encontrado”. Uma escolha comum é . - Convenção de igualdade:
- Se os valores são inteiros, a comparação
é direta. - Se são reais, cuidado com comparação exata (pode-se usar uma tolerância
se for necessário); aqui vou assumir que a comparação direta é apropriada (caso comum em exercícios básicos).
- Se os valores são inteiros, a comparação
Passo 4
Estratégia detalhada passo a passo (em palavras, preparando para o código).
- Inicializar
(significa "ainda não achei "). - Para
variando de até : - Ler o próximo valor e guardar em
. - Comparar
com . - Se
e (ou simplesmente se ainda não achou), definir e interromper a leitura precoce (opcionalmente, pode-se continuar lendo para consumir entrada, mas não necessário para o resultado).
- Ler o próximo valor e guardar em
- Depois do laço:
- Se
, imprimir que não aparece. - Se
, imprimir que aparece e mostrar .
- Se
Observação sobre interromper cedo (break) versus continuar lendo:
- Parar no primeiro encontro (usar break) é eficiente e suficiente se só for necessária a primeira posição.
- Se for obrigatório consumir todos os
valores (por especificação de entrada em alguns juízes), pode-se ainda parar a busca mas continuar lendo os valores sem compará-los (ou simplesmente não parar e registrar a primeira ocorrência sem break).
Passo 5
Exemplo prático passo a passo (vai ajudar a fixar).
- Exemplo: suposição de entrada
-
-
- sequência de
valores:
-
- Execução:
- Inicialmente
. -
: lê . ? Não. continua . -
: lê . ? Sim. . Como queremos a primeira posição, podemos dar um break aqui. - Conclusão:
, então imprimir que aparece e sua posição é .
- Inicialmente
Se preferirmos listar todas as posições, ao invés de parar em
continuaríamos e guardaríamos as posições
e
.
Passo 6
Cuidados e casos especiais (para não ser pego de surpresa na prova).
- Caso
: não há números a ler; algoritmo deve simplesmente imprimir que não aparece. - Entrada inválida (por exemplo
): normalmente assumir que a entrada é válida; em prova com especificação estrita, pode-se tratar como erro. - Tipos numéricos:
- Inteiros: usar
sem preocupação. - Reais: para evitar erros por precisão use uma tolerância
e compare .
- Inteiros: usar
- Formato de saída:
- O enunciado não especifica o texto exato; escolha um formato claro: por exemplo imprimir uma linha “NAO” se não aparece, ou “SIM pos” se aparecer. Atenção a possíveis exigências do avaliador/questão (alguns pedem exatamente “SIM” e “NAO” ou outras palavras).
Passo 7
Complexidade e por que essa escolha é boa para a prova.
- Tempo: no pior caso o algoritmo lê e compara todos os
valores — complexidade . - Espaço: apenas algumas variáveis auxiliares — espaço
. - Por ser simples, evita erros de implementação em condição de prova e é rápido o suficiente para praticamente qualquer
típico de exercícios.
Passo 8
Resumo final do raciocínio e pequenas dicas de implementação para linguagens comuns.
- Implementar um laço for/while lendo um valor por iteração e comparando com
. - Usar
para marcar “não encontrado”. - Ao encontrar, atribuir
e parar (ou guardar e continuar, dependendo do que se pede). - Exemplo de detalhe em C/Python/Java: lembre-se de converter corretamente tipos de entrada (int, float) e de imprimir a posição começando em
.
Resposta
Leia
\nLeia
\n
\nPara
até
faça\n Leia
\n Se
então\n
\n Pare o laço\nFim do para\nSe
então\n Imprimir “Elemento não encontrado”\nSenão\n Imprimir “Elemento encontrado na posição”,
\nFim se