Questão 01 - Fazer uma função que receba um vetor de números reais e o seu tamanho, e retorne o menor elemento do vetor. Inicialmente, deve-se criar uma função para ler o vetor recebendo como argumento o número de elementos desejados (tamanho do vetor). Escrever o módulo principal.

Passo 1

O enunciado pede três coisas claras:
  • Criar uma função que recebe um vetor de números reais e o seu tamanho e retorna o menor elemento do vetor. Vou chamar essa função de \text{menor\_elemento}.
  • Criar inicialmente uma função para ler o vetor, sendo que essa função recebe como argumento o número de elementos desejados (tamanho do vetor). Vou chamar essa função de \text{ler\_vetor}.
  • Escrever o módulo principal (função \text{main}) que usa as duas funções acima para ler os dados, obter o menor elemento e mostrar o resultado.
Informações relevantes dadas:
  • O vetor contém números reais (ou seja, valores do tipo real — em C usaremos \text{double}).
  • A função que encontra o menor elemento recebe o vetor e o seu tamanho (ou seja, dois argumentos: o ponteiro/array e um inteiro n).
  • A função de leitura recebe o número de elementos desejados n como argumento.

Passo 2

Como vamos resolver (visão geral, sem código ainda):
  • Representamos o vetor como um array de \text{double} na linguagem C.
  • A função \text{ler\_vetor} recebe um inteiro n, aloca memória para n elementos do tipo \text{double}, lê cada valor do teclado e retorna um ponteiro para o vetor alocado.
    • Explicando passo a passo: alocar memória significa reservar um bloco de memória em tempo de execução usando \text{malloc}. Se a alocação falhar, devemos tratar o erro.
    • Ler os n valores é feito com um laço que vai do índice 0 até n-1.
  • A função \text{menor\_elemento} recebe um vetor (ponteiro para \text{double}) e um inteiro n. Para achar o menor:
    • Inicializamos uma variável \text{min} com o primeiro elemento do vetor: \text{min} = v[0].
    • Percorremos os elementos restantes (índices 1 até n-1). Para cada elemento v[i], se v[i] < \text{min} então atualizamos \text{min} = v[i].
    • Ao final do laço, \text{min} contém o menor elemento.
  • A função \text{main} solicita ao usuário o valor de n, valida n>0, chama \text{ler\_vetor}(n), chama \text{menor\_elemento} com o vetor lido e imprime o resultado. Por fim, libera a memória alocada com \text{free}.

Passo 3

Detalhando a função de leitura \text{ler\_vetor}:
  • Protótipo sugerido: \text{double * ler\_vetor(int n)}.
  • O que cada coisa significa:
    • \text{double *} é o tipo de retorno: um ponteiro para o início do vetor de números reais.
    • \text{int n} é o número de elementos que o usuário quer ler.
  • Procedimento passo a passo dentro da função:
    1. Verificar se \,n \le 0. Se for, não faz sentido alocar; pode retornar \text{NULL} ou tratar como erro.
    2. Usar \text{malloc} para alocar \,n \times \text{sizeof(double)} bytes.
    3. Verificar se o ponteiro retornado por \text{malloc} não é \text{NULL}. Se for \text{NULL}, significa que a alocação falhou.
    4. Fazer um laço com índice i que vai de 0 até n-1. Em cada iteração, usar \text{scanf("%lf", \&v[i])} para ler um valor real e armazenar em v[i].
    5. Retornar o ponteiro v para o chamador.
  • Observação prática para prova: se não puder alocar dinamicamente, uma alternativa é pedir um tamanho máximo e usar um array estático, mas geralmente a alocação dinâmica é a forma correta e flexível.

Passo 4

Detalhando a função que encontra o menor elemento \text{menor\_elemento}:
  • Protótipo sugerido: \text{double menor\_elemento(const double v[], int n)}.
    • Uso de \text{const} é uma boa prática: indica que a função não modifica o vetor.
  • Passo a passo do algoritmo:
    1. Verificar se n \le 0. O vetor está vazio — isso é um caso inválido; podemos tratar como erro ou decidir um comportamento definido (aqui vamos tratar como erro).
    2. Inicializar \text{min} = v[0]. Isso garante que \text{min} começa com um valor real do vetor, então funciona mesmo que todos os números sejam negativos.
    3. Fazer um laço com i variando de 1 até n-1.
    4. Em cada iteração, comparar v[i] com \text{min}. Se v[i] < \text{min}, então atribuir \text{min} = v[i].
    5. Ao final do laço, retornar \text{min}.
  • Por que começamos em v[0] e não, por exemplo, em um valor muito grande? Porque usar v[0] evita problemas com limites (por exemplo, se todos os números forem negativos ou muito grandes) e é simples de implementar e provar correto.

