Trabalho de linguagem de programacao - LINGUAGEM DE PROGRAMAÇÂO

Prévia do material em texto

CENTRO UNIVERSITÁRIO INTERNACIONAL UNINTER 
ESCOLA SUPERIOR POLITÉCNICA 
TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE 
SISTEMAS 
DISCIPLINA DE LINGUAGEM DE PROGRAMAÇÃO 
 
 
 
ATIVIDADE PRÁTICA 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
EXERCÍCIO 1: ESCREVA UM ALGORITMO EM LINGUAGEM C COM AS 
SEGUINTES INSTRUÇÕES: 
1. Declare três variáveis (inteiro, real e char); 
2. Declare três ponteiros; 
3. Associe as variáveis aos ponteiros; 
4. Modifique os valores de cada variável indiretamente usando os ponteiros 
associados. Para armazenar os valores nas variáveis, armazene na variável char a 
primeira letra do seu nome, na variável inteira os dois últimos dígitos do seu RU e na 
variável real os 4 últimos dígitos do seu RU, sendo os 2 últimos os valores com 
virgula; 5. Imprima na tela os valores das variáveis antes e após a modificação. 
 
#include <stdio.h> //Biblioteca 
#include <stdlib.h> 
#include <stdio.h> // Biblioteca de entra e saída padrão C 
#include <stdlib.h> // Biblioteca padrão C ela quem faz a alocação na memoria e 
controla os processos 
 
int main()// Para o codigo ser executado precisamos iniciar nosso condigo com a 
função main 
{// utilizamos chaves para dar inicio ao codigo 
 int x = 80; // int para valores inteiros o valor inteiro referente aos 
dois ultimos numeros das RU do Welington RU : 3173880 numero utilizado é o 80 
 float y = 38.80; // float para valor real com ponto, valor referente aos quatro 
ultimos numeros das RU do Welington RU :3173880 numero utilizado é o ponto 
38.80 char z = 'W'; // char para demonstrar um caractere o qual 
solicitado foi a primeira letra do Welington letra: W 
 
 int* pX = &x; // utilizando o asterisco * para identificar que é um 
ponteiro este ponteiro vai estar indicando o valor da variavel inteira x=80 e o 
endereco de memoria float* pY = &y; //utilizamos o asteriscos* para 
identificar que é um ponteiro este ponteiro vai estar indicando o valor da 
variavel com ponto (.) y=38.80 e o endereco de memoria char* pZ = &z; 
//utilizamos o asterisco* para identificar que é um ponteiro este ponteiro vai 
estar indicando o valor da variavel tipo caractere z= 
*W* e o endereco de memoria 
 printf("Endereco x = %p - valor de x = %i\n", pX, 
*pX); printf("Endereco y = %p - valor de y = %f\n", 
pY, *pY); printf("Endereco z = %p - valor de z = %c\n", 
pZ, *pZ); 
 // printf para imprimir na tela os enderecos de memoria e os valores 
referentes a cada um das variaveis . 
 system("pause"); //comando que pausa a mensagem na tela e solicita 
uma tecla para continuar return 0; // para retornar sem erro 
 
}// para finalizar o codigo. 
 
 
 
 
 
 
 
 
Imagem do código funcionando no seu computador: 
 
 
 
 
 
Exercício 2: Escreva um algoritmo em LINGUAGEM C que armazene na memória o seu 
RU e o valor 1234567, ambos digitados pelo usuário na tela. Em seguida, imprima na 
tela ambos RU usando ponteiros. O algoritmo também vai ter que comparar os dois RU 
usando ponteiros e imprimir na tela qual é o maior. 
 
 
#include <stdio.h> // Biblioteca de entra e saída padrão C 
#include <stdlib.h> // Biblioteca padrão C ela quem faz a alocação na memoria e 
controla os processos 
 void maior(int* x, int* y); //void inicial para ter o retorno do ponteiro 
maior int main()// Para o codigo ser executado precisamos iniciar nosso 
condigo com a função main 
{// utilizamos chaves para dar inicio ao codigo int 
ru, ru2, * p1, * p2; // declaracao das variaveis 
 
 printf("1 -DIGITE SEU RU, E PRECIONE A TECLA ENTER :"); // printf para 
imprimir na tela os enderecos de memoria e os valores referentes a cada um das 
variaveis. 
 scanf_s("%d", &ru); //fazendo a leitura do primeiro dado de entrada 
printf("\n"); // pulando uma linha 
 printf("2 -DIGITE O SEGUNDO RU, E PRECIONE A TECLA ENTER : "); // printf para 
imprimir na tela os enderecos de memoria e os valores referentes a cada um das 
variaveis. 
 scanf_s("%d", &ru2); //fazendo a leitura do segundo dado de entrada 
p1 = &ru; //declaração do primeiro ponteiro p2 = &ru2; 
//declaraçao do segundo ponteiro 
 
 printf(" \n SEU RU: %d", *p1); // mensagem impressa na tela com indicaçao do 
ponteiro 1 
 printf(" \n SEGUNDO RU: %d\n", *p2); // mensagem impressa na tela com 
indicaçao do ponteiro 2 
 maior(&ru, &ru2); // retorno da maior 
variavel printf("\n\n\n"); // pulando linhas 
 
 system("pause"); //comando que passa a mensagem na tela e solicita uma tecla 
para continuar 
}// para finalizar o codigo. 
 
