Exerccios de Linguagem de Programao II

Lista 1
1. Quais sero os valores de x, y e p ao final do trecho de cdigo abaixo?

int x, y, *p;
y = 0;
p = &y;
x = *p;
x = 4;
(*p)++;
--x;
(*p) += x;
Resp: x = 3, y = 4, p apontando para y (*p = 4).

2. Os programas (trechos de cdigo) abaixo possuem erros. Qual(is)? Como deveriam ser?
a)
void main() {
int x, *p;
x = 100;
p = x; //p deveria receber o endereo de x, j que p um ponteiro (e x no). Ponteiros armazenam o
endereo para o qual eles apontam! O cdigo correto seria: p = &x;
printf(Valor de p: %d.\n, *p);
}

b)
void troca (int *i, int *j) {
int *temp;
*temp = *i;
*i = *j;
*j = *temp;
}
A varivel temp no precisava ser um ponteiro, j que apenas precisa armazenar um valor inteiro, sem
precisar apontar para algum lugar.

3. Suponha que os elementos do vetor v so do tipo int e cada int ocupa 8 bytes no seu computador. Se o
endereo de v[0] 55000, qual o valor da expresso v + 3?
Se v (ou o endereo de v[0]), que representa o primeiro item do vetor est no byte de endereo 55000, logo
o ndice v[3] (ou v + 3) estar no byte 55000 + 8*3 = 55024. Nota: em mquinas de 32 bits, inteiros ocupam
32 bits (4 bytes).
4. Escreva uma funo mm que receba um vetor inteiro v[0..n-1] e os endereos de duas variveis inteiras,
digamos min e max, e deposite nessas variveis o valor de um elemento mnimo e o valor de um
elemento mximo do vetor. Escreva tambm uma funo main que use a funo mm.
#include <stdio.h>
#include <stdlib.h>
#define tam 5
void mm(int vet[],int* min, int* max){
int i;
*min=vet[0];
*max =vet[0];
for (i=0; i< tam;i++){
if (*min>vet[i])
*min = vet[i];
if (*max<vet[i])
*max = vet[i];
}
}
int main()
{ int min, max, vet[tam],i;
for (i=0;i<tam;i++){
printf("Digite valor %d ",i);
scanf("%d",&vet[i]);
}
mm(vet,&min,&max);
printf("\nValor minino %d\nValor maximo %d ",min,max);
return 0;
}

5. Qual o resultado do cdigo abaixo? Explique cada linha.
int x = 100, *p, **pp;
p = &x;
pp = &p;
printf(Valor de pp: %d\n, **pp);

int x = 100, *p, **pp; //x recebe o valor 100, p um ponteiro para inteiro e pp um ponteiro para ponteiro
para inteiro
p = &x; //p passa a apontar para o endereo de x (logo, *p tem o valor 100)
pp = &p; //pp passa a apontar para o endereo de p, logo *pp o valor de pp, que o mesmo que p e **pp
o mesmo que *p, que o mesmo que x (que igual a 100)
printf(Valor de pp: %d\n, **pp); //imprime o valor de **pp, que igual ao valor de x, como mencionado
na linha acima

6. Escreva uma especificao de tipos abstratos de dados (TAD) para os nmeros complexos, a + bi, onde a
a parte real e b a parte imaginria.
(a + bi) + (c + di) = (a + c) + (b + d)i,
(a + b) * (c + di) = (a * c b * d) + (a * d + b * c)i
(a + bi) = (-a) + (-b)i.
Ento, implemente em C nmeros complexos, conforme especificado acima, usando estruturas com partes
reais e complexas. Escreva rotinas para somar, multiplicar e negar (inverter) tais nmeros.
NumComplexo.h
typedef struct TNumComplexos{
int pI, pIm;
}NumComplexo;

NumComplexo* somar(NumComplexo *n1, NumComplexo *n2);
NumComplexo* multiplica(NumComplexo *n1, NumComplexo *n2);
void inverteNum(NumComplexo *n1);

NumComplexo.c
#include "NumComplexo.h"
#include <stdlib.h>
NumComplexo* somar(NumComplexo *n1, NumComplexo *n2){
NumComplexo *num = (NumComplexo *)malloc(sizeof(NumComplexo));
num->pI = n1->pI + n2->pI;
num->pIm = n1->pIm + n2->pIm;
return num;
}
NumComplexo* multiplica(NumComplexo *n1, NumComplexo *n2){
NumComplexo *num = (NumComplexo *)malloc(sizeof(NumComplexo));
num->pI = n1->pI * n2->pI;
num->pIm = n1->pIm * n2->pIm;
return num;
}
void inverteNum(NumComplexo *n1)
{
n1->pI = (-1)*n1->pI;
n1->pIm = (-1)*n1->pIm;
}

