Exercícios Resolvidos em C - Listas 1 e 2

Prévia do material em texto

EXERCICIOS DE TODAS AS LISTAS RESOLVIDAS.
LISTA I
 1. Elabore um programa em C que tem uma função para calcular a área do quadrado e outra função para 
retornar o perímetro do quadrado. As funções recebem como parâmetro o lado e retornam a área e o 
perímetro como resultado, respectivamente. Lembre-se que a área é o lado ao quadrado e o perímetro é a 
soma de todos os lados. 
#include<stdio.h>
 float quadrado(float l);
 float perimetro(float l);
 main(){
 float a,p, lado;
 printf("\ndigite o tamanhanho do lado:\n");
 scanf("%f",&lado);
 a=quadrado(lado);
 p=perimetro(lado);
 printf("\n A area do quadrado e' : %f\n",a);
 printf ("\n O perimetro do quadrado e'%f:\n",p);
 return 0;
 }
 float quadrado(float l){
 return(l*l);
 }
 float perimetro (float l){
 return(l+l+l+l);
 }
 
2. Construa um programa em C que leia o preço de um produto, leia o percentual de desconto e calcule o 
valor a pagar e o valor do desconto fornecido no produto. 
#include<stdio.h>
#include<math.h>
#include <stdlib.h>
float precofinal (float preco, float desconto);
int main(){
float preco,desconto;
float valortotal;
printf("\nDigite o preço do produto:\n");
 scanf("%f",&preco);
 printf("\nDigite o Desconto:\n");
 scanf("%f",&desconto);
 printf("\no valor final ficou %f:",precofinal(preco,desconto));
 system ("pause");
}
 float precofinal (float preco, float desconto){
 float aux;
 aux=preco-(preco*desconto/100);
 return(aux);
 }
3. Fazer um programa com uma função para testar se o número lido é PAR. Se for PAR imprimir o número 
digitado na tela. Esta função recebe como parâmetro o valor lido e retorna V se ele for número par. 
#include <stdio.h>
#include <stdlib.h>
int num, p;
int verificador (int n1);
int main()
{
 printf("Digite o numero: \n");
 scanf("%d", &p);
 printf("%d", verificador( num));
}
int verificador(int n1){
 if(p%2==0)
{
 printf("O Numero é par (V)", &p );
}
 else{
 printf(" Numero impar (F) ");
 }
 return(p);
}
4. Agora utilizando vetor amplie o programa anterior para que ele leia e analise 10 números digitados e 
depois retorne a lista com os valores pares que foram lidos. 
#include<stdio.h>
#include<stdlib.h>
int i, num[10], numFinal[10];
int verificador (int num);
int main(){
for (i=0;i<10;i ++){
 printf("\nENTRE COM NUMEROS:\n");
scanf("%i",&num[i]);
numFinal[i] = verificador(num[i]);
}
for (i=0;i<10;i ++){
 if (numFinal [i]!=1){
 printf("\n OS PARES SAO:%i",numFinal[i]);
}
}
return 0;
}
int verificador (int num)
{
 if (num%2==0)
 return(num);
}
5. Faça um programa em C que apresente como opções as operações matemáticas: soma, subtração, 
multiplicação e divisão. Cada uma das operações deve ser feita através de uma função que retorne como 
resultado o valor da operação. O programa deve utilizar o comando CASE para as escolhas de operações a 
serem realizadas. 
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
int soma(int x, int y);
float multiplica(int x, int y);
float divide (float x, float y);
float subtrai (int x, int y);
int main (){
 int num,n1,n2;
 int rsoma,rsub,rdiv,rmul;
printf("\n escolha um numero:\n");
 printf ("\n 1 -soma.");
 printf ("\n 2 - subtracao.");
 printf ("\n 3 - divisao");
 printf("\n 4- multiplicação");
 printf ("\n QUAL NUMERO DESEJA ESCOLHER?\n");
 scanf("%d",&num);
 switch (num){
 case 1 :
 printf ("\ndigite primeiro numero\n");
 scanf ("%d",&n1);
 printf ("\ndigite segundo numero\n");
 scanf("%d",&n2);
rsoma=soma(n1,n2);
 printf("\n A SOMA DOS NUMEROS EH:%d",rsoma);
break;
 case 2:
 printf ("\ndigite primeiro numero\n");
 scanf ("%d",&n1);
 printf ("\ndigite segundo numero\n");
 scanf("%d",&n2);
 rsub= subtrai(n1,n2);
 printf("\nA SUBTRACAO EH:%f",subtrai(n1,n2));
 break;
case 3:
 printf ("\ndigite primeiro numero\n");
 scanf ("%d",&n1);
 printf ("\ndigite segundo numero\n");
 scanf("%d",&n2);
 rdiv = divide(n1,n2);
 printf("\nA DIVISAO EH: %f",divide(n1,n2));
 break;
 case 4:
 printf ("\ndigite primeiro numero\n");
 scanf ("%d",&n1);
 printf ("\ndigite segundo numero\n");
 scanf("%d",&n2);
 rmul= multiplica (n1,n2);
 printf("\nA MULTIPLICACAO EH: %f",multiplica(n1,n2));
 break;
 }
return 0;
}
int soma(int x, int y){
return (x+y);
}
float subtrai (int x, int y){
return (x-y);
}
float divide (float x, float y){
return(x/y);
}
float multiplica(int x, int y){
return(x*y);
}
LISTA 2
1. Escreva um programa para calcular o IMC de uma pessoa e como resultado indique se a pessoa está 
abaixo do 
peso (IMC menor que 20), normal (IMC entre 20 e 25), se está acima do peso (IMC entre 26 e 30), obesa 
(IMC entre 31 e 35) ou com obesidade mórbida (acima de 35). O IMC é calculado pela seguinte fórmula: 
IMC = peso altura2 
 