void maior(int* x, int* y) //void inicial para ter o retorno do ponteiro maior { 
 if (*x > * y) //estara trazendo o valor maior 
 { 
 printf("\ NO RU MAIOR E : %d\n", *x); //se for maior vai me trazer o 
valor de x } else { 
 printf("\ NO RU MAIOR E : %d\n", *y); //se for maior vai me trazer o 
valor de y 
 } 
 //if_else para determinar qual vai ser a maior Ru 
 
} 
 
 
Imagem do código funcionando no seu computador: 
 
 
 
Exercício 3: Faça um algoritmo em linguagem C com as seguintes funcionalidades: 
• Receba um registro, com dois campos, como dados de entrada. 
• O primeiro campo é um vetor que vai armazenar o nome do aluno. 
• O segundo campo é uma variável do tipo inteiro que vai armazenar o RU do aluno. 
• Imprime na tela os dados armazenados na estrutura. 
 
#include <stdio.h> //Biblioteca 
#include <stdlib.h> 
typedef struct reg1 //declaracao do registro solicitado 
{ char name[100];//vetor nome quantidade de 
letras int RuAluno;//variavel RU do aluno 
}reg;//declara variavel registro int main() { 
 { 
 reg ficha;//declara variavel registro ficha 
 
nome 
printf("\nDigite seu nome: ");//solicita ao usuario que digite seu 
 scanf("%s", &ficha.name); //armazena o nome 
 printf("\nDigite o numero do Ru:"); 
 scanf("%d", &ficha.RuAluno); //informa os dados armazenados 
 printf("\n\nDados do aluno\n"); //vai imprimir a mensagem na tela 
 
digitado 
printf("\nNome do Aluno:%s", ficha.name); //imprime o nome 
 
digitado 
printf("\nNumero do Ru:%d", ficha.RuAluno); //imprime o RU 
 printf("\n\n"); 
 system("pause"); 
 return(0); 
 } 
 
Imagem do código funcionando no seu computador: 
 
 
Exercício 4: 
Replique o exercício 3. Porém, agora, declare um ponteiro para a estrutura de dados 
heterogênea. No momento da leitura dos dados e da impressão na tela, use o ponteiro 
para buscar o conteúdo dos campos. Imprima na tela também o seu RU na tela. 
 
#include <stdio.h> //Biblioteca 
#include <stdlib.h> 
typedef struct reg1 { //criação do registro char 
name[100];//vetor nome quantidade de letras int 
RuAluno; //variavel RU do aluno 
}reg; main() { reg ficha, * p; //declaração da variavel com ponteiro 
 p = &ficha; //aponta o ponteiro p para para ficha printf("\nDigite seu 
nome: ");// solicita que o usuario digite seu nome scanf("%s", &p->name); 
//armazena o nome digitado printf("\nDigite o numero do RU:"); 
 scanf("%d", &p->RuAluno); printf("\n\nDados do aluno\n"); //vai imprimir a 
mensagem na tela printf("Nome do Aluno: %s", p->name); 
 printf("\nNumero do RU:%d\n", p->RuAluno); 
 system("pause"); 
 return(0); 
} 
 
 
 
Imagem do código funcionando no seu computador: 
 
 
Exercício 5: Faça um algoritmo em linguagem C que contenha dois números inteiros 
digitados na tela pelo usuário: 
a. O primeiro número marca um início; 
b. O segundo número marca um fim; 
O algoritmo vai contar quantos números existem entre o início (primeira entrada) e o fim 
(segunda entrada). A impressão na tela do usuário deve ser realizada de duas formas: 
a. Iterativa; 
b. Recursiva; Ao colocar no seu relatório uma imagem do seu código funcionando, 
coloque ele rodando utilizando como valor de inicio os 2 últimosvalores do seu RU e 
valor final o número 99. 
 
 
#include <stdio.h> 
 
#include <stdlib.h> 
 
 int qtdeEntreNumeros(int numero, int fim); //assinatura da 
função 
 int 
main() 
 
{ 
 int x, y, i, qtde = 0, qtde2 = 0; //declaração das variáveis 
printf("Digite um inteiro inicio:"); //Impressão na tela 
 
 scanf_s("%d", &x); //Leitura de valor na dela e guarda na variável x 
 
 
 printf("Digite um inteiro fim:"); //Impressão na tela 
 
 scanf_s("%d", &y); //Leitura de valor na dela e guarda na variável y 
 
 
 for (i = x + 1; i < y; i++) //Laço de repetição por iteração 
 
 { 
 qtde = qtde + 1; //soma 1 a variavel qtde 
 
 } 
 
 
 qtde2 = qtdeEntreNumeros(x, y); //chamada da função que retorna o valor para 
a variavel qtde2 
 
 
 printf("Resposta Iteracao: %d\n", qtde); //Impressão na tela 
 
 printf("Resposta Fatorial: %d\n", qtde2); //Impressão na tela 
 
} 
 
 
int qtdeEntreNumeros(int numero, int fim) //função que recebe dois parametros e 
retorna um interno 
 
{ 
 int qtde = 0; //declaração da variavél 
 
 if (fim > numero) //teste condicional que verifica se o número é menor que o 
fim 
 return (1); 
 
else 
 { 
 
 //Chamada recursiva 
 qtde = qtdeEntreNumeros(numero + 1, 
fim); 
 
 return (qtde); 
 
 } 
 
} 
Imagem do código funcionando no seu computador: