GABARITO LISTA 03

Prévia do material em texto

GABARITO LISTA 03 – LINGUAGEM C
Exercício 1
//Cria a função para receber uma matriz e retornar a soma de seus elementos
#include <stdio.h>
#include <stdlib.h>
float soma_elementos_de_uma_matriz(float a[ ][5])
{
//Declaração de variáveis
int i,j; //'i' para percorrer as linhas 'j' para percorrer as colunas
float soma=0; //'soma' para armazenar a soma dos elementos
for(i=0;i<5;i++)
for(j=0;j<5;j++)
soma=soma+a[i][j];
return soma;
}
int main( )
{
//Declaração de variáveis
//Cria uma matriz do tipo real de tamanho 5x5
float a[5][5];
//Cria uma variável para receber a soma
float soma;
//idem ao da função
int i,j;
printf("Digite os valores da sua matriz:\n");
for(i=0; i<5;i++)
for(j=0;j<5;j++)
{
//"i+1" e "j+1" só para começar aparecendo [1][1]
printf("[%d][%d]= ",i+1,j+1);
scanf("%f",&a[i][j]);
}
soma= soma_elementos_de_uma_matriz(a);
printf("O soma dos elementos do vetor eh %.2f!",soma);
return 0;
}
Exercício 2
//Cria a função para receber uma matriz e retornar a soma dos elementos das 
suas diagonais
#include <stdio.h>
#include <stdlib.h>
int soma_diagonais_matriz(int m[ ][6])
{
//Declaração de variável
//'i'para percorrer as linhas e 'j' para percorrer as colunas
int i,j;
//'soma' para receber a soma dos elementos da diagonal principal e  //secundaria
int soma=0;
for(i=0;i<6;i++)
for(j=0;j<6;j++)
{
//i==j esta na diagonal principal
//i+j==5 esta na diagonal secundaria
if((i==j)||(i+j==5))
soma=soma+m[i][j];
}
return soma;
}
int main( )
{
//Declaração de variáveis
//Cria uma matriz do tipo inteiro de tamanho 6x6
int a[6][6];
//Cria uma variável para receber a soma
int soma;
//idem ao da função
int i,j;
printf("Digite os valores da sua matriz:\n");
for(i=0; i<6;i++)
for(j=0;j<6;j++)
{
//"i+1" e "j+1" só para começar aparecendo [1][1]
printf("[%d][%d]= ",i+1,j+1);
scanf("%d",&a[i][j]);
}
soma= soma_diagonais_matriz(a);
printf("O soma dos elementos da diagonais principal e secundaria eh %d!",soma);
return 0;
}
Exercício 3
// função recebe matriz A(7,6) retorna a soma dos elementos da linha 5 e da coluna 3.
#include <stdio.h>
#include <stdlib.h>
float soma53(float matriz[ ][6],int linha,int coluna) //apenas a 1ª dimensão pode ser omitida
{
float soma=0;
int i;
for(i=0;i<linha;i++) //aqui meu i correrá as colunas enquanto minha linha é fixa
{
soma = soma + matriz[4][i];
//somei os elementos da linha 5 (índice 4) e coluna i
}
for(i=0;i<coluna;i++) //aqui meu i correrá as linhas enquanto minha coluna é fixa
{
soma += matriz[i][2]; //somei os elementos da linha i e coluna 3 (índice 2)
//ou soma = soma + matriz[1][2];
}
soma = soma ­ matriz[4][2];
//somei o elemento da linha 5 e coluna 3 duas vezes. Devo retirar uma vez
return soma;
}
int main()
{
float m[7][6];
int i,j;
for(i=0;i<7;i++)
{
for(j=0;j<6;j++)
{
printf("Informe o elemento [%d][%d]: ",i+1,j+1);
//para o usuário, não existe linha 0 ou coluna 0
scanf("%f",&m[i][j]);
}
}
printf("A soma dos elementos da linha 5 e coluna 3 eh : %f", soma53(m,7,6) );
return 0;
}
Exercício 4
//Cria a função para receber uma matriz e retornar o menor elemento da diagonal secundaria
#include <stdio.h>
#include <stdlib.h>
int menor_elemento_da_diagonal_secundaria(int m[ ][6])
{
//Declaração de variável
//'i'para percorrer as linhas e 'j' para percorrer as colunas
int i,j;
//'menor' para receber o menor elemento da diagonal secundaria
int menor=m[0][5]; //começa com um dos elementos da diagonal secundária
for(i=0;i<6;i++)
for(j=0;j<6;j++)
{
if(i+j==5) //a soma dos índices da diagonal secundária é 5
if(m[i][j]<menor)
menor=m[i][j];
}
return menor;
}
int main( )
{
//Declaração de variáveis
//Cria uma matriz do tipo inteiro de tamanho 6x6
int a[6][6];
//Cria uma variável para receber o menor
int menor;
//idem ao da função
int i,j;
printf("Digite os valores da sua matriz:\n");
for(i=0; i<6;i++)
for(j=0;j<6;j++)
{
//"i+1" e "j+1" só começar aparecendo [1][1]
printf("[%d][%d]= ",i+1,j+1);
scanf("%d",&a[i][j]);
}
menor= menor_elemento_da_diagonal_secundaria(a);
printf("O menor elemento da diagonal secundaria eh %d!",menor);
return 0;
}
Exercício 5
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
LEGENDA:
Negrito Preto: Programa em C
Normal Preto: Comentários
Negrito Azul: O quê é necessário completar para resolver o exercício
Os \n foram colocados testando o código diversas vezes. É opcional.
­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­­
/* A partir do trecho de código a seguir, complete o programa criando as funções que faltam. */
#include <stdio.h>
#include <string.h>
/*
Perceba que aqui os tamanhos dos vetores são especificados. Se não fosse,
o ideal seria também passá­los como parâmetros ou correr o vetor no main
chamando a subrotina e informando o indice especifico (como foi feito).
Outro jeito é utilizando o #define <nome> <valor>
*/
typedef struct{
int matricula;
float notas[3];
}Aluno;
/* colocando o typedef, não precisa de fato inventar um nome para acompanhar struct e
depois mudar */
void LeAluno(Aluno T[ ])
//recebi um vetor de estrutura T e uma posicao inteira
{
int i,j; //correr o vetor das matriculas e das notas 
for(i=0;i<5;i++)
{
printf("\n Matrícula: ");
scanf("%d",&T[i].matricula); //leitura da matricula
for(j=0;j<3;j++) //correndo o vetor das notas
{
printf("Nota %d: ",j+1); //leitura da nota 1,2,3
scanf("%f",&T[i].notas[j]);
//leitura da nota j no aluno de indice i em T
}
}
}
void ImprimeTurma (Aluno T[ ]) //recebeu o vetor de estrutura
{
int i, j; //iremos correr o vetor de estrutura Aluno e as notas
for(i=0; i<5; i++) //correndo o vetor T
{
printf("\nMatrícula: %d \n",T[i].matricula);
//imprimindo a matricula
for(j=0; j<3; j++) //correndo o vetor de notas
printf("Nota %d: %.2f \n", j+1, T[i].notas[j]);
//imprimindo cada nota
}
}
float CalculaMediaAluno(Aluno T[ ], int posicao)
//posicao recebe o i do main
{
int i; //o i do main não é este. Então posso usar a mesma variável
float soma=0; //soma das notas
for(i=0; i<3; i++)
{
soma = soma + T[posicao].notas[i];
}
return soma /3;
//divido soma por 3 notas e retorno o resultado
}
int main( )
{
Aluno Turma[5];
float media;
int i;
LeAluno(Turma);
ImprimeTurma(Turma);
// função que imprime os dados dos alunos: precisa só de Turma
for(i=0; i< 5; i++) //correndo o vetor T
{
// função que calcula a média das notas de um aluno
media = CalculaMediaAluno(Turma, i);
//devo passar o vetor T e a posicao i
printf("Aluno %d ­ Media = %f\n", Turma[i].matricula, media);
}
return 0;
}
Exercício 6
/* Crie uma estrutura ponto que representará um ponto no espaço. Essa estrutura conterá três
números reais (x, y e z). Faça um programa que crie um vetor de estruturas com 5 pontos.
Crie funções para:
a) Ler os 5 Pontos;
b) Imprimir os pontos lidos;
c) Calcular a distância de 2 pontos pelo seus indices;
d) Calcular a distância de todos os pontos consecutivos (primeiro com o segundo, segundo
com o terceiro etc);
Ao final, crie um menu que permita selecionar cada uma das funções acima. */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define tam 3 //defini o tamanho tam do vetor de estrutura como uma variável global
typedef struct {
float x,y,z;
}ponto;
//ponto é o nome da struct
void Leitura(ponto p[ ],int pos)
{
printf("\nPonto %d: \n\n",pos);
printf("Coordenada x: ");
scanf("%f",&p[pos].x);
printf("Coordenada y: ");
scanf("%f",&p[pos].y);
printf("Coordenada z: ");
scanf("%f",&p[pos].z);
}
void Imprime(ponto p[ ],int pos)
{
printf("\nPonto %d: \n\n",pos);
printf("Coordenada x: %.2f \n",p[pos].x);
printf("Coordenada y: %.2f \n",p[pos].y);
printf("Coordenada z: %.2f \n",p[pos].z);
}
float distancia1(ponto p[ ]){
int a,b; //índices dos pontos de 0 a 4
float resultado;
printf("\nIndice do 1º ponto: ");
scanf("%d",&a);
printf("\nIndice do 2º ponto: ");
scanf("%d",&b);
/* CÁLCULO DA DISTÃNCIA ENTRE DOIS PONTOS:
RAIZ QUADRADA ( (X2­X1)² + (Y2­Y1)² + (Z2­Z1)²)
Usando funções da biblioteca math.h:
sqrt(pow(x2­x1,2)+pow(y2­y1,2)+pow(z2­z1,2));
Quem é x2­x1 ? p[b].x ­ p[a].x
Agora é só substituir tudo.
*/
resultado = sqrt( pow( p[b].x ­ p[a].x ,2) + pow( p[b].y ­ p[a].y ,2 ) + pow( p[b].z ­ 
p[a].z ,2 ) );
return resultado;
}
float distancia2(ponto p[ ],int a,int b) // Mesma idéia do de cima
//recebo os pontos específicos e não leio aqui
{
return sqrt( pow(p[b].x­p[a].x,2) + pow(p[b].y­p[a].y,2) + pow(p[b].z­p[a].z,2));
//retornei direto
}
int main( )
{
ponto conjunto[tam]; //criei um vetor conjunto de tam=5 posicoes
int opcao; //opcao a ser selecionado no menu
int i; //correr o vetor conjunto
int flag=0; //explicação posterior
float dist; //armazenará a distância
do{
//Impressão do Menu (Testado diversas vezes)
printf("\n**********"); //opcional ­> questão estética e não funcional
printf("\n Menu ");
printf("\n**********\n\n");
printf("1) Leitura dos %d pontos \n",tam);
// tam define a quantidade
printf("2) Impressão dos %d pontos \n",tam);
printf("3) Distancia de 2 pontos atraves dos seus indices \n");
printf("4) Distancia de todos os pontos consecutivos \n");
printf("5) Sair \n\n"); //não foi pedido, mas é preciso
printf("Opcao: ");
scanf("%d%*c",&opcao); //%*c serve para limpar o BUFFER
/* Para fazer as opções 2,3 e 4, é necessário que tenha feito o 1 primeiro. Para
controlar isso usaremos um flag que receberá 1 quando entrar na opcao 1. */
switch(opcao){
case 1: 
{
printf("\n\n********************************\n"); //estética
printf("OPCAO 1: LEITURA DOS %d PONTOS ",tam);
printf("\n********************************\n");
for(i=0;i<tam;i++)
Leitura(conjunto,i); //passei o vetor e a posicao especifica
flag=1; //houve a leitura
}
break; //case 1 só termina aqui
case 2: 
{
  printf("\n\n********************************\n");
printf("OPCAO 2: IMPRESSAO DOS %d PONTOS ",tam);
printf("\n********************************\n");
if (flag==1)
{
for(i=0;i<tam;i++)
Imprime(conjunto,i);
//passei o vetor e a posicao especifica
}
else
printf("\nÉ necessario ler os pontos primeiro\n\n");
}
break;
case 3: 
{
  printf("\n\n*******************************\n");
printf("OPCAO 3: DISTANCIA DE 2 PONTOS ");
printf("\n*******************************\n");
if (flag==1)
{
dist=distancia1(conjunto); //passei o vetor
printf("\nA distancia entre estes pontos é %.2f \n",dist);
}
else
printf("\nÉ necessario ler os pontos primeiro\n\n");
}
break;
case 4: 
{
  printf("\n\n*******************************\n");
printf("OPCAO 4: DISTANCIA CONSECUTIVA ");
printf("\n*******************************\n");
if (flag==1)
{
/*
CÁLCULO DA DISTÂNCIA:
Segue a mesma linha de raciocínio, porém:
vou calcular a distância de i com i+1
quando i for 4, calculo com o indice 0
*/
for(i=0;i<tam;i++)
{
if(i!=tam­1) //se o i não for 4 no caso (5­1)
{
dist=distancia2(conjunto,i,i+1);
//passei o vetor e as posicoes
printf("\nDistancia P%d ­> P%d = %.2f \n",i,i+1,dist);
}
else // i tornou­se 4 (último ponto)
{
dist=distancia2(conjunto,i,0); //cálculo de i=4 com 0
printf("\nDistancia P%d ­> P0 = %.2f \n",i,dist);
}
}
}
else
printf("\nÉ necessario ler os pontos primeiro\n\n");
}
break;
case 5: 
{
  printf("\n\n*************************\n");
printf("OPCAO 5: FIM DO PROGRAMA ");
printf("\n*************************\n");
}
break;
}
}while(opcao!=5);
return 0;
}
Exercício 7
#include <stdio.h>
#include <stdlib.h>
#include <string.h> /*Declarar biblioteca para trabalhar com string */
typedef struct est_livro /*Montar a estrutura*/
{
char titulo[100];
char autor[100];
char editora[100];
int ano;
int emprestado;
int codigo;
}livro; /*A estrutura est_livro está definida como livro */
void incluir_livro(livro estoque[ ]) /*Procedimento para incluir livros*/
{
int i;
for(i=0;i<500;i++)
{
if(estoque[i].codigo==(­1))
/*Quando o livro nao ta cadastrado, o seu código é ­1*/
{
printf("\nDigite o título: ");
scanf("%s",&estoque[i].titulo);
/*Como foi declarado a biblioteca <string.h>, podemos usar scanf("%s",)*/
printf("\nDigite o autor: ");
scanf("%s",&estoque[i].autor);
printf("\nDigite a editora: ");
scanf("%s",&estoque[i].editora);
printf("\nDigite o ano: ");
scanf("%d",&estoque[i].ano);
printf("\n Informe 0 para livro emprestado e 1 para disponível: ");
scanf("%d",&estoque[i].emprestado);
printf("\nDigite código: ");
scanf("%d",&estoque[i].codigo);
i=500;
/*Utilizado para interromper o for, para que inclua apenas 1 livro*/
}
}
}
void listar_livro(livro estoque[ ]) /*Procedimento para listar livros cadastrados*/
{
int i;
printf("\nLivros cadastrados:");
for(i=0;i<500;i++) /*Passar em todas as posições do vetor estoque[ ]*/
{
if(estoque[i].codigo!=(­1)) /*Verificar se o livro está cadastrado*/
{
printf("\nTítulo: ");
puts(estoque[i].titulo);
printf("\tCódigo: %d",estoque[i].codigo);
}
}
}
void consultar_livro(livro estoque[ ]) /*Procedimento para consultar livro a partir do código*/
{
int i,c;
printf("\nDigite o código do livro a ser procurado: ");
scanf("%d",&c);
for(i=0;i<500;i++)
{
if(c==estoque[i].codigo) /*Verificar se o código do livro é igual ao digitado*/
{
printf("\nTítulo: ");
puts(estoque[i].titulo);
printf("\nAutor: ");
puts(estoque[i].autor);
printf("\nEditora: ");
puts(estoque[i].editora);
printf("\nAno: %d",estoque[i].ano);
if(estoque[i].emprestado==1) /*Verificar se está emprestado*/
{
printf("\nDisponível");
}
else
{
printf("\nEmprestado");
}
}
}
}
void emprestar_livro(livro estoque[ ]) /*Procedimento para fazer empréstimo de livro*/
{
int i,c;
printf("\nDigite o código do livro a ser emprestado: ");
scanf("%d",&c);
for(i=0;i<500;i++)
{
if(c==estoque[i].codigo)
{
if(estoque[i].emprestado==1)
{
estoque[i].emprestado=0;
/*Muda o estado do livro para emprestado*/
printf("\nEmprestimo realizado com êxito");
}
else
{
printf("\nLivro não disponível");
}
}
}
}
void receber_livro(livro estoque[ ]) /*Procedimento para fazer a devolução do livro*/
{
int i,c;
printf("\nDigite o código do livro a ser devolvido: ");
scanf("%d",&c);
for(i=0;i<500;i++)
{
if(c==estoque[i].codigo)
{
estoque[i].emprestado=1;/*Muda o estado do livro para disponível*/
printf("Devolução concluída");
}
}
}
void listar_emprestado(livro estoque[ ])/*Procedimento para listar os livros emprestados*/
{
int i;
printf("\nLivros emprestados");
for(i=0;i<500;i++)
{
if(estoque[i].emprestado==0)/*Verificar se o livro está emprestado*/
{
printf("\nTítulo: ");
puts(estoque[i].titulo);
printf("\tCódigo: %d",estoque[i].codigo);
}
}
}
void listar_disponivel(livro estoque[ ])/*Procedimento para listar livros disponíveis*/
{
int i;
printf("\nLivros disponíveis para empréstimo");
for(i=0;i<500;i++)
{
if(estoque[i].emprestado==1)/*Verificar se o livro está emprestado*/
{
printf("\nTítulo: ");
puts(estoque[i].titulo);
printf("\tCódigo: %d",estoque[i].codigo);
}
}
}
int main( )
{
int i,n;
livro estoque[500];
for(i=0;i<500;i++)
{
estoque[i].codigo=(­1);
/*Atribuir o valor do código para ­1 em todas as posições do vetor*/
estoque[i].emprestado=2;
/*Para definir todos os livros indefinido, nem emprestado, nem disponível*/
}
while (n!=8)/*Utilizado para o programa rodar até o usuário desejar*/
{
/*Menu para o usuário*/
printf("\nDigite o número com a opção que deseja executar:\n1)Incluir livro
\n2)Listar livros \n3)Consultar livro \n4)Empréstimo de livro \n5)Devolução de livro
\n6)Listar livros emprestados \n7)Listar livros disponíveis\n8)Sair do programa\n");scanf("%d%*c",&n);/*Ler a opção escolhida*/
switch(n) /*Escolher qual procedimento que irá realizar pelo número digitado*/
{
case 1: incluir_livro(estoque);
break;
case 2: listar_livro(estoque);
break;
case 3: consultar_livro(estoque);
break;
case 4: emprestar_livro(estoque);
break;
case 5: receber_livro(estoque);
break;
case 6: listar_emprestado(estoque);
break;
case 7: listar_disponivel(estoque);
break;
case 8: break; /*Não realizar nenhum comando*/
default: printf("\nCódigo inválido");
}
}
return 0;
}
Exercício 8
// Faça uma função recursiva para exibir na tela de 1 a 10
#include <stdio.h>
#include <stdlib.h>
void imprime(int i){
//este parâmetro i assume valores de 1 a 10
if (i < 1 || i > 10) //"acerto" do valor de i, caso esteja fora do intervalo
i = 1;
printf("%d\n", i); //imprime o valor de i
if(i<10)
//se o valor de i não chegou a 10 (último nº do intervalo)
//eu chamo mais uma vez
imprime(i + 1); //próxima chamada: i=i+1
}
int main( ){
imprime(1); //chama o procedimento com qualquer parâmetro (o correto é 1)
return 0;
}
Exercício 9
// Faça uma função recursiva para exibir na tela os números ímpares de 1 a 30
#include <stdio.h>
#include <stdlib.h>
void imprimeimpar(int i){
if (i < 1 || i > 30) //"acerto" do valor de i, caso esteja fora do intervalo
i = 1;
printf("%d\n", i);
if (i<28) //Aqui ele será 27 e deve chamar mais uma vez
imprimeimpar(i + 2);
//próxima chamada ­ incrementa i em 2 unidades para continuar ímpar
}
int main( ){
imprimeimpar(1); //chama o procedimento com o parâmetro correto.
return 0;
}
Exercício 10
/* Faça uma função recursiva para exibir os números compreendidos entre a e b, sendo a e b
parâmetros da função. Se b for menor que a, exiba uma mensagem de erro. */
#include <stdio.h>
#include <stdlib.h>
/* Nesse exercício foi utilizada a variável c na impressão, pois a e b não devem ser impressos
[imprimir elementos ENTRE a e b]*/
void imprime_entre(int a,int b){ //a deve ser menor que b
int c;
c = a+1; //Variável c armazena a+1, o valor a não deve ser impresso.
if (b < a)
{
printf("ERRO: b MENOR QUE a"); //condição de erro
}else{
if (b > c){ //irei imprimir os valores onde a < c < b
printf(" %d ", c);
imprime_entre(c,b);
//Irei chamar novamente. Agora vou imprimir os valores entre c < num < b
}
}
}
int main( ){
imprime_entre(1,40); //exemplo
printf("\n\n");
imprime_entre(40,1); //exemplo
return 0;
}
Exercício 11
/* Pesquise a sequência de Fibonacci e faça uma função recursiva para exibir seus n
primeiros termos, sendo n um parâmetro da função. */
#include <stdio.h>
#include <stdlib.h>
int fibonacci(int n)
{
if (n==1) //alguns consideram que fibonacci começa com 0,1,1,2..., escolhemos 1,1,2...
return 1;
else if (n == 2)
return 1;
else
return fibonacci(n­1)+fibonacci(n­2);
}
int main( )
{
int i,num;
printf("Digite quantos termos da sequencia Fibonacci você deseja obter: ");
scanf("%d",&num);
for(i=1; i<=num; i++)
{
printf("%d ",fibonacci(i));
}
return 0;
}
/*Em fibonacci tem­se que os dois primeiros termos são 1 (base recursiva,
pois conhecemos estes valores), e os seguintes são obtidos através da soma
dos dois valores anteriores (passo recursivo). Assim se queremos o terceiro
termo da sequencia, a função testa se 3=1 e se 3=2, obtendo resposta 'falso'
para ambas, no 'else' temos que o termo 3 do fibonacci=(termo 2 + termo 1)...para
calcular cada um dos termos, chamaremos a função fibonacci, que no caso,
retornará 1 tanto para o termo 2 quanto para o termo 1. Daí temos que
termo 3 = 1 + 1 = 2. Esse valor será impresso na tela pelo 'for' implementado
no programa principal. O mecanismo é o mesmo para gerar os outros
termos da sequencia.*/
Exercício 12
/* Faça uma função recursiva que receba um vetor de números reais e seu tamanho e retorne
a soma de seus elementos*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
float soma(float v[ ],int tam)
{
if(tam<1)// Tamanho inválido
{
printf("Tamanho invalido!");
exit(1);//Sai do programa
}
if(tam==1) //base recursiva
return v[0];
else
return v[tam­1] + soma(v,tam­1);
/*aqui modificamos a soma através da recursividade. Temos, então, que a soma
total será o ultimo termo do vertor mais a soma de todos os outros termos.*/
}
int main( )
{
float v[MAX];
int i;
for(i=0;i<MAX;i++)
{
printf("V[%d]= ",i);
scanf("%f",&v[i]);
}
printf("O valor da soma e: %f",soma(v,MAX)); //imprime a soma do vetor
return 0;
}
Exercício 13
/* Faça uma função recursiva que receba um vetor de números reais e seu tamanho e retorne
o menor elemento deste vetor. */
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
float menor_elemento_do_vetor(float v[ ],int tam)
{
float m;
if(tam<0) //Tamanho inválido
{
printf("Tamanho invalido!");
exit(1);//Sai do programa
}
if (tam == 1)
return v[tam­1];//retornaremos o primeiro elemento do vetor
else
{
m = menor_elemento_do_vetor(v, tam­1);
/*ficaremos chamando a função até que tam se iguale a 1. A partir daí,
faremos as comparações abaixo e retornando o menor valor para o
passo anterior até o 1º onde tam==MAX. Neste, fazemos uma ultima
comparação e mostramos o menor*/
if (v[tam­1] < m)
return v[tam­1];
else
return m;
}
}
int main( )
{
float v[MAX];
int i;
for(i=0;i<MAX;i++)
{
printf("V[%d]= ",i);
scanf("%f",&v[i]);
}
printf("O menor elemento é : %f", menor_elemento_do_vetor( v, MAX ) );
return 0;
}