PROTOCOLO

Prévia do material em texto

Relatório - Programa: Aventura na Floresta Sussurrante 
 Introdução 
Este programa foi desenvolvido em Portugol WebStudio para simular uma 
aventura interativa na qual o jogador, um explorador corajoso, escolhe um dos 
três caminhos disponíveis na Floresta Sussurrante. A aplicação da lógica de 
programação ocorre por meio de condições e menus de decisão, utilizando a 
estrutura de seleção ESCOLHA-CASO e a estrutura condicional SE. A 
pontuação final do jogador é determinada com base nas escolhas feitas e nos 
desafios superados. 
 Lógica do Programa 
Ao iniciar, o programa exibe uma introdução que apresenta a aventura e 
explica que o jogador deve escolher um dos três caminhos disponíveis. 
O jogador é solicitado a selecionar uma opção digitando 1, 2 ou 3, cada uma 
correspondendo a um dos caminhos: 
Caminho das Sombras 
Caminho da Luz 
Caminho das Criaturas 
Se o jogador escolher um número diferente de 1, 2 ou 3, o programa exibe uma 
mensagem de erro informando que a opção é inválida e encerra a execução. 
Funcionamento do Programa 
Caminho 1: O Caminho das Sombras 
Descrição: O caminho é misterioso e perigoso, envolto em escuridão e com 
árvores antigas. 
Desafio: O jogador encontra uma criatura mágica que faz um enigma: 
Pergunta: "Quem sou eu? Tenho olhos, mas não vejo. Tenho boca, mas não 
falo." 
Resposta correta: Caveira. 
Lógica: 
Se o jogador acertar a resposta, o programa adiciona 100 pontos à sua 
pontuação e exibe a mensagem: "Você encontrou uma gema preciosa!" 
Se errar, o jogador não ganha pontos e a mensagem é: "Você não conseguiu 
resolver o enigma e perdeu sua chance." 
Caminho 2: O Caminho da Luz 
Descrição: Um caminho mais seguro, iluminado pela luz do sol. 
Desafio: O jogador encontra uma ponte quebrada sobre um rio perigoso e 
deve decidir: 
 Atravessar a ponte quebrada. 
 Buscar um desvio seguro. 
Lógica: 
Se escolher atravessar e for bem-sucedido, o programa adiciona 50 pontos e 
exibe: "Você encontrou uma fonte mágica e restaurou sua saúde!" 
Se buscar um desvio, o jogador não ganha pontos adicionais. 
Caminho 3: O Caminho das Criaturas 
Descrição: Este caminho é mais imprevisível, cheio de sons estranhos e 
pegadas misteriosas. 
Desafio: O jogador encontra uma criatura adormecida bloqueando o caminho e 
deve decidir: 
Contornar a criatura com cuidado. 
Acordá-la para passar. 
Lógica: 
Se o jogador decidir contornar a criatura com sucesso, ele ganha 75 pontos e 
uma habilidade especial de camuflagem. 
Se escolher acordá-la, a criatura fica furiosa e o jogador não recebe pontos. 
 Possíveis Erros e Mensagens 