a) O programa deverá ser escrito através de uma função que retorna como valor o resultado do IMC. 
#include<stdio.h>
#include<stdlib.h>
float pesoIdeal(float p, float a);
int main() {
 float imc,peso,altura,aux;
 printf("Digite o seu peso:\n");
 scanf("%f", &peso);
 printf("Digite a sua altura:\n");
 scanf("%f", &altura);
imc= pesoIdeal(peso,altura);
 if (imc <= 19){
 printf("O seu Idice de Massa Corporea e %.2f e esta abaixo do normal.\n", imc);
 }
 else if (imc >=20 && imc<=25){
 printf ("O seu Indice de Massa Corporea e %.2f e voce esta com o peso normal\n",imc);
 }
 else if (imc >=26 && imc<=30){
 printf("O seu Indice de Massa Corporea e %.2f e voce esta Acima do Peso\n",imc);
 }
 else if (imc >=31 && imc<=35){
 printf("O seu Indice de Massa Corporea e %.2f e voce esta Obesa \n", imc);
 }
 else if (imc >=36){
 printf("O seu Indice de Massa Corporea e %.2f e voce esta com Obesidade Morbida\n", imc);
 }
 return 0;
}
float pesoIdeal(float p, float a){
return (p/(a*a));
}
b) Fazer o mesmo programa para ler e calcular o IMC de um conjunto de 10 valores armazenados em um 
vetor. 
#include<stdio.h>
#include<stdlib.h>
#define COUNT 10
// MINHA FUNCAO
float pesoIdeal(float p, float a);
main() {
float peso[10],altura[10];
 float imc, aux;
 int i;
for (i=0;i<COUNT;i ++){
 printf("Digite o seu peso e sua altura :\n");
 scanf("%f%f", &peso[i], &altura[i]);
}
 //chama funcao
 for (i=0;i<COUNT;i ++){
imc= pesoIdeal(peso[i],altura[i]);
if (imc <= 19){
 printf("O seu Idice de Massa Corporea e %.2f e esta abaixo do normal.\n", imc);
 }
else{
 if (imc >=20 && imc<=25){
 printf ("O seu Indice de Massa Corporea e %.2f e voce esta com o peso normal\n",imc);
}
else{
if (imc >=26 && imc<=30){
 printf("O seu Indice de Massa Corporea e %.2f e voce esta Acima do Peso\n",imc);
 }
 else{
 if (imc >=31 && imc<=35){
 printf("O seu Indice de Massa Corporea e %.2f e voce esta Obesa \n", imc);
 }
 else {
 printf("O seu Indice de Massa Corporea e %.2f e voce esta com Obesidade Morbida\n", 
imc);
 }
 }
}
}
 }
 return 0;
}
// MINHA FUNCAO
float pesoIdeal(float p, float a){
return (p/(a*a));
}
2. Faça um programa que apresenta uma função para calcular o MDC Máximo Divisor Comum de dois 
números lidos. 
#include <stdio.h>
#include <stdlib.h>
int mdc (int x, int y);
main()
{
 int n1,n2;
 
 printf("\nDigite dois numeros: \n");
 scanf("%d%d",&n1, &n2);
 
 
 printf("MDC = %d\n",mdc(n1,n2) );
 return 0;
}
int mdc (int x, int y){
int aux;
 while(aux!=0)
 {
 x = y;
 y = aux;
 aux= x%y; 
 }
}
3. Como a matemática prova que o produto de dois números inteiros é igual ao produto do MDC dos 
números pelo MMC, a função MaxDivCom() (MDC do exercício anterior) deve ser utilizada para se 
escrever uma função para o cálculo do mínimo múltiplo comum de dois números lidos. Neste exercício 
deverá ser acrescentada uma função para calcular o MMC de dois números utilizando a função anterior. 
#include <stdio.h>
#include <stdlib.h>
int mdc (int x, int y);
int mmc (int x, int y);
main()
{
 int n1,n2;
 
 printf("\nDigite dois numeros: \n");
 scanf("%d%d", &n1, &n2);
 
 
 printf("MDC = %d\n",mdc(n1,n2) );
 printf("MMC = %d\n",mmc(n1,n2));
 return 0;
}
int mdc (int x, int y){
int aux;
 while(aux!=0)
 {
 x = y;
 y = aux;
 aux= x%y; 
 }
}
int mmc (int x, int y)
{
int aux2=1,i;
for(i=2; ;i++)
{
while(x%i==0|| y%i==0)
{
aux2 *= i;
if(x%i==0)
x/=i;
if(y%i==0)
y/= i;
}
if(x==1 && y ==1 )break;
}
return aux2;
}
4. Faça um programa em C com uma função para verificar se o ano digitado é bissexto ou não. A função 
deve retornar 1 se for verdadeiro ou 0 se for falso. 
#include <stdio.h>
float bissexto (int ano);
main()
{
 int ano;
 printf("ANO BISSEXTO");
 printf("\nDigite o ano: ");
 scanf("%d", &ano);
 if (bissexto(ano))
 {
 printf("\nAno bissexto.\n",ano);
 }
 else
{
 printf("\nAno nao bissexto.\n",ano);
 }
}
float bissexto (int ano)
{
 if (ano % 4 == 0 ){
 return true;
}
else
{
 if( ano % 400 == 0 || ano % 100 != 0){
 return false;
}
}
}
LISTA III
1. Crie um programa em C que leia dois números (a, b) e exiba na tela quantos e quais são os números
pares compreendidos entre a e b. Utilize a função é par que foi desenvolvida na outra lista de 
exercícios.
#include <stdio.h>
#include <stdlib.h>
int comPar (int x);
int main(){
int num1, num2, aux, contPar;
printf("\nDigite primeiro numero\n");
scanf("%i",&num1);
printf("\nDigite segundo numero\n");
scanf("%i",&num2);
// aux= num1 +1;
for(aux=num1; aux<=num2; aux++)
{
if(comPar(aux)==0)
{
contPar ++;
printf("\nos numeros pares são: %d\n",aux);
 }
 }
 printf("\na quantidade dos numeros pares são %d\n", contPar);
 
}
int comPar (int x){
 if (x%2==0)
 return 0 ;
 else 
 return 1;
}
2. Funcionários de uma empresa, após uma longa batalha com a chefia, conseguiram um aumento 
salarial. O aumento será variado em função do cargo de cada funcionário. Funcionários que 
trabalham na limpeza terão um aumento de 10%, já os funcionários da segurança terão aumento de
15% e os funcionários do ensino terão aumento de apenas 5%. Escreva um programa em C que tem 
uma função para calcular o novo salário. Esta função deve receber como parâmetros o salário atual 
de um funcionário e o código do cargo do mesmo e retorne o seu novo salário. O salário é 
representado como um número real e o código do funcionário por um número inteiro como pode 
ser observado pela tabela abaixo.
 Cargo Código do 