main.c
#include <stdio.h>
#include <stdlib.h>
#include "NumComplexo.h"

int main()
{
NumComplexo num1, num2,num3;
printf("Primeiro Numero complexo\n ");
printf("Digite a parte real ");
scanf("%d", &num1.pI);
printf("Digite a parte imaginaria ");
scanf("%d", &num1.pIm);
printf("\nSegundo Numero complexo\n ");
printf("Digite a parte real ");
scanf("%d", &num2.pI);
printf("Digite a parte imaginaria ");
scanf("%d", &num2.pIm);
num3 = *somar(&num1, &num2);
printf("\nResulado da soma dos numeros complexos\n");
if (num3.pIm>0)
printf("%d + %di",num3.pI,num3.pIm);
else
printf("%d %di",num3.pI,num3.pIm);
num3 = *multiplica(&num1, &num2);
printf("\nResulado da multiplicao dos numeros complexox\n");
if (num3.pIm>0)
printf("%d + %di",num3.pI,num3.pIm);
else
printf("%d %di",num3.pI,num3.pIm);
printf("\nInverte Numero complexo\n");
inverteNum(&num1);
if (num1.pIm>0)
printf("%d + %di",num1.pI,num1.pIm);
else
printf("%d %di",num1.pI,num1.pIm);
return 0;
}

7. Escreva uma especificao de tipos abstratos de dados (TAD) para os nmeros reais. Vamos supor que
um nmero real seja representado por uma estrutura em C, como esta:
struct realtype
{
int esquerda;
int direita;
};
onde esquerda e direita representam os dgitos posicionados esquerda e direita do ponto decimal,
respectivamente. Se esquerda for um inteiro negativo, o nmero real representado ser negativo.
Escreva uma rotina para criar um nmero real
Escreva rotinas adio, subtrao e multiplicao que aceitem duas dessas estruturas e definam o valor de
uma terceira estrutura para representar o nmero que seja a soma, a diferena e o produto,
respectivamente, dos dois registros de entrada.
TReal.h
typedef struct TRealTipo
{
int esquerda;
int direita;
}realTipo;
realTipo criaNumero(int esquerda, int direita);
realTipo soma(realTipo n1, realTipo n2);
realTipo subtracao(realTipo n1, realTipo n2);
realTipo multiplicacao(realTipo n1, realTipo n2);

TReal.c
realTipo criaNumero(int esquerda, int direita){
realTipo num ;
num.esquerda = esquerda;
num.direita = direita;
return num;
}
realTipo soma(realTipo n1, realTipo n2){
realTipo n3;
n3.esquerda = (n1.esquerda+n2.esquerda) ;
n3.direita = ((n1.direita+n2.direita));
return n3;
}
realTipo subtracao(realTipo n1, realTipo n2){
realTipo n3;
n3.esquerda = n1.esquerda - n2.esquerda;
n3.direita = n1.direita - n2.direita;
return n3;
}
realTipo multiplicacao(realTipo n1, realTipo n2){
realTipo n3;
n3.esquerda = n1.esquerda * n2.esquerda;
n3.direita = n1.direita * n2.direita;
return n3;
}

8. Voc dever implementar um tipo abstrato de dados TConjunto para representar conjuntos de nmeros
inteiros. Seu tipo abstrato dever armazenar os elementos do conjunto e o seu tamanho n. Considere
que o tamanho mximo de um conjunto 20 elementos e use arranjos de 1 dimenso (vetores) para a
sua implementao. Seu TAD deve possuir procedimentos (ou funes quando for o caso) para:
a) criar um conjunto vazio;
b) ler os dados de um conjunto;
c) fazer a unio de dois conjuntos;
d) verificar se dois conjunto so iguais (possuem os mesmos elementos);
e) imprimir um conjunto;

TConjunto.h
typedef struct TConjunto{
int tamanho;
int elemento[20];
}conjunto;

int cria(int n, conjunto *c);
void ler(conjunto *c);
int uniao (conjunto c1, conjunto c2, conjunto *c3);
int iguais (conjunto c1, conjunto c2);
void imprima(conjunto c1);