Passo 5

Como montar o \text{main} na prova (passo a passo):
  1. Declarar uma variável inteira \,n.
  2. Pedir ao usuário o valor de \,n (ex.: imprimir uma mensagem e ler com \text{scanf("%d",&n)}).
  3. Validar que \,n>0. Se não for, imprimir mensagem de erro e terminar.
  4. Chamar \text{ler\_vetor(n)} para obter o ponteiro para os \,n valores. Tratar se a função retornou \text{NULL} (erro de alocação).
  5. Chamar \text{menor\_elemento(v,n)} e guardar o resultado em uma variável \text{double}, por exemplo \text{min}.
  6. Imprimir \text{min} com \text{printf} (ex.: \text{printf("Menor elemento = %.6f\n", min);}).
  7. Liberar a memória com \text{free(v)}.
  8. Retornar \,0 para indicar finalização bem-sucedida.

Passo 6

Exemplo rápido para fixar (mini-teste mental):
  • Suponha que n=5 e o usuário digita os valores \,3.2,\,-1.0,\;0.5,\;10.0,\,-2.3.
  • Procedimento:
    • \text{min} = v[0] = 3.2.
    • Compara com v[1] = -1.0 -1.0 < 3.2, então \text{min} = -1.0.
    • Compara com v[2] = 0.5 0.5 < -1.0? Não → mantém -1.0.
    • Compara com v[3] = 10.0 → não.
    • Compara com v[4] = -2.3 -2.3 < -1.0 \text{min} = -2.3.
    • Resultado final: menor elemento = -2,3 (na notação com vírgula como o enunciado em PT-BR costuma usar).

Passo 7

Observações finais e dicas de prova:
  • Sempre trate entradas inválidas (por exemplo, n \le 0 ou falha na leitura).
  • Ao usar alocação dinâmica, não esquecer de liberar com \text{free} para evitar vazamento de memória.
  • Em provas que não permitem alocação dinâmica, use um array com tamanho fixo máximo e leia somente até \,n, mas isso deve ser informado.
  • No momento de implementar, escreva primeiro os protótipos das funções, depois as definições, depois o \text{main}. Isso ajuda a organizar.
  • Mantenha o código simples e com nome de funções autoexplicativas (por exemplo, \text{ler\_vetor} e \text{menor\_elemento}) — isso ajuda o corretor a entender sua solução.

Resposta

#include <stdio.h>
#include <stdlib.h>
/* Lê um vetor de n elementos (double) e retorna o ponteiro para o vetor alocado.
Retorna NULL se n <= 0 ou se a alocação falhar. */
double *ler_vetor(int n) {
if (n <= 0) return NULL;
double *v = (double *) malloc(n * sizeof(double));
if (v == NULL) {
fprintf(stderr, “Erro: falha na alocacao de memoria.\n”);
return NULL;
}
for (int i = 0; i < n; i++) {
printf(“Digite o elemento %d: “, i + 1);
if (scanf(”%lf”, &v[i]) != 1) {
fprintf(stderr, “Erro: entrada invalida.\n”);
free(v);
return NULL;
}
}
return v;
}
/* Retorna o menor elemento do vetor v com n elementos.
Assume n > 0; se n <= 0, o programa termina com erro. */
double menor_elemento(const double v[], int n) {
if (n <= 0) {
fprintf(stderr, “Erro: vetor vazio.\n”);
exit(EXIT_FAILURE);
}
double min = v[0];
for (int i = 1; i < n; i++) {
if (v[i] < min) min = v[i];
}
return min;
}
int main(void) {
int n;
printf(“Quantos elementos? “);
if (scanf(”%d”, &n) != 1 || n <= 0) {
fprintf(stderr, “Tamanho invalido.\n”);
return 1;
}
double *vetor = ler_vetor(n);
if (vetor == NULL) {
    fprintf(stderr, "Nao foi possivel ler o vetor.\n");
    return 1;
}

double menor = menor_elemento(vetor, n);
printf("Menor elemento = %.6f\n", menor);

free(vetor);
return 0;
}

Exercícios relacionados