cargo 
Limpeza 10 
Segurança 11 
Ensino 12 
#include <stdio.h>
#include<stdlib.h>
float salario_limpeza( float salario, float aumento );
float salario_seguranca(float salario, float aumento);
float salario_ensino(float salario, float aumento);
int main()
{
int cod;
 float sal;
 
 printf("\nDigite o codigo do funcionario\n10---->Limpeza\n11---->Segurança\n12----
>Ensino\n");
 scanf("%i",&cod);
 printf("\ndigite seu Salario\n");
 scanf("%f",&sal);
 
 switch (cod)
 {
 case 10 :
 printf("\nCARGO LIMPEZA\n");
 printf("o salario da limpeza eh: %f",salario_limpeza(sal,cod));
 break;
 
 
 case 11:
 printf("\nCARGO SEGURANCA\n");
 printf("\n O novo salario da seguranca eh: %f",salario_seguranca(sal,cod));
 break;
 
 case 12:
 printf("\nCARGO ENSINO\n");
 printf("\n O novo salario de ensino eh: %f",salario_ensino(sal,cod));
 break;
 }
 
 
}
float salario_limpeza( float salario, float aumento ) 
 {
float aux;
aumento=0.10;
 aux = salario+(salario*aumento);
 return aux;
 } 
float salario_seguranca( float salario, float aumento)
 {
 float aux;
 aumento=0.15;
 aux = salario+(salario*aumento);
 return aux;
 }
float salario_ensino( float salario, float aumento)
{
float aux;
aumento=0.05;
 aux = salario+(salario*aumento);
 return aux;
}
 
3. Crie uma função chamada CALCULA_POTENCIA que recebe dois parâmetros base e expoente e que
calcula e retorna como resposta da função o valor de baseexpoente, ou seja, caso seja chamada x = 
CALCULA_POTENCIA(2,4); x deverá receber o valor 16, pois 24 = 16. Utilize um laço for dentro da 
função para calcular o valor da potenciação, sabendo que 24 = 2* 2 * 2*2. Não pode utilizar a 
biblioteca math.h. Mostrar a função main( ) e a chamada da função. Os valores de base e expoente 
deverão ser fornecidos pelo usuário .
#include <stdio.h>
#include <stdlib.h>
float CALCULA_POTENCIA(float base, float expo){
 int i;
 float b = base;
 for(i=1;i<expo;i++){
 base = base * b;
 }
 return base;
}
main(){
 float base, expo, result;
 printf("\nInforme o valor da base: ");
 scanf("%f", &base);
 printf("\nInforme o valor do expoente: ");
 scanf("%f", &expo);
 result = CALCULA_POTENCIA(base,expo);
 printf("\nResultado: %.2f", result);
}
4. Faça um programa em C para ler duas matrizes de tamanho 5 x 5. Em seguida, compare os valores 
das duas matrizes, nas respectivas posições, e conte e mostre quantos números são iguais nas duas 
matrizes.
#include <stdio.h>
#include <stdlib.h>
#define LINHA 5
#define COLUNA 5
int main ( ){
 int i, j, ma[LINHA][COLUNA],mb[LINHA][COLUNA];
 
 printf("1º matriz\n");
 for (i=0;i<LINHA; i++){
 printf("Linha %d \n" , i);
 for (j=0; j<COLUNA; j++)
 scanf("%d", &ma[i][j]); 
 }
 
 printf("2º matriz\n");
 for (i=0;i<LINHA; i++){
 printf("Linha %d \n" , i);
 for (j=0; j<COLUNA; j++)
 scanf("%d", &mb[i][j]); 
 }
 for (i=0;i<LINHA; i++)
 for (j=0; j<COLUNA; j++)
 if (ma[i][j]==mb[i][j])
 printf("\n%d na posicao %d,%d\n",ma[i][j],i,j); 
return 0; 
 
}
5. Faça um programa em C que leia as três notas dos alunos, sendo que a turma possui no máximo 20 
alunos. Para cada aluno, calcule média aritmética das 3 notas usando uma função para calcular a média 
recebendo como parâmetro as três notas e retornando o valor da média. No final do programa imprima 
uma tabela indexando o aluno e sua média na disciplina.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define LINHA 2
#define COLUNA 2
/*
Faça um programa em C para ler duas matrizes de tamanho 5 x 5. Em seguida, compare os valores das duas matrizes,
nas respectivas posições, e conte e mostre quantos números são iguais nas duas matrizes
*/
main() {
 int x, lin, col, numB, numE, contador;
 int mat1[LINHA][COLUNA], mat2[LINHA][COLUNA];
 // Ler a primeira matriz
 lin = 0; col = 0;
 for (lin=0; lin<LINHA; lin++) {
 for (col=0; col<COLUNA; col++) {
 printf("Digite o numero da linha %i coluna %i da 1a Matriz:", lin, col);
 scanf("%d", &mat1[lin][col]);
 }
 }
 // Ler a segunda matrizfor (lin = 0; lin <LINHA; lin++) {
 for (col = 0; col < COLUNA; col++) {
 printf("Digite o numero da linha %i coluna %i da 2a Matriz:", lin, col);
 scanf("%i", &mat2[lin][col]);
 }
 }
//Comparar as matrizes
 contador = 0;
 for (lin = 0; lin <LINHA; lin++) {
 for (col = 0; col <COLUNA; col++) {
 if (mat1[lin][col] == mat2[lin][col]){
 
 printf(" \n O numero %d na posicao (%d,%d) da M1 e da posicao (%d,%d) da M2 são iguais ", mat1[lin][col], lin, 
col,lin, col);
 contador++;
}
 
 }
 
 }
 if (contador > 0) {
 printf("\n\nQuantidade de numeros iguais : %d ", contador);
 } else {
 printf("\n\nNão foram encontrados numeros iguais");
 }
}
LISTA IV
1 - Faça um programa com uma função para ler um número e se for maior que 20 imprimir a metade 
desse numero. 
#include <stdio.h>
#include <stdlib.h>
// Faça um programa com uma função para ler um número e se for maior que 20 
//imprimir a metade desse numero
void calc(float *num)
{
 float novo;
 if(*num>20.0)
 {
 novo=(*num/2.0);
 *num=novo;
 }
}
int main()
{
 float x;
 printf("Informe o numero: ");
 scanf("%f", &x);
 calc(&x);
 printf("%.2f", x);
 return 0;
}
2 - Apresentar um programa que usa uma função que imprime todos os números divisíveis por 4 que 
sejam menores que 200. 
#include <stdio.h>
#include <stdlib.h>
#define max 200
void divs(int num)
{
 for(num=1;num<max;num++)
 {
 if(num%4==0)
 {
 printf("\nO numero %d e divisivel por 4", num);
 }
 }
}
int main(void)
{
 int x;
 divs(x);
 return 0;
}
3- Criar uma função que receba um caractere como parâmetro e retorne 1 (um) caso seja uma vogal e 
zero caso não seja.
#include <stdio.h>
#include <stdlib.h>
int vog(char l)
{
 if(l=='a' || l=='e' || l=='i' || l=='o' || l=='u')
 {
 return 1;
 }
 else
 {
 return 0;
 }
}
int main()
{
 int i;
 char letra;
 printf("Digite um caractere: ");
 scanf("%c", &letra);
 i = vog(letra);
 if(i==1)
 {
 printf("Esta letra e uma vogal");
 }
 else
 {
 printf("E uma consoante");
 }
 return 0;
}
4 - Um ponteiro pode ser usado para dizer a uma função onde ela deve depositar o resultado de seus 
cálculos. Escreva uma função hm que converta minutos em horas-e-minutos. A função recebe um inteiro 
mnts e os endereços de duas variáveis inteiras, digamos h e m, e atribui valores a essas variáveis de modo 
que m seja menor que 60 e que 60*h+m seja igual a mnts. Escreva também uma função main que use a 
função hm. 
#include <stdio.h>
#include <stdlib.h>
void hm(int mnts, int *h, int *m)
{
 *h = mnts/60;
 *m = mnts%60;
}
int main(void)
{
 int min,*hor,*minu;
 printf("Informe os minutos para serem convertidos em horas: ");
 scanf("%d", &min);
 hm(min,&hor,&minu);
 printf("Sao %d hora(s) e %d minuto(s)", hor,minu);
 return 0;
}
5 - Escreva uma função mm que receba um vetor inteiro v[0..n-1] e os endereços de duas variáveis 
inteiras, digamos min e max, e deposite nessas variáveis o valor de um elemento mínimo e o valor de um 
elemento máximo do vetor. Escreva também uma função main que use a função mm. 
#include <stdio.h>
#include <stdlib.h>
#define numb 5
void mm(int vet[], int *max, int *min)
{
 int y;
 *max=-99999,*min=99999;
 for(y=0;y<numb;y++)
 {
 if(vet[y]>*max)
 {
 *max = vet[y];
 }
 if(vet[y]<*min)
 {
 *min = vet[y];
 }
 }
}
int main(void)
{
 int vet[numb],x, min,max;
 for(x=0;x<numb;x++)
 {
 printf("Informe cinco numeros: ");
 scanf("%d", &vet[x]);
 }
 mm(vet,&max,&min);
 printf("O maximo e %d \nO minimo e %d", max,min);
 return 0;
}
LISTA V
1) Faça um programa que preencha dois vetores de seis elementos numéricos cada um e mostre um 
terceiro vetor que será resultante da intercalação entre os elementos dos dois vetores conforme exemplo,
abaixo utilizando o conceito de ponteiros: 
vet1 possui os elementos 2; 7; 4; 5; 3; 1 
vet2 possui os elementos 5; 8; 3; 11; 7; 2 
e o vetor resultante deverá ser vet3 e apresentar o seguinte resultado = 2; 5; 7; 8; 4; 3; 5; 11; 3; 7; 1; 2 
a) Primeiro solucionar com alocação estática de memória; 
#include <stdlib.h>
int main()
{
 int vet1[6], vet2[6], vet3[12];
 int i,x=0,y=0;
 vet1[0] = 2;
 vet1[1] = 7;
 vet1[2] = 4;
 vet1[3] = 5;
 vet1[4] = 3;
 vet1[5] = 1;
 vet2[0] = 5;
 vet2[1] = 8;
 vet2[2] = 3;
 vet2[3] = 11;
 vet2[4] = 7;
 vet2[5] = 2;
 for(i=0;i<12;i++)
 {
 vet3[i] = vet1[x];
 i++;
 vet3[i] = vet2[y];
 x++;
 y++;
 }
 for(i=0;i<12;i++)
 {
 printf("\n%d", vet3[i]);
 }
 return 0;
}
b) O segundo programa deverá ser usando ponteiros apenas; 
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
 int vet1[6],vet2[6],*vet3,i,j=0,x=0;
 vet1[0] = 2;
 vet1[1] = 7;
 vet1[2] = 4;
 vet1[3] = 5;
 vet1[4] = 3;
 vet1[5] = 1;
 vet2[0] = 5;
 vet2[1] = 8;
 vet2[2] = 3;
 vet2[3] = 11;
 vet2[4] = 7;
 vet2[5] = 2;
 vet3 = (int *)calloc(12 , sizeof(int));
 for(i=0;i<12;i++)
 {
 vet3[i] = vet1[x];
 i++;
 vet3[i] = vet2[j];
 j++;
 x++;
 }
 for(i=0;i<12;i++)
 {
 printf("\n%d", vet3[i]);
 }
 return 0;
}
c) O terceiro programa deverá ser com alocação dinâmica de memória e o total de elementos no 
vetor deverá ser lido do teclado. Bem como os valores a serem testados.
#include <stdio.h>
#include <stdlib.h>
int main()
{
 int *vet1,*vet2,*vet3,i,j=0,x=0;
 int num1, num2, num3;
 printf("Informe a quantidade de numeros do primeiro vetor: ");
 scanf("%d", &num1);
 vet1 = (int *)calloc(num1,sizeof(int));
 for(i=0;i<num1;i++)
 {
 printf("\nInforme os numeros do primeiro vetor: ");
 scanf("%d", &vet1[i]);
 }
 printf("Informe a quantidade de numeros do segundo vetor: ");
 scanf("%d", &num2);
 vet2 = (int *)calloc(num2,sizeof(int));
 for(i=0;i<num2;i++)
 {
 printf("\nInforme os numeros do segundo vetor: ");
 scanf("%d", &vet2[i]);
 }
 num3 = num1+num2;
 vet3 = (int *)calloc(num3, sizeof(int));
 for(i=0;i<num3;i++)
 {
 vet3[i] = vet1[x];
 i++;
 vet3[i] = vet2[j];
 j++;
 x++;
 }
 for(i=0;i<num3;i++)
 {
 printf("\n%d", vet3[i]);
 }
 return 0;
}
3) Criar uma função para ler uma matriz de qualquer tamanho, as dimensões de linhas e colunas serão 
lidas do teclado. Inicialmente esta matriz deverá ser inicializada com zeros. Depois crie outra função 
que preencherá a mesma matriz com valores lidos do teclado. Por fim, apresente a chamada das funções 
em um programa main().
#include <stdio.h>
#include <stdlib.h>
// Criar uma função para ler uma matriz de qualquer tamanho, as dimensões de linhas e 
//colunas serão lidas do teclado. Inicialmente esta matriz deverá ser inicializada com 
//zeros. Depois crie outra função que preencherá a mesma matriz com valores lidos do 
//teclado. Por fim, apresente a chamada das funções em um programa main(). 
void matzero(int n, int m, int *A[n][m])
{
 int x,y;
 for(x=0;x<n;x++)
 {
 for(y=0;y<m;y++)
 {
 A[x][y] = 0;
 }
 }
}
void prematriz(int n, int m, int *A[n][m])
{
 int x,y;
 for(x=0;x<n;x++)
 {
 for(y=0;y<m;y++)
 {
 printf("Informeos valores das posicoes [%d] [%d]: ", x,y);
 scanf("%d", &A[x][y]);
 }
 }
}
int main(void)
{
 int i,j,x,y;
 printf("Informe numero de linhas e colunas da matriz: ");
 scanf("%d %d", &i,&j);
 int M[i][j];
 matzero(i,j,&M);
 for(x=0;x<i;x++)
 {
 for(y=0;y<j;y++)
 {
 printf("%d", M[x][y]);
 }
 printf("\n");
 }
 prematriz(i,j,&M);
 for(x=0;x<i;x++)
 {
 for(y=0;y<j;y++)
 {
 printf("%d", M[x][y]);
 }
 printf("\n");
 }
 return 0;
}
6 - Faça um programa como uma função que receba um ano como argumento e retorne o dia e o mês em
que cai o feriado de Páscoa. 
O algoritmo é o seguinte: 
#include <stdio.h>
#include <string.h>
void pascoa(int ANO)
{
 char mes_pascoa[10];
 int A = ANO%19,B = ANO/100,C = ANO%100,D=B/4,E=B%4,F=(B+8)/25;
 int G=(B-F+1)/3,H=(19*A+B-D-G+15)%30,I=C/4,K=C%4;
 int L= (32+2*E+2*I-H-K)%7;
 int M=(A+11*H+22*L)/451;
 int MES=(H+L-7*M+114)/31;
 switch(MES)
 {
 case 3:
 strcpy(mes_pascoa, "Marco");
 break;
 case 4:
 strcpy(mes_pascoa, "Abril");
 break;
 default:
 printf("Inválido");
 break;
 }
 int DIA = ((H+L-7*M+114)%31)+1;
 printf("O dia da pascoa sera: %d do mes: %s", DIA, mes_pascoa);
}
int main(void)
{
 int a;
 printf("Informe o ano: ");
 scanf("%d", &a);
 pascoa(a);
}
LISTA VI
1. Leia e armazene num vetor de 10 posições o nome dos alunos aprovados no vestibular para Ciência da 
Computação em 2013/1. A seguir, leia um nome de entrada e verifique se este aluno consta na listagem dos 
aprovados e mostre sua classificação (ordem de aprovação, representada pelo índice do vetor +1). Caso o 
nome informado não exista na lista dos aprovados, mostre uma mensagem ‘Nome informado não consta na 
lista dos aprovados’. 
Ex: 
Vetor de Aprovados: 
 Ana Santos João Souza Maria Silveira ... ... 
