PDS2- vpl1-2-3

Prévia do material em texto

PDS2 
VPL 1 – CONTAGEM DE LETRAS 
O objetivo desse VPL é praticar os comandos de entrada e saída específicos de C++ 
(cin, cout) e também a utilização do tipo string. Não utilize outros comando de 
entrada como o getline. 
Escreva um programa que lê como entrada apenas uma palavra. Em seguida, seu 
programa deve contar o número de ocorrências de cada letra presente na palavra. 
Por fim, deve-se imprimir a quantidade de vezes que uma determinada letra 
apareceu. Se uma letra não aparece na palavra, ela não deve ser impressa. Imprima 
as letras em ordem alfabética. 
Para facilitar, você pode assumir que as palavras sempre terão todas as letras 
minúsculas. Considere que os caracteres válidos são os presentes no intervalo “a” a 
“z”. 
Exemplos de entrada e saída: 
input = 
estudantes 
output = 
a 1 
d 1 
e 2 
n 1 
s 2 
t 2 
u 1 
input = 
abacaxi 
output = 
a 3 
b 1 
c 1 
i 1 
x 1 
Dicas: 
Dica 1: 
Teste o arquivo localmente. Para isso, sugerimos utilizar o seguinte comando: 
./executavel < entrada.txt 
O arquivo entrada.txt possui a palavra a ser utilizada como entrada. 
Dica 2: 
Utilize operações entre caracteres para facilitar. Exemplo: 
char caractere = 'c' 
int indice = caractere - 'a' 
O valor da variável índice será 2. 
#include<iostream> 
 
using namespace std; 
 
int main() { 
 string palavra; 
 cin >> palavra; 
 
 int ocorrencias[26]; 
 for (int i = 0, ie = 26; i < ie; i++) { 
 ocorrencias[i] = 0; 
 } 
 for (int ch: palavra) { 
 int asc_code = ch - 'a'; 
 ocorrencias[asc_code]++; 
 } 
 
 for (int i = 0, ie = 26; i < ie; i++) { 
 if (ocorrencias[i] != 0) { 
 char letra = 'a' + i; 
 cout << letra << " " << ocorrencias[i] << endl; 
 } 
 } 
 return 0; 
} 
 
 
VPL 2 – PONTEIROS 
Esse exercício foi desenhado para se praticar a manipulação de dados em memória 
considerando-se o uso de ponteiros. 
Deve-se preencher o corpo das funções com o código para realizar a tarefa descrita 
nas linhas. 
#include <iostream> 
#include <cstddef> 
#include <string> 
 
using namespace std; 
 
// 1) A funcao deve adicionar dez a uma variavel inteira 
 
void add10(int *n) { 
 
 *n+=10; 
} 
 
// 2) A funcao deve comparar dois endereços, retornando true se apontarem 
para a mesma posicao na memoria e false caso contrario 
 
bool compare_end(int *num1, int *num2) { 
 
 if (num1 == num2) { 
 return true; 
 } 
 else{ 
 return false; 
 } 
} 
 
// 3) A funcao deve comparar os valores armazenados em dois enderecos, 
retornando true se forem iguais e false caso contrario 
 
bool compare_val(int *num1, int *num2) { 
 
 if (*num1 == *num2) { 
 return true; 
 } 
 else{ 
 return false; 
 } 
} 
 
// 4) A funcao deve receber o ponteiro para um numero inteiro e retornar 
o ponteiro para um caracter 
 
char* cast_TO_char(int *n) { 
 
 char *c = NULL; 
 
 c = (char*) n; 
 return c; 
 
} 
 
// 5) A funcao deve imprimir todos os caracteres ate que o caracter ‘/0’ 
seja encontrado. 
// O parametro é um ponteiro para a primeira posicao do vetor de 
caracteres 
// A funcao deve adicionar uma quebra de linha '\n' apos exibir a 
cadeia de caracteres. 
 
void print_char(char *n) { //n é um vetor de caracteres 
 
 int i=0; 
 for(i=0; i<1; i++){ 
 cout<<n; 
 if(n[i]=='\0'){ 
 break; 
 } 
 cout<<"\n"; 
 } 
 
} 
 
// 6) A funcao deve imprimir uma string. 
// O parametro e a referencia para um string. 
// A funcao deve adicionar uma quebra de linha '\n' apos exibir a string. 
void print_string(string &str) { 
 
 cout << str << endl; 
} 
 
// 7) A funcao deve concatenar uma string (end) ao final de outra (begin) 
void concatenar_string(string &begin, string end) { 
 
 begin += end; 
} 
 
