1) O programa abaixo calcula a rea de um tringulo.

Complemente o cdigo de modo que o usurio

informe os lados do tringulo e que sua rea seja calculada e exibida.

struct triangulo { float a,b,c; };
float area_triangulo (struct triangulo tri1){
float s, area;
s = (tri1.a + tri1.b + tri1.c)/2;
area = sqrt(s*(s - tri1.a)*(s - tri1.b)*(s tri1.c));
return area; }

int main(int argc, char *argv[])
{ struct triangulo tri1;
printf("Digite os lados do Tringulo");
scanf("%f %f %f", &tri1.a, &tri1.b, &tri1.c);
printf("A Area do triangulo eh: %.2f\n",area_triangulo(tri1) );
return 0;}

3) Dadas as funes abaixo, complemente a funo main de modo que se crie duas pessoas e as liste na tela.

#include <stdio.h>
#include <stdlib.h>

struct pessoa {
int idade; char sexo; struct pessoa* prox;};
typedef struct pessoa Pessoa;
Pessoa* inicializa (){ return NULL; }
Pessoa* insere (Pessoa* p, int Idade, char S){
Pessoa* nova = (Pessoa*) malloc(sizeof(Pessoa));
nova->idade=Idade; nova->sexo=S; nova->prox=p;
return nova;}
void imprime(Pessoa* p)
{ Pessoa* t;
for (t=p;t!= NULL; t = t->prox){
printf("Idade = %d, Sexo = %c\n", t->idade,t->sexo); } }

int main(int argc, char *argv[])
{Pessoa* p;

p = inicializa();
p = insere(p,33,'M');
p = insere(p,55,'F');
imprime(p);

system("PAUSE");
return 0; }
4) Caso o usurio execute este programa quais sero os valores armazenados no tipo estruturado pilha:

#include <stdio.h>
#include <stdlib.h>
#define MAX 50
struct pilha{
int n;
float vet[MAX];};
typedef struct pilha Pilha;

Pilha* cria(){
Pilha* p = (Pilha*) malloc(sizeof(Pilha));
p->n=0;
return p;}

void coloca(Pilha* p, float valor){
if (p->n == MAX){
printf("Capacidade da pilha estorou.\n"); exit(1);}
p->vet[p->n]=valor; p->n++;}

int vazia (Pilha* p){ return (p->n==0);}

float retira(Pilha* p){
float valor;
if (vazia(p)){printf("Pilha Vazia. \n"); exit(1);}
valor = p->vet[p->n-1];
p->n--;
return valor;}
// Prova A
int main(int argc, char *argv[])
{
Pilha* z;
z = cria();
coloca(z,22); coloca(z,33); retira(z); coloca(z,43);
coloca(z,27); retira(z); coloca(z,32); retira(z); coloca(z,24); coloca(z,30);
// QUAIS SO OS VALORES ARMAZENADOS NA ESTRUTURA PILHA NESTE PONTO.
system("PAUSE");
return 0;}


// Prova B
int main(int argc, char *argv[])
{
Pilha* z;
z = cria();
coloca(z,44); coloca(z,55); coloca(z,43); retira(z);
coloca(z,37); retira(z); coloca(z,22); retira(z); coloca(z,34); coloca(z,60);
// QUAIS SO OS VALORES ARMAZENADOS NA ESTRUTURA PILHA NESTE PONTO.
system("PAUSE");
return 0;}
dfsfsdffds

A B

30 60
24 34
43 55
22 44

Resultado
5) Com base no cdigo abaixo, preencha a tabela com os valores exibidos de nvalue:
PROVA A
#include <stdio.h>
#include <stdlib.h>
#define D0 0x01
#define D1 0x02
int main(int argc, char *argv[])
{ unsigned int nvalue = 0x61;
printf("nvalue(0) = %x\n\n",nvalue);
nvalue = nvalue + D1;
printf("nvalue(1) = %x\n\n",nvalue);
nvalue += D0;
printf("nvalue(2) = %x\n\n",nvalue);
nvalue = nvalue >> 2;
printf("nvalue(3) = %x\n\n",nvalue);
nvalue <<= 1;
printf("nvalue(4) = %x\n\n",nvalue);
nvalue = nvalue | D0;
printf("nvalue(5) = %x\n\n",nvalue);
nvalue = nvalue & ~D1;
printf("nvalue(6) = %x\n\n",nvalue);
system("PAUSE");
return 0;}
PROVA B
#include <stdio.h>
#include <stdlib.h>
#define D0 0x01
#define D1 0x02
int main(int argc, char *argv[])
{ unsigned int nvalue = 0x42;
printf("nvalue(0) = %x\n\n",nvalue);
nvalue = nvalue + D1;
printf("nvalue(1) = %x\n\n",nvalue);
nvalue += D0;
printf("nvalue(2) = %x\n\n",nvalue);
nvalue = nvalue >> 2;
printf("nvalue(3) = %x\n\n",nvalue);
nvalue <<= 1;
printf("nvalue(4) = %x\n\n",nvalue);
nvalue = nvalue | D0;
printf("nvalue(5) = %x\n\n",nvalue);
nvalue = nvalue & ~D1;
printf("nvalue(6) = %x\n\n",nvalue);
system("PAUSE");
return 0;}


nvalue(0) nvalue(0) = 61 nvalue(0) = 42
nvalue(1) nvalue(1) = 63 nvalue(1) = 44
nvalue(2) nvalue(2) = 64 nvalue(2) = 45
nvalue(3) nvalue(3) = 19 nvalue(3) = 11
nvalue(4) nvalue(4) = 32 nvalue(4) = 22
nvalue(5) nvalue(5) = 33 nvalue(5) = 23
nvalue(6) nvalue(6) = 31 nvalue(6) = 21