0 1 2 3 ... 9 
 O aluno João Souza foi aprovado em 2º. Lugar 
#include <stdio.h>
#include <stdlib.h>
#define APROVADOS 10
#define MAX_LETRAS 80 // O número máximo de letras que um nome pode conter.
int main(void)
{
 printf("CIENCIA DA COMPUTACAO 2013/1\n\n");
 printf("Insira os nomes dos %d candidatos aprovados em ordem decrescente de posicao:\n\n", 
APROVADOS);
 char aprovados[APROVADOS][MAX_LETRAS];
 int i;
 for(i = 0; i < APROVADOS; ++i)
 {
 printf("%ia posicao: ", i + 1);
 gets(aprovados[i]);
 }
 printf("\n");
 printf("Insira o nome de um candidato:\n");
 char candidato[MAX_LETRAS];
 gets(candidato);
 printf("\n");
 for(i = 0; i < APROVADOS; ++i)
 if(strcmp(candidato, aprovados[i]) == 0)
 {
 printf("O(a) candidato(a) %s foi APROVADO(A) em %do lugar.\n", candidato, i + 1);
 return 0;
 }
 printf("O(a) candidato(a) %s NAO foi aprovado(a).\n", candidato);
 return 0;
}
2. Leia e armazene num vetor de 5 posições o nome dos alunos matriculados na disciplina de Algoritmos I. 
Considere que a posição do vetor corresponde ao código do aluno. 
Ex: Vetor de Alunos Matriculados: 
 Ana 