// 8) A funcao deve uma alocar um array com 10 posicoes e 
// inicializa-las com o identificador da sua posição 
 
void aloca_array(int** arr) { 
 *arr = new int[10]; 
 for (int i = 0; i < 10; i++) { 
 (*arr)[i] = i; 
 } 
} 
 
// 9) A funcao deve exibir os valores armazenados em um array 
// Os valores devem ser separados por um espaco 
// Adicione uma quebra de linha após exibir os valores 
void exibe_array(int* arr) { 
 
 for(int i=0; i<10; i++){ 
 cout<< arr[i]<<" "; 
 } 
 cout<<endl; 
} 
 
// 10) A funcao deve adicionar o offset (pos) ao endereco (arr), 
// e retornar um ponteiro para a nova posicao 
int* retorna_addr_array_pos(int* arr, int pos) { 
 
 arr += pos; 
 return arr; 
} 
 
// 11) A funcao deve liberar a memória utilizada pelo array 
void libera_array(int* arr) { 
 
 free(arr); 
} 
 
int main(){ 
 int num1 = 10, num2 = 20, num3 = 10; 
 int num4 = 'a'; 
 
 add10(&num1); 
 cout << num1 << endl; 
 cout << compare_end(&num1, &num2) << endl; 
 cout << compare_val(&num1, &num2) << endl; 
 cout << compare_end(&num1, &num3) << endl; 
 cout << compare_val(&num1, &num2) << endl; 
 char *c = cast_TO_char(&num4); 
 printf("%c\n",c[0]); 
 //cout << "a" << endl; 
 
 char text[21] = "PDS II is the best!\0"; 
 print_char(text); 
 
 string text2 = "PDS II is great!"; 
 print_string(text2); 
 
 concatenar_string(text2, " It is really nice! =D"); 
 print_string(text2); 
 
 int *array; 
 aloca_array(&array); 
 int *p6 = retorna_addr_array_pos(array, 6); 
 *p6 = *p6 * *p6 * 3.1415; 
 cout << "Position 6: " << *p6 << " -> " << (p6 - array) << endl; 
 exibe_array(array); 
 libera_array(array); 
 
 return 0; 
} 
 
VPL 3- ORÇAMENTO FEDERAL 
Neste exercício, devemos implementar dois TADs para auxiliar na resolução do 
seguinte problema: Lisarb é um país que possui orçamento restrito, e diversas 
demandas sociais. Desta forma, seus representantes nos solicitaram construir um 
sistema para auxiliar na gestão dos recursos provenientes de impostos. Segundo a 
lei vigente, cinco categorias de gastos devem ser consideradas, sendo que cada 
uma delas receberá um percentual dos impostos arrecadados. 
As categorias possuem identificadores numéricos, sendo elas: 
• 0 - Saúde 
• 1 - Educação 
• 2 - Segurança 
• 3 - Previdência 
• 4 - Administração Pública 
Os percentuais recebidos por cada categoria devem ser os seguintes: 
• 0 - Saúde - 15% 
• 1 - Educação - 15% 
• 2 - Segurança - 20% 
• 3 - Previdência - 35% 
• 4 - Administração Pública - 15% 
Para realizar esta tarefa, devemos criar os tipos de dados Categoria e Orcamento. 
O TAD Categoria deve possuir um código (inteiro) e o valor que esta categoria de 
gasto possui em caixa (double). 
O TAD Orcamento deve conter as cinco categorias. 
Para manipular uma categoria, será preciso implementar os seguintes métodos: 
• Categoria 
void inicia_categoria(Categoria *categoria, int codigo_categoria, double valor_caixa): 
Inicializa um objeto categoria com seu código e o valor que ela deve ter em caixa 
para gastos com sua pasta. 
int codigo_categoria(Categoria *categoria): Recupera o código correspondente a 
uma categoria. 
double valor_caixa_categoria(Categoria *categoria): Recupera o valor em caixa de 
uma categoria. 
 
 
void adiciona_caixa_categoria(Categoria *categoria, double valor): Adiciona uma 
quantia ao caixa de uma categoria. 
void gasta_caixa_categoria(Categoria *categoria, double valor): Remove uma 
quantia ao caixa de uma categoria. 
• Orcamento 
void inicia_orcamento(Orcamento *orcamento, double impostos): Inicializa um 
objeto Orçamento, sendo que ele deve conter um objeto categoria para cada pasta. 
Recebe como parâmetro o valor monetário que deve ser atribuído a aquele 
orçamento. Este valor deve ser distribuído a cada categoria, nos percentuais 
descritos anteriormente. 
void gasto_categoria(Orcamento *orcamento,int codigo_categoria, double valor): 
Reduz o valor no caixa da categoria especificada. 
double saldo_categoria(Orcamento *orcamento, int codigo_categoria): Retorna o 
valor em caixa da categoria especificada. 
Categoria* recupera_categoria(Orcamento *orcamento, int codigo_categoria): 
Retorna o ponteiro para o objeto da categoria especificada. 
Importante: Uma categoria pode ter dívidas, ou seja, seu caixa pode ser menor que 
zero. 
 
