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
. - 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
. - Escrever o módulo principal (função
) 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
). - 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
). - A função de leitura recebe o número de elementos desejados
como argumento.
Passo 2
Como vamos resolver (visão geral, sem código ainda):
- Representamos o vetor como um array de
na linguagem C. - A função
recebe um inteiro , aloca memória para elementos do tipo , 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
. Se a alocação falhar, devemos tratar o erro. - Ler os
valores é feito com um laço que vai do índice até .
- Explicando passo a passo: alocar memória significa reservar um bloco de memória em tempo de execução usando
- A função
recebe um vetor (ponteiro para ) e um inteiro . Para achar o menor: - Inicializamos uma variável
com o primeiro elemento do vetor: . - Percorremos os elementos restantes (índices
até ). Para cada elemento , se então atualizamos . - Ao final do laço,
contém o menor elemento.
- Inicializamos uma variável
- A função
solicita ao usuário o valor de , valida , chama , chama com o vetor lido e imprime o resultado. Por fim, libera a memória alocada com .
Passo 3
Detalhando a função de leitura
:
- Protótipo sugerido:
. - O que cada coisa significa:
-
é o tipo de retorno: um ponteiro para o início do vetor de números reais. -
é o número de elementos que o usuário quer ler.
-
- Procedimento passo a passo dentro da função:
- Verificar se
. Se for, não faz sentido alocar; pode retornar ou tratar como erro. - Usar
para alocar bytes. - Verificar se o ponteiro retornado por
não é . Se for , significa que a alocação falhou. - Fazer um laço com índice
que vai de até . Em cada iteração, usar para ler um valor real e armazenar em . - Retornar o ponteiro
para o chamador.
- Verificar se
- 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
:
- Protótipo sugerido:
. - Uso de
é uma boa prática: indica que a função não modifica o vetor.
- Uso de
- Passo a passo do algoritmo:
- Verificar se
. O vetor está vazio — isso é um caso inválido; podemos tratar como erro ou decidir um comportamento definido (aqui vamos tratar como erro). - Inicializar
. Isso garante que começa com um valor real do vetor, então funciona mesmo que todos os números sejam negativos. - Fazer um laço com
variando de até . - Em cada iteração, comparar
com . Se , então atribuir . - Ao final do laço, retornar
.
- Verificar se
- Por que começamos em
e não, por exemplo, em um valor muito grande? Porque usar 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
na prova (passo a passo):
- Declarar uma variável inteira
. - Pedir ao usuário o valor de
(ex.: imprimir uma mensagem e ler com ). - Validar que
. Se não for, imprimir mensagem de erro e terminar. - Chamar
para obter o ponteiro para os valores. Tratar se a função retornou (erro de alocação). - Chamar
e guardar o resultado em uma variável , por exemplo . - Imprimir
com (ex.: ). - Liberar a memória com
. - Retornar
para indicar finalização bem-sucedida.
Passo 6
Exemplo rápido para fixar (mini-teste mental):
- Suponha que
e o usuário digita os valores . - Procedimento:
-
. - Compara com
→ , então . - Compara com
→ ? Não → mantém . - Compara com
→ não. - Compara com
→ → . - Resultado final: menor elemento =
(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,
ou falha na leitura). - Ao usar alocação dinâmica, não esquecer de liberar com
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é
, mas isso deve ser informado. - No momento de implementar, escreva primeiro os protótipos das funções, depois as definições, depois o
. Isso ajuda a organizar. - Mantenha o código simples e com nome de funções autoexplicativas (por exemplo,
e ) — isso ajuda o corretor a entender sua solução.
Resposta
#include <stdio.h>
#include <stdlib.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 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;
}
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;
}
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;
}