TConjunto.c
#include "TConjunto.h"
#include <stdio.h>
int cria(int n, conjunto *c){
int i;
if (n <=20){
c->tamanho= n;
for (i = 0; i < n;i++){
c->elemento[i] = 0;
return 1;
}
}
c->tamanho = 0;
return 0;
}
void ler(conjunto *c){
int i;
for (i=0; i < c->tamanho; i++){
printf("Digite elemento %d ",i);
scanf("%d", &c->elemento[i]);
}
}
int uniao (conjunto c1, conjunto c2, conjunto *c3){
int i,j=0;
if (c1.tamanho + c2.tamanho <=20) {
c3->tamanho = c1.tamanho + c2.tamanho;
for (i=0; i<c1.tamanho;i++){
c3->elemento[j] = c1.elemento[i];
j++;
}
for (i=0; i<c2.tamanho;i++){
c3->elemento[j] = c2.elemento[i];
j++;
}
return 1;
}
return 0;

}
int iguais (conjunto c1, conjunto c2){
int i;
if (c1.tamanho == c2.tamanho ){
for (i=0; i<c1.tamanho;i++) {
if (c1.elemento[i] != c2.elemento[i])
return 0;
}
return 1;
}
return 0;
}
void imprima(conjunto c1){
int i;
printf("Tamanho: %d\n",c1.tamanho);
printf("Elementos\n");
for (i=0; i<c1.tamanho;i++)
printf("%d ",c1.elemento[i]) ;
printf("\n");
}

Main.c
#include <stdio.h>
#include <stdlib.h>
#include "TConjunto.h"
int main()
{ conjunto c1, c2,c3;
if (cria(5,&c1))
printf("Conjunto criado\n");
else
printf("Conjunto nao pode ser criado\n");

if (cria(4,&c2))
printf("Conjunto criado\n");
else
printf("Conjunto nao pode ser criado\n");
ler(&c1);
ler (&c2);
uniao(c1,c2,&c3);
imprima(c1);
imprima(c2);
imprima(c3);
if (iguais(c1,c2))
printf("Conjunto iguais");
else
printf ("Conjunto diferentes");
return 0;
}

9. Considere as seguintes informaes sobre cada aluno de uma determinada disciplina:
Nome com at 30 caracteres;
Matrcula com 8 caracteres;
Turma com apenas 1 caractere;
Notas das 3 provas;
Sabendo que existem mais de uma turma por disciplina,
a. Crie um TAD, em C, de forma modular, que armazene as informaes anteriores e as funes de
manuteno dos registros (Preenche, Imprime).
b. Implemente uma funo que tenha como valor de retorno a mdia final obtida pelos os alunos de
uma determinada turma. A nota final de cada aluno dada pela mdia das trs provas.
c. Crie um programa principal que imprima a mdia de uma turma.
TAlunos.h
typedef struct TAlunos{
char nome[30];
char matricula [8];
char turma;
float notas[3];
}alunos;
void preenche (alunos t[], int quant);
void imprima(alunos t[],int quant);
float media (alunos t[], int quant);

TAlunos.c
#include <stdlib.h>
#include <stdio.h>
#include "TAlunos.h"

void preenche (alunos t[], int quant){
int i,j;
for (i=0;i< quant; i++){
printf("Nome: ");
gets(t[i].nome);
printf("Matricula: ");
gets(t[i].matricula);
printf("Turma: ");
scanf(" %c",&t[i].turma);
for (j=0; j<3;j++){
printf("Nota %d: ",(j+1));
scanf("%f",&t[i].notas[j]);
}
getchar();
}
}
void imprima(alunos t[], int quant){
int i,j;
for (i=0;i< quant; i++){
printf("Nome: ");
puts(t[i].nome);
printf("Matricula: ");
puts(t[i].matricula);
printf("Turma: %c",t[i].turma );
for (j=0; j<3;j++)
{ printf("\nNota %d: %.2f ",(j+1),t[i].notas[j]); }
printf("\n\n");
}
}
float media (alunos t[], int quant){
int i,j;
float soma=0.0;
for (i=0;i < quant; i++){
for (j=0; j<3;j++){ soma +=t[i].notas[j]; }
}
return soma/quant;
}

10. Faa um programa que leia um valor n e crie dinamicamente um vetor de n elementos e passe esse
vetor para uma funo que vai ler os elementos desse vetor. Depois, no programa principal, o vetor
preenchido deve ser impresso. Alm disso, antes de finalizar o programa, deve-se liberar a rea de
memria alocada.
#include <stdio.h>
#include <stdlib.h>
void preenche(int *v, int n){
int i;
for (i=0; i<n;i++){
printf("Digite elemento %d ", i);
scanf("%d",&v[i]); }
}
int main()
{ int n,i;
printf("Digite a quantidade de elementos");
scanf("%d",&n);
int *v =(int *)malloc(n*sizeof(int));
if (v==NULL){
printf("Memria insuficiente");
exit(1);
}
preenche(v,n);
for (i=0; i < n;i++){
printf("%d ",v[i]); }
free(v); return 0;
}