#include<iostream> 
 
using namespace std; 
 
typedef struct Categoria{ 
 
 int codigo; 
 double valor; 
 
} Categoria; 
 
// Inicializa um objeto categoria com seu código e o valor que ela deve 
ter em caixa para gastos com sua pasta. 
void inicia_categoria(Categoria *categoria,int codigo_categoria, double 
valor_caixa) { 
 
 categoria->codigo = codigo_categoria; 
 categoria->valor = valor_caixa; 
 
} 
 
// Recupera o código correspondente a uma categoria. 
int codigo_categoria(Categoria *categoria) { 
 
 return categoria->codigo; 
 
} 
 
// Recupera o valor em caixa de uma categoria. 
double valor_caixa_categoria(Categoria *categoria){ 
 
 double caixa; 
 caixa = categoria->valor; 
 return caixa; 
 
} 
 
// Adiciona uma quantia ao caixa de uma categoria. 
void adiciona_caixa_categoria(Categoria *categoria, double valor) { 
 
 categoria->valor += valor; 
} 
 
// Remove uma quantia ao caixa de uma categoria. 
void gasta_caixa_categoria(Categoria *categoria, double valor) { 
 
 categoria->valor -= valor; 
} 
 
typedef struct Orcamento { 
 
 Categoria categorias[5]; 
 
} Orcamento; 
 
// Inicializa um objeto Orçamento, sendo que ele deve conter um objeto 
categoria para cada pasta. 
// Recebe como parâmetro o valor monetário que deve ser atribuído a 
aquele orçamento. 
// Este valor deve ser distribuído a cada categoria, nos percentuais 
descritos anteriormente. 
void inicia_orcamento(Orcamento *orcamento, double impostos) { 
 
 double valor_saude = 0.15 * impostos; 
 double valor_educacao = 0.15 * impostos; 
 double valor_seguranca = 0.2 * impostos; 
 double valor_previdencia = 0.35 * impostos; 
 double valor_administracao = 0.15 * impostos; 
 
 inicia_categoria(&orcamento->categorias[0], 0, valor_saude); 
 inicia_categoria(&orcamento->categorias[1], 1, valor_educacao); 
 inicia_categoria(&orcamento->categorias[2], 2, valor_seguranca); 
 inicia_categoria(&orcamento->categorias[3], 3, valor_previdencia); 
 inicia_categoria(&orcamento->categorias[4], 4, valor_administracao); 
} 
 
// Reduz o valor no caixa da categoria especificada. 
void gasto_categoria(Orcamento *orcamento, int codigo_categoria, double 
valor) { 
 
 gasta_caixa_categoria(&(orcamento->categorias[codigo_categoria]), 
valor); 
} 
 
// Retorna o valor em caixa da categoria especificada. 
double saldo_categoria(Orcamento *orcamento, int codigo_categoria) { 
 
 double saldo; 
 saldo= valor_caixa_categoria(&(orcamento-
>categorias[codigo_categoria])); 
 
 return saldo; 
} 
 
// Retorna o ponteiro para o objeto da categoria especificada. 
Categoria* recupera_categoria(Orcamento *orcamento, int codigo_categoria) 
{ 
 
 return &(orcamento->categorias[codigo_categoria]); 
} 
 
int main() { 
 Orcamento orcamento; 
 
 char test = 0; 
 while(cin >> test) { 
 switch (test) { 
 case 'o': { 
 double valor = 0; 
 cin >> valor; 
 inicia_orcamento(&orcamento, valor); 
 } 
 break; 
 case 'g': { 
 int categoria = 0; 
 double valor = 0; 
 cin >> categoria >> valor; 
 gasto_categoria(&orcamento, categoria, valor); 
 cout << categoria << ": " << saldo_categoria(&orcamento, categoria) 
<< endl; 
 } 
 break; 
 case 'p': { 
 for (int categoria = 0; categoria < 5; categoria++) { 
 cout << categoria << ": " << saldo_categoria(&orcamento, 
categoria) << endl; 
 } 
 } 
 break; 
 default: { 
 cout << "----------" << endl; 
 } break; 
 } 
 } 
 return 0; 
}