Sant
os 
João 
Souz
a 
Mari
a 
Silve
ira 
... ... 
0 1 2 3 4 
 A seguir, armazene em 3 vetores as notas N1, N2 e N3 obtidas por estes alunos na disciplina de Algoritmos 
I, respectivamente. Considere que o índice do vetor corresponde ao código do aluno. 
Sabendo que a média final de um aluno é definida como a média aritmética entre as 3 notas obtidas, e que 
um aluno é aprovado se obtiver média igual ou superior a 6.0, mostre para cada aluno: 
- seu nome 
- média final obtida 
- “aprovado” ou “reprovado”
#include <stdio.h>
#include <stdlib.h>
#define ALUNOS 5
int main(void)
{
 printf("NOTAS DE ALGORITMOS I\n\n");
 char nomes[ALUNOS][80];
 float notas1[ALUNOS];
 float notas2[ALUNOS];
 float notas3[ALUNOS];
 int i;
 for(i = 0; i < ALUNOS; ++i)
 {
 printf("ALUNO %d\n", i + 1);
 printf("Nome: ");
 fflush(stdin);
 gets(nomes[i]);
 printf("Nota 1: ");
 scanf("%f", &notas1[i]);
 printf("Nota 2: ");
 scanf("%f", &notas2[i]);
 printf("Nota 3: ");
 scanf("%f", &notas3[i]);
 printf("\n");
 }
 for(i = 0; i < ALUNOS; ++i)
 {
 printf("ALUNO %d\n", i + 1);
 printf("%s\n", nomes[i]);
 double media = (notas1[i] + notas2[i] + notas3[i]) / 3.0;
 printf("Media: %.1f\n", media);
 if(media >= 6.0)
 printf("APROVADO\n");
 else
 printf("REPROVADO\n");
 printf("\n");
 }
}
3.Faça um programa que leia uma string digitada pelo usuário (máximo 20 caracteres) e imprima na tela o 
número de vogais existente nesta string. 
#include <stdio.h>
#include <stdlib.h>
#define MAX_CARACTERES 20
int main(void)
{
 char string[MAX_CARACTERES];
 printf("Insira uma string de no maximo %d caracteres:\n\n", MAX_CARACTERES);
 gets(string);
 int vogais = 0;
 int i;
 for(i = 0; i < MAX_CARACTERES; ++i)
 switch(string[i])
 {
 case 'a':
 case 'e':
 case 'i':
 case 'o':
 case 'u':
 ++vogais;
 }
 printf("\n\nHa %d vogal(is) nos %d caractere(s) da string.\n", vogais, MAX_CARACTERES);
 return 0;
}
LISTA VII
1) Fazer um programa com alocação dinâmica que calcula a média em um vetor. 
Entrada: inteiro n 
n números inteiros 
Saída: 
média dos n números 
Obs.: tamanho máximo de n é 100, informe ao usuário caso entrada esteja errada. 
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
 printf("MEDIA DE VALORES INTEIROS\n\n");
 int n = 0;
 while(1)
 {
 printf("Deseja que o programa calcule a media de quantos valores?\n");
 scanf("%d", &n);
 if(n >= 1)
 break;
 else
 printf("Entrada invalida! O numero de valores deve ser maior que 0.\n\n");
 }
 printf("\n");
 int* numeros = (int*)malloc(n * sizeof(int));
 if(numeros == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 return 1;
 }
 printf("Insira os valores:\n");
 int i;
 for(i = 0; i < n; ++i)
 {
 printf("%3d: ", i + 1);
 scanf("%d", &numeros[i]);
 }
 int soma = 0;
 for(i = 0; i < n; ++i)
 soma += numeros[i];
 free(numeros);
 printf("\nMedia dos valores inseridos: %.2f\n", (float)soma / n);
 return 0;
}
2) Multiplicação inversa entre dois vetores. 
Leia dois vetores de mesmo tamanho determinado pelo usuário e faça a multiplicação inversa, 
coloque o resultado em um terceiro vetor e depois imprima-o. 
#include <stdio.h>
#include <stdlib.h>
void lerDados(int* vetor, int tamanho);
void mostrarDados(int* vetor, int tamanho);
int main(void)
{
 printf("MULTIPLICACAO INVERSA ENTRE DOIS VETORES\n\n");
 int n = 0;
 while(1)
 {
 printf("Deseja que os vetores contenham quantos elementos?\n");
 scanf("%d", &n);
 if(n >= 1)
 break;
 else
 printf("Entrada invalida! O numero de elementos deve ser maior que 0.\n\n");
 }
 printf("\n");
 int* vetorA = (int*)malloc(n * sizeof(int));
 int* vetorB = (int*)malloc(n * sizeof(int));
 if(vetorA == NULL || vetorB == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 return 1;
 }
 printf("Insira os valores para o primeiro vetor:\n");
 lerDados(vetorA, n);
 printf("\n");
 printf("Insira os valores para o segundo vetor:\n");
 lerDados(vetorB, n);
 int* vetorC = (int*)malloc(n * sizeof(int));if(vetorC == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 free(vetorA);
 free(vetorB);
 return 1;
 }
 int i, j;
 for(i = 0, j = (n - 1); i < n; ++i, --j)
 vetorC[i] = vetorA[i] * vetorB[j];
 printf("\n");
 printf("Primeiro vetor:\n");
 mostrarDados(vetorA, n);
 printf("\n");
 printf("Segundo vetor:\n");
 mostrarDados(vetorB, n);
 printf("\n\n");
 printf("Vetor multiplicacao inversa:\n");
 mostrarDados(vetorC, n);
 printf("\n");
 free(vetorA);
 free(vetorB);
 free(vetorC);
 return 0;
}
void lerDados(int* vetor, int tamanho)
{
 int i;
 for(i = 0; i < tamanho; ++i)
 {
 printf("%3d: ", i + 1);
 scanf("%d", &vetor[i]);
 }
}
void mostrarDados(int* vetor, int tamanho)
{
 int i;
 for(i = 0; i < tamanho; ++i)
 printf("%5d", vetor[i]);
}
3) Intercalação de dois vetores ordenados 
Entre com n números (inteiros positivos) em ordem até ser digitado -1, esse será seu primeiro vetor, faça o 
mesmo processo novamente. Imprima-os em ordem . 
observação: caso o usuário digite uma entrada errada, avise que esta errado e peça para digitar novamente.
#include <stdio.h>
#include <stdlib.h>
void lerDados(int** vetor, int* tamanho);
void mostrarDados(int* vetor, int tamanho);
void intercalarDados
(
 int* vetorDestino, int tamanhoDestino,
 int* vetorA, int tamanhoA,
 int* vetorB, int tamanhoB
);
int main(void)
{
 printf("INTERCALACAO DE DOIS VETORES DE INTEIROS POSITIVOS\n\n");
 printf("Insira duas listas de valores inteiros.\n");
 printf("Para terminar a insercao de cada lista, insira um valor negativo.\n\n");
 int* vetorA = NULL;
 int tamanhoA = 0;
 lerDados(&vetorA, &tamanhoA);
 int* vetorB = NULL;
 int tamanhoB = 0;
 lerDados(&vetorB, &tamanhoB);
 printf("\n");
 if(tamanhoA <= 0 && tamanhoB <= 0)
 {
 printf("Alguma das listas tem que conter valores!\n");
 return 1;
 }
 int* vetorC = (int*)malloc((tamanhoA + tamanhoB) * sizeof(int));
 int tamanhoC = tamanhoA + tamanhoB;
 if(vetorC == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 free(vetorA);
 free(vetorB);
 return 1;
 }
 intercalarDados(vetorC, tamanhoC, vetorA, tamanhoA, vetorB, tamanhoB);
 printf("Primeiro vetor:\n");
 mostrarDados(vetorA, tamanhoA);
 printf("\n");
 printf("Segundo vetor:\n");
 mostrarDados(vetorB, tamanhoB);
 printf("\n\n");
 printf("Vetor intercalacao:\n");
 mostrarDados(vetorC, tamanhoC);
 printf("\n");
 free(vetorA);
 free(vetorB);
 free(vetorC);
 return 0;
}
void lerDados(int** vetor, int* tamanho)
{
 while(1)
 {
 int entrada = 0;
 scanf("%d", &entrada);
 if(entrada >= 0)
 {
 *vetor = realloc(*vetor, (*tamanho + 1) * sizeof(int));
 if(*vetor == NULL)
 {
 printf("\nNao foi possivel alocar memoria.\n");
 exit(1);
 }
 (*vetor)[(*tamanho)++] = entrada;
 }
 else
 break;
 }
}
void mostrarDados(int* vetor, int tamanho)
{
 int i;
 for(i = 0; i < tamanho; ++i)
 printf("%5d", vetor[i]);
}
void intercalarDados
(
 int* vetorDestino, int tamanhoDestino,
 int* vetorA, int tamanhoA,
 int* vetorB, int tamanhoB
)
{
 int i;
 int a = 0;
 int b = 0;
 for(i = 0; i < (tamanhoA + tamanhoB) && i < tamanhoDestino;)
 {
 if(a < tamanhoA)
 vetorDestino[i++] = vetorA[a++];
 if(b < tamanhoB)
 vetorDestino[i++] = vetorB[b++];
 }
}
5) Fazer um programa com alocação dinâmica lê uma matriz e devolve como saída na tela a matriz 
transposta. 
Entrada: n(dimensão da matriz quadrada) 
matriz 
Saída: matriz transposta 
#include <stdio.h>
#include <stdlib.h>
void alocarMatriz(int*** matriz, int linhas, int colunas);
void liberarMatriz(int*** matriz, int linhas);
void lerMatriz(int** matriz, int linhas, int colunas);
void mostrarMatriz(int** matriz, int linhas, int colunas);
int main(void)
{
 printf("MATRIZ TRANSPOSTA\n\n");
 int n = 0;
 while(1)
 {
 printf("Insira a dimensao da matriz quadrada:\n");
 scanf("%d", &n);
 if(n >= 1)
 break;
 else
 printf("Entrada invalida! A dimensao da matriz tem que ser maior que 0.\n\n");
 }
 printf("\n");
 int** matriz = NULL;
 alocarMatriz(&matriz, n, n);
 printf("Insira os valores para a matriz:\n\n");
 lerMatriz(matriz, n, n);
 int** matrizT = NULL;
 alocarMatriz(&matrizT, n, n);
 int i, j;
 for(i = 0; i < n; ++i)
 for(j = 0; j < n; ++j)
 matrizT[i][j] = matriz[j][i];
 printf("\n");
 printf("Matriz\n\n");
 mostrarMatriz(matriz, n, n);
 printf("\n");
 printf("Matriz Transposta\n\n");
 mostrarMatriz(matrizT, n, n);
 liberarMatriz(&matriz, n);
 liberarMatriz(&matrizT, n);
 return 0;
}
void alocarMatriz(int*** matriz, int linhas, int colunas)
{
 *matriz = (int**)malloc(linhas * sizeof(int*));
 if(*matriz == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 exit(1);
 }
 int i;
 for(i = 0; i < linhas; ++i)
 {
 (*matriz)[i] = (int*)malloc(colunas * sizeof(int));
 if((*matriz)[i] == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 exit(1);
 }
 }
}
void liberarMatriz(int*** matriz, int linhas)
{
 int i;
 for(i = 0; i < linhas; ++i)
 free((*matriz)[i]);
 free(matriz);
}
void lerMatriz(int** matriz, int linhas, int colunas)
{
 int i, j;
 for(i = 0; i < linhas; ++i)
 {
 printf("\tLinha %3d\n", i + 1);
 for(j = 0; j < colunas; ++j)
 {
 printf("\t\tColuna %3d: ", j + 1);
 scanf("%d", &matriz[i][j]);
 }
 printf("\n");
 }
}
void mostrarMatriz(int** matriz, int linhas, int colunas)
{
 int i, j;
 for(i = 0; i < linhas; ++i)
 {
 printf("\t");
 for(j = 0; j < colunas; ++j)
 printf("%5d", matriz[i][j]);
 printf("\n");
 }
}
6) Fazer um programa com alocação dinâmica que realiza a multiplicação de matrizes. 
Entrada : dimensão da matriz A 
matriz A 
Dimensão da matriz B 
matriz B 
Saída: Multiplicação AB 
Obs: Caso o usuário entre com a dimensão de B errado, imprima uma mensagem de erro e encerre o 
programa. 
#include <stdio.h>
#include <stdlib.h>
void alocarMatriz(int*** matriz, int linhas, int colunas);
void liberarMatriz(int*** matriz, int linhas);
void lerMatriz(int** matriz, int linhas, int colunas);
void mostrarMatriz(int** matriz, int linhas, int colunas);
int main(void)
{
 printf("MULTIPLICACAO DE DUAS MATRIZES\n\n");
 int** matrizA = NULL;
 int linhasA = 0;
 int colunasA = 0;
 printf("Matriz A\n");
 while(1)
 {
 printf("Insira o numero de linhas: ");
 scanf("%d", &linhasA);
 if(linhasA >= 1)
 break;
 else
 printf("Entrada invalida! O numero de linhas deve ser maior que 0.\n\n");
 }
 while(1)
 {
 printf("Insira o numero de colunas: ");
 scanf("%d", &colunasA);
 if(colunasA >= 1)
 break;
 else
 printf("Entrada invalida! O numero de colunas deve ser maior que 0.\n\n");
 }
 alocarMatriz(&matrizA, linhasA, colunasA);
 printf("\n");
 int** matrizB = NULL;
 int linhasB = 0;
 int colunasB = 0;
 printf("Matriz B\n");
 while(1)
 {printf("Insira o numero de linhas: ");
 scanf("%d", &linhasB);
 if(linhasB >= 1 && linhasB == colunasA)
 break;
 else
 printf("Entrada invalida! O numero de linhas deve ser maior que 0\n"
 "e igual ao numero de colunas da matriz A.\n\n");
 }
 while(1)
 {
 printf("Insira o numero de colunas: ");
 scanf("%d", &colunasB);
 if(colunasB >= 1)
 break;
 else
 printf("Entrada invalida! O numero de colunas deve ser maior que 0.\n\n");
 }
 alocarMatriz(&matrizB, linhasB, colunasB);
 printf("\n");
 printf("Insira os valores para a matriz A:\n\n");
 lerMatriz(matrizA, linhasA, colunasA);
 printf("\n");
 printf("Insira os valores para a matriz B:\n\n");
 lerMatriz(matrizB, linhasB, colunasB);
 int** matrizC = NULL;
 int linhasC = linhasA;
 int colunasC = colunasB;
 alocarMatriz(&matrizC, linhasC, colunasC);
 int i, j;
 for(i = 0; i < linhasC; ++i)
 for(j = 0; j < colunasC; ++j)
 {
 int soma = 0;
 int aj, bi;
 for(aj = 0, bi = 0; aj < colunasA; ++aj, ++bi)
 soma += matrizA[i][aj] * matrizB[bi][j];
 matrizC[i][j] = soma;
 }
 printf("\n");
 printf("Matriz A\n\n");
 mostrarMatriz(matrizA, linhasA, colunasA);
 printf("\n");
 printf("Matriz B\n\n");
 mostrarMatriz(matrizB, linhasB, colunasB);
 printf("\n");
 printf("Matriz Multiplicacao\n\n");
 mostrarMatriz(matrizC, linhasC, colunasC);
 liberarMatriz(&matrizA, linhasA);
 liberarMatriz(&matrizB, linhasB);
 liberarMatriz(&matrizC, linhasC);
 return 0;
}
void alocarMatriz(int*** matriz, int linhas, int colunas)
{
 *matriz = (int**)malloc(linhas * sizeof(int*));
 if(*matriz == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 exit(1);
 }
 int i;
 for(i = 0; i < linhas; ++i)
 {
 (*matriz)[i] = (int*)malloc(colunas * sizeof(int));
 if((*matriz)[i] == NULL)
 {
 printf("Nao foi possivel alocar memoria.\n");
 exit(1);
 }
 }
}
void liberarMatriz(int*** matriz, int linhas)
{
 int i;
 for(i = 0; i < linhas; ++i)
 free((*matriz)[i]);
 free(matriz);
}
void lerMatriz(int** matriz, int linhas, int colunas)
{
 int i, j;
 for(i = 0; i < linhas; ++i)
 {
 printf("\tLinha %3d\n", i + 1);
 for(j = 0; j < colunas; ++j)
 {
 printf("\t\tColuna %3d: ", j + 1);
 scanf("%d", &matriz[i][j]);
 }
 printf("\n");
 }
}
void mostrarMatriz(int** matriz, int linhas, int colunas)
{
 int i, j;
 for(i = 0; i < linhas; ++i)
 {
 printf("\t");
 for(j = 0; j < colunas; ++j)
 printf("%5d", matriz[i][j]);
 printf("\n");
 }
}