Se o jogador digitar uma opção que não seja 1, 2 ou 3, o programa exibe a 
mensagem: 
"Opção inválida. Por favor, escolha 1, 2 ou 3." 
Em seguida, o programa encerra. 
Conclusão 
Este programa utiliza as estruturas ESCOLHA-CASO para decidir qual caminho 
o jogador segue e SE-SENÃO para validar as respostas e ações do usuário 
dentro de cada caminho. A lógica foi estruturada para proporcionar uma 
narrativa envolvente e recompensar escolhas corretas com pontos. 
Testes realizados: 
Todas as opções de caminho foram testadas e funcionam corretamente. 
A pontuação é calculada corretamente com base nas escolhas do jogador. 
Mensagens de erro são exibidas adequadamente para entradas inválidas. 
Este programa cumpre o objetivo de aplicar os fundamentos de lógica de 
programação e estruturas de decisão em uma narrativa interativa. Além disso, 
ele foi testado para garantir que todas as funcionalidades e mensagens sejam 
exibidas corretamente durante a execução. 
programa {} 
funcao inicio() 
escreval("Você é um explorador corajoso que se aventura em uma misteriosa 
Floresta Sussurrante em busca de tesouros lendários e segredos 
perdidos.\n") 
escreval("Ao adentrar na floresta, você se depara com três caminhos 
diferentes:\n") 
 
escreval("1. O Caminho das Sombras\n") 
escreval("2. O Caminho da Luz\n") 
escreval("3. O Caminho das Criaturas\n") 
escreva("Escolha um caminho (1, 2 ou 3): ") 
 
inteiro opcao 
leia(opcao) 
 
// Verificar a opção escolhida 
escolha opcao 
caso 1: 
caminho_das_sombras() 
pare 
caso 2: 
caminho_da_luz() 
pare 
caso 3: 
caminho_das_criaturas() 
pare 
caso contrario: 
escreval("Escolha inválida. Por favor, selecione um caminho válido.\n") 
inicio() // Reinicia a função para escolher novamente 
fimescolha 
fimfuncao 
funcao caminho_das_criaturas() 
escreval("Você escolheu o Caminho das Criaturas.\n") 
escreval("Este caminho é repleto de estranhas pegadas misteriosas no 
chão. Parece ser o caminho mais imprevisível...\n") 
escreval("Você se depara com uma criatura mágica adormecida, bloqueando a 
passagem.\n") 
 
 
 
cadeia decisao 
escreval("Digite 'contornar' para tentar contornar a criatura ou 
'acordar' para acordá-la: ") 
leia(decisao) 
se (decisao = "contornar") entao 
escreval("Você tenta contornar a criatura silenciosamente...\n") 
senao se (decisao = "acordar") entao 
escreval("Você decide acordar a criatura com cuidado...\n") 
senao 
escreval("Decisão inválida. Tente novamente.\n") 
caminho_das_criaturas() // Reinicia a função para nova decisão 
fimenquanto 
fimfuncao 
funcao caminho_das_sombras() 
escreval("Você escolheu o Caminho das Sombras...\n") 
// Implementar o que acontece nesse caminho 
fimfuncao 
 
funcao caminho_da_luz() 
escreval("Você escolheu o Caminho da Luz...\n") 
// Implementar o que acontece nesse caminho 
fimfuncao 
{} 
 
 
 
Relatório do Programa - Labirinto com Estrutura "Enquanto-Faça" 
Introdução 
Este relatório descreve o desenvolvimento e o funcionamento de um programa 
escrito em Portugol, cujo objetivo é simular a exploração de um labirinto 5x5. 
O jogador é representado como um explorador que deve encontrar um tesouro 
escondido no labirinto, enfrentando caminhos livres e limites de 
movimentação. O programa utiliza a estrutura de repetição "enquanto-faça" 
para manter a exploração até que o jogador encontre o tesouro. 
 Objetivo 
Implementar um labirinto 5x5 em forma de matriz, com a posição do tesouro 
definida aleatoriamente. 
Utilizar a estrutura de repetição "enquanto-faça" para manter o jogo em 
execução até o tesouro ser encontrado. 
Permitir a movimentação do jogador pelas teclas (w - cima, s - baixo, a - 
esquerda, d - direita). 
Aplicar lógica de programação, uso de matrizes e controle de fluxo com 
condições. 
 Passo a Passo do Código 
Logo no início, declaramos as variáveis principais do programa: 
portugol 
Copiar código 
inteiro labirinto[5][5] // Matriz do labirinto 5x5 
inteiro posX = 0, posY = 0 // Posição inicial do explorador (0,0) 
inteiro tesouroX, tesouroY // Posição aleatória do tesouro 
caractere movimento // Para capturar a entrada do jogador 
logico encontrouTesouro = falso // Indica se o tesouro foi encontrado 
A matriz labirinto[5][5] representa o labirinto com 25 posições. 
As variáveis posX e posY indicam a posição atual do explorador. 
tesouroX e tesouroY armazenam a posição aleatória onde o tesouro será 
colocado. 
A variável encontrouTesouro controla a execução do loop principal. 
 Geração Aleatória do Tesouro 
A função sorteiaTesouro() gera a posição do tesouro usando a função 
aleatorio(). O objetivo é garantir que o tesouro esteja em uma posição aleatória 
diferente a cada execução do programa. 
portugol 
Copiar código 
funcao sorteiaTesouro() 
{ 
 tesouroX = inteiro(aleatorio(5)) 
 tesouroY = inteiro(aleatorio(5)) 
 
 // Impede que o tesouro apareça na posição inicial (0,0) 
 se (tesouroX == 0 && tesouroY == 0) 
 { 
 tesouroX = 4 
 tesouroY = 4 
 } 
 
 labirinto[tesouroX][tesouroY] = 2 // Marca o tesouro na matriz 
}Se a posição gerada for (0,0), o tesouro é colocado na posição (4,4) para 
garantir que ele não esteja na posição inicial. 
Loop Principal do Programa - Estrutura "enquanto-faça" 
O loop principal mantém o jogo rodando até que o explorador encontre o 
tesouro. 
portugol 
Copiar código 
enquanto (encontrouTesouro == falso) 
{ 
 limpaTela() // Limpa a tela para atualizar o labirinto 
 mostraLabirinto() // Mostra o estado atual do labirinto 
 escreva("\nEscolha um movimento (w: cima, a: esquerda, s: baixo, d: direita): 
") 
 leia(movimento) // Lê o movimento do jogador 
 moverExplorador(movimento) // Move o explorador com base no comando 
 verificaTesouro() // Verifica se o tesouro foi encontrado 
} 
• limpaTela(): Atualiza a tela a cada movimento. 
• mostraLabirinto(): Exibe a matriz atualizada com a posição do jogador 
e os caminhos livres. 
• leia(movimento): Lê o comando do jogador para mover o explorador. 
• moverExplorador(movimento): Executa a movimentação do 
explorador. 
• verificaTesouro(): Verifica se a posição atual do explorador coincide 
com a posição do tesouro. 
 Função de Movimentação do Explorador 
A função moverExplorador() permite que o jogador se mova pela matriz com as 
teclas indicadas: 
portugol 
Copiar código 
funcao moverExplorador(caractere movimento) 
{ 
 se (movimento == 'w' && posX > 0) // Para cima 
 { 
 posX = posX - 1 
 } 
 senao se (movimento == 's' && posX 0) // Para a esquerda 
 { 
 posY = posY - 1 
 } 
 senao se (movimento == 'd' && posY 0) 
 { 
 posX = posX - 1 
 } 
 // Movimento para baixo 
 senao se (movimento == 's' && posX 0) 
 { 
 posY = posY - 1 
 } 
 // Movimento para a direita 
 senao se (movimento == 'd' && posYcomo if-else e switch-case para a tomada de decisão. 
 Objetivo 
O sistema avalia as informações financeiras fornecidas pelo cliente e decide se o 
empréstimo será aprovado ou negado. A partir das entradas fornecidas pelo cliente 
(renda, valor solicitado, histórico de crédito e estabilidade no emprego), o programa 
analisa se todos os critérios são atendidos. Caso algum critério não seja satisfeito, o 
programa informa o motivo da rejeição. 
 Passo a Passo do Código 
Declaração das Variáveis 
Definimos variáveis para capturar as entradas fornecidas pelo usuário e outras 
necessárias para a lógica do sistema. 
c 
Copiar código 
#include 
#include // Para utilizar o tipo booleano 
 
int main() { 
 float renda, valorEmprestimo, entrada; 
 char historicoCredito; // 'B' para bom, 'R' para ruim 
 int estabilidadeEmprego; // Tempo de emprego em anos 
 bool aprovado = true; // Variável para controlar a decisão final 
 
 // Solicitação das entradas do usuário 
 printf("Digite sua renda mensal: "); 
 scanf("%f", &renda); 
 
 printf("Digite o valor do emprestimo desejado: "); 
 scanf("%f", &valorEmprestimo); 
 
 printf("Digite o valor da entrada: "); 
 scanf("%f", &entrada); 
 
 printf("Informe o historico de credito (B para bom, R para ruim): 
"); 
 scanf(" %c", &historicoCredito); // O espaço evita problemas de 
buffer 
 
 printf("Informe o tempo de estabilidade no emprego (em anos): "); 
 scanf("%d", &estabilidadeEmprego); 
• Variáveis: 
o renda: renda mensal do cliente. 
o valor Empréstimo: valor solicitado para o empréstimo. 
o entrada: valor da entrada fornecida pelo cliente. 
o Histórico Credito: histórico de crédito do cliente (Bom ou Ruim). 
o estabilidade Emprego: tempo de estabilidade no emprego. 
o aprovado: variável que indica se o empréstimo será aprovado ou não. 
Lógica de Aprovação – Estrutura 
 
A lógica de aprovação verifica se cada um dos critérios foi atendido. Caso algum deles 
não seja satisfeito, a variável aprovada é definida como falso, e uma mensagem 
específica é exibida. 
 
Critérios Implementados: 
Relação entre Renda e Valor do Empréstimo: O valor do empréstimo não pode ser 
maior que 30% da renda mensal. 
Histórico de Crédito: Se o cliente possui um histórico ruim, o empréstimo é rejeitado. 
Estabilidade no Emprego: O cliente deve ter pelo menos 2 anos de estabilidade no 
emprego. 
Entrada Mínima: A entrada deve ser de no mínimo 10% do valor do empréstimo. 
Exibição do Resultado 
Após verificar todos os critérios, o programa exibe o resultado da análise. 
c 
Copiar código 
 // Exibe o resultado final 
 if (aprovado) { 
 printf("Emprestimo aprovado! Parabens.\n"); 
 } else { 
 printf("Nao foi possivel aprovar o emprestimo.\n"); 
 } 
 
 return 0; 
} 
• Se todos os critérios forem atendidos, o programa exibe a mensagem 
"Empréstimo aprovado!". 
• Caso contrário, exibe a mensagem "Não foi possível aprovar o empréstimo" e 
explica o motivo específico durante a execução das verificações. 
Testes e Resultados 
Teste 1: Cliente com renda de R$5000, solicitando um empréstimo de R$1000 com 
entrada de R$150, histórico de crédito bom e 3 anos de estabilidade. 
Resultado: Empréstimo aprovado. 
Teste 2: Cliente com histórico de crédito ruim. 
Resultado: Empréstimo rejeitado devido ao histórico. 
Teste 3: Cliente com estabilidade de apenas 1 ano no emprego. 
Resultado: Empréstimo rejeitado por falta de estabilidade. 
 
 
 
Conclusão 
Este sistema de análise de empréstimos em C é uma solução eficiente para verificar a 
elegibilidade de clientes com base em múltiplos critérios. A implementação demonstra 
o uso prático de estruturas condicionais e lógica de programação, sendo útil para tomada 
de decisão em instituições financeiras. 
 
programa { 
 funcao inicio() { 
 
 } 
} 
#include 
#include // Para utilizar o tipo booleano 
 
int main() { 
 float renda, valorEmprestimo, entrada; 
 char historicoCredito; // 'B' para bom, 'R' para ruim 
 int estabilidadeEmprego; // Tempo de emprego em anos 
 bool aprovado = true; // Variável para controlar a decisão final 
 
 // Solicitação das entradas do usuário 
 printf("Digite sua renda mensal: "); 
 scanf("%f", &renda); 
 
 printf("Digite o valor do emprestimo desejado: "); 
 scanf("%f", &valorEmprestimo); 
 
 printf("Digite o valor da entrada: "); 
 scanf("%f", &entrada); 
 
 printf("Informe o historico de credito (B para bom, R para ruim): "); 
 scanf(" %c", &historicoCredito); 
 
 printf("Informe o tempo de estabilidade no emprego (em anos): "); 
 scanf("%d", &estabilidadeEmprego); 
 
 // Verificação dos critérios 
 if (valorEmprestimo > 0.3 * renda) { 
 printf("Emprestimo rejeitado: Valor do emprestimo excede 30%% da 
renda mensal.\n"); 
 aprovado = false; 
 } 
 
 if (historicoCredito == 'R') { 
 printf("Emprestimo rejeitado: Historico de credito ruim.\n"); 
 aprovado = false; 
 } 
 
 if (estabilidadeEmprego 
#include 
#include 
 
typedef struct { 
 char nome[50]; 
 float mediaDisciplina1; 
 float mediaDisciplina2; 
 float mediaGeral; 
 int classificacao; 
} Aluno; 
• nome: Nome do aluno. 
• mediaDisciplina1 e mediaDisciplina2: Médias das disciplinas. 
• mediaGeral: Média geral calculada. 
• classificacao: Posição do aluno na classificação geral. 
 
 Função para Calcular a Média Geral 
Esta função recebe as médias das disciplinas e retorna a média geral do aluno. 
c 
Copiar código 
float calcularMediaGeral(float nota1, float nota2) { 
 return (nota1 + nota2) / 2; 
} 
 
 
Função de Comparação para Ordenação 
Para classificar os alunos por média geral em ordem decrescente, utilizamos a função 
qsort() do C, que precisa de uma função de comparação. 
c 
Copiar código 
int compararMedias(const void *a, const void *b) { 
 Aluno *alunoA = (Aluno *)a; 
 Aluno *alunoB = (Aluno *)b; 
 return (alunoB->mediaGeral > alunoA->mediaGeral) - (alunoB-
>mediaGeral mediaGeral); 
} 
 
Função para Gravar os Dados no Arquivo .txt 
Essa função grava as informações dos alunos no arquivo e calcula a média geral da 
turma. 
c 
Copiar código 
void salvarArquivo(Aluno *alunos, int n) { 
 FILE *arquivo = fopen("classificacao_alunos.txt", "w"); 
 if (arquivo == NULL) { 
 printf("Erro ao abrir o arquivo.\n"); 
 exit(1);} 
 
 fprintf(arquivo, "Classificacao dos Alunos:\n\n"); 
 
 float mediaTurma = 0; 
 for (int i = 0; i 
#include 
#include 
 
typedef struct { 
 char nome[50]; 
 float mediaDisciplina1; 
 float mediaDisciplina2; 
 float mediaGeral; 
 int classificacao; 
} Aluno; 
 
float calcularMediaGeral(float nota1, float nota2) { 
 return (nota1 + nota2) / 2; 
} 
 
int compararMedias(const void *a, const void *b) { 
 Aluno *alunoA = (Aluno *)a; 
 Aluno *alunoB = (Aluno *)b; 
 return (alunoB->mediaGeral > alunoA->mediaGeral) - (alunoB-
>mediaGeral mediaGeral); 
} 
 
void salvarArquivo(Aluno *alunos, int n) { 
 FILE *arquivo = fopen("classificacao_alunos.txt", "w"); 
 if (arquivo == NULL) { 
 printf("Erro ao abrir o arquivo.\n"); 
 exit(1); 
 } 
 
 fprintf(arquivo, "Classificacao dos Alunos:\n\n"); 
 
 float mediaTurma = 0; 
 for (int i = 0; i