Portfólio-Algoritmo-e-Logica-de-Programacao

Prévia do material em texto

Autor:Adriano de vasconcelos freire
 
BACHARELADO EM ENGENHARIA DE
CONTROLE E AUTOMAÇÃO
Nova Iguaçu
2024 
Relatório de Aula Prática - Algoritmos e Lógica de Programação
Relatório apresentado a disciplina Algoritmo e Lógica
de Programação como requisito parcial de obtenção
de nota do curso de Bacharelado em Engenharia de
Automação e Controle.
Prof(a) Anderson Emidio de Macedo Goncalves
Nova Iguaçu
2024 
Relatório de Aula Prática - Algoritmos e Lógica de Programação
PORTFÓLIO
SUMÁRIO 
 
INTRODUÇÃO.................................................................................................5
DESENVOLVIMENTO.....................................................................................5
2.1 Floresta Sussurante………………………………………………………...…6 
2.1.1. Função inicio()........................................................................................6 
2.1.2 Função escolher_caminho(caminho)......................................................7 
2.1.3. Função caminho_da_luz()......................................................................8 
2.1.4. Função caminho_das_sombras().........................................................10 
2.1.5. Função caminho_das_criaturas()..........................................................13 
2.2 Labirinto do Tesouro Perdido ............…..............................................… 13 
2.2.1. Análise do Cenário................................................................................13 
2.2.2. Criação de Variáveis e Constantes.......................................................14 
2.2.3. Geração Aleatória do Tesouro e Labirinto............................................15 
2.2.4. Loop Principal - Movimento do Explorador............................................15 
2.2.5. Interação com o Jogador.......................................................................16 
2.2.6. Finalização.............................................................................................18 
2.3 Classificação de Alunos……………………………………………………....20 
2.3.1. Análise de Cenário.................................................................................20 
2.3.2. Criação de Variáveis e Constantes........................................................20 
2.3.3. Cálculo da Média e Ordenação .............................................................21 
2.3.4. Entrada de Dados (Cadastro de Alunos) ...............................................21 
2.3.5. Classificação dos Alunos .......................................................................22 
2.3.6. Salvamento dos Dados em Arquivo.......................................................23 
2.3.7. Finalização.............................................................................................24 
2.4 Sistema de Aprovação de Empréstimos ..……………..…………………...25 
2.4.1. Análise de Cenário ................................................................................25 
2.4.2. Criação de Variáveis e Entrada de Dados ............................................25
2.4.3. Cálculo e Condições para Aprovação....................................................26
2.4.4. Finalização.............................................................................................27
CONSIDERAÇÕES FINAIS.............................................................................28
REFERÊNCIAS BIBLIOGRÁFICAS................................................................28 
Este portfólio apresenta quatro programas distintos, cada um desenvolvido para
explorar conceitos-chave de programação e lógica em diferentes ambientes de
desenvolvimento. Os programas foram criados utilizando duas linguagens de programação 
 
INTRODUÇÃO 
diferentes: Portugol e C, cada um rodando em seu respectivo ambiente de desenvolvimento
(Portugol Web Studio e Visual Studio Code). 
Os códigos apresentados são: 
1. Floresta Sussurrante (Portugol Web Studio): Este programa é um jogo de aventura textual 
onde o jogador, na pele de um explorador corajoso, deve escolher entre diferentes caminhos 
em uma floresta misteriosa. Cada escolha leva a um desfecho diferente, incentivando o uso 
de estruturas condicionais e loops para navegar pelas escolhas narrativas. 
2. Labirinto do Tesouro Perdido (Portugol Web Studio): Neste segundo programa, o jogador 
está em uma missão para encontrar um tesouro escondido no meio de um labirinto perigoso, 
cheio de armadilhas, corredores estreitos, bifurcações e salas ocultas. A lógica do jogo 
envolve a utilização de algoritmos de busca e controle de fluxo para guiar o jogador ao tesouro, 
evitando armadilhas e obstáculos pelo caminho. 
3. Classificação de Alunos (C, Visual Studio Code): Este programa foi desenvolvido para 
classificar alunos com base em suas notas. Utilizando estruturas de controle como loops e 
condicionais, o programa calcula a média das notas de cada aluno, determinando sua 
classificação final. Este exercício enfatiza a importância da manipulação de dados e do 
controle de fluxo na programação em C. 
4. Sistema de Aprovação de Empréstimos (C, Visual Studio Code): O último programa é 
um sistema de aprovação de empréstimos que avalia a elegibilidade do solicitante com base 
em critérios financeiros pré-estabelecidos. Utilizando estruturas condicionais avançadas, o 
programa determina se o empréstimo deve ser aprovado ou negado, considerando fatores 
como renda, histórico de crédito, e outros dados financeiros. Este programa demonstra o uso 
de lógica condicional complexa e manipulação de dados em C. 
Cada um desses programas foi criado com o objetivo de praticar e aprimorar diferentes 
habilidades de programação, desde o controle de fluxo básico até a implementação de 
algoritmos mais complexos. Nas seções a seguir, cada programa será detalhado com 
explicações sobre o código fonte e a lógica de cada função, proporcionando uma visão 
abrangente do desenvolvimento de software em diferentes contextos. 
 
DESENVOLVIMENTO 
2.1 Floresta Sussurante 
2.1.1. Função inicio() 
funcao escolher_caminho(inteiro caminho) { 
escolha(caminho) { 
caso 1: 
caminho_da_luz() 
funcao inicio() { 
inteiro caminho 
escreva("Você é um explorador corajoso que se aventura em uma misteriosa 
Floresta Sussurrante em busca de tesouros lendários e segredos perdidos. \n") 
escreva("Ao adentrar na floresta você se depara com três caminhos diferentes:\n") 
escreva("1 - O Caminho da Luz.\n") 
escreva("2 - O Caminho das Sombras.\n") 
escreva("3 - O Caminho das Criaturas.\n") 
escreva("Escolha um caminho para seguir (1, 2 ou 3): \n") 
leia(caminho) 
escolher_caminho(caminho) 
escreva("Fim do Programa.") 
} 
• Propósito: Esta função é o ponto de entrada do programa. Ela apresenta a 
narrativa inicial ao jogador, explicando o cenário e as opções de caminhos. 
Lógica: • 
Exibe um texto introdutório ao jogador. 
Oferece três caminhos diferentes para o jogador escolher. 
Lê a escolha do jogador e chama a função escolher_caminho() para processar a 
escolha. 
2.1.2 Função escolher_caminho(caminho) 
funcao caminho_da_luz() { 
escreva("Este caminho é iluminado por raios de sol que filtram entre as copas das 
árvores. Parece ser o caminho mais seguro e reconfortante da floresta.\n") 
escreva("O jogador encontra uma ponte quebrada sobre um rio turbulento. Ele deve 
decidir se tentará atravessar a ponte quebrada ou procurará um desvio seguro. \n") 
 pare 
caso 2: 
caminho_das_sombras() 
pare 
caso 3: 
caminho_das_criaturas() 
pare 
caso contrario: 
escreva("Escolha inválida. Por favor, selecione um caminho válido.\n") 
leia(caminho) 
escolher_caminho(caminho) 
} 
} 
• Propósito: Esta função decide qual cenário será apresentado ao jogador com 
base na escolha do caminho. 
Lógica: • 
• Usa a estrutura escolha para determinar qual função será chamada com 
base no número inserido pelo jogador. 
Se o jogador inserir uma opção inválida, a função solicita uma nova entrada 
e chama a si mesma recursivamente. 
•2.1.3. Função caminho_da_luz() 
 cadeia decisao 
enquanto (verdadeiro){ 
escreva("Agora decida seu destino, escreva 'atravessar' para tentar passar pela 
ponte ou escreva 'desvio' para buscar um caminho alternativo: \n") 
leia(decisao) 
se (decisao == "atravessar") { 
escreva("Você conseguiu atravessar a ponte com maestria e segurança!\n") 
escreva("Do outro lado você se deparou com uma fonte encantada que curando 
sua saúde e revitazando por completo seu cansaço, você ganhou 50 pontos!\n") 
escreva("Você venceu!\n") 
pare // Sai do loop após resposta válida 
} 
senao se (decisao == "desvio") { 
escreva("Você decidiu contornar o rio subindo pelos penhascos próximos. No 
entanto, as rochas são instáveis, você perdeu o equilíbrio e acabou caindo de uma altura 
mortal nas águas abaixo.\n") 
escreva("Você perdeu!\n") 
pare // Sai do loop após resposta válida 
} 
senao { 
escreva("Resposta inválida. Por favor, escolha entre 'atravessar' ou 'desvio'.\n") 
} 
} 
} 
• Propósito: Simula o cenário do "Caminho da Luz", onde o jogador deve tomar 
uma decisão crítica. 
Lógica: • 
• 
• 
• 
funcao caminho_das_sombras() { 
escreva("Este caminho é cercado por árvores antigas e sombrias, com raios de lua 
penetrando entre os galhos. Parece ser o caminho mais misterioso e perigoso da floresta.\n") 
escreva("O jogador encontra uma criatura mágica guardiã do caminho, que exige um 
enigma para deixá-lo passar.\n") 
escreva("Guardião: Quem sou eu? Tenho olhos, mas não vejo. Tenho boca, mas não 
falo. O que sou?\n") 
cadeia decisao 
leia(decisao) 
se (decisao == "caveira") { 
escreva("Guardião: Resposta correta, prossiga seu caminho.\n") 
escreva("Você encontrou um bau escondido contendo uma gema preciosa que vale 
100 pontos!\n") 
escreva("Você venceu!\n") 
} 
senao { 
escreva("Guardião: Resposta incorreta. Sua alma agora pertence ao mundo 
sombrio!\n") 
escreva("Você perdeu!\n") 
} 
} 
Descreve o ambiente e o desafio (atravessar uma ponte ou procurar um desvio). 
Utiliza um loop enquanto para garantir que o jogador faça uma escolha válida. 
Dependendo da escolha do jogador, o resultado pode ser vitória (atravessar 
com sucesso) ou derrota (cair ao tentar desviar). 
 
2.1.4. Função caminho_das_sombras() 
• 
• 
• 
• 
• 
Propósito: Apresenta o cenário do "Caminho das Sombras", onde o jogador
enfrenta um desafio de enigma. 
Lógica: 
Descreve o cenário e o desafio apresentado pelo guardião. 
Solicita uma resposta para o enigma. 
Verifica a resposta e determina o resultado (vitória ou derrota) com base na 
resposta correta ("caveira"). 
funcao caminho_das_criaturas() { 
escreva("Este caminho é repleto de sons estranhos e pegadas misteriosas no chão. Parece 
ser o caminho mais imprevisível e enigmático da floresta.\n") 
escreva("O jogador se depara com uma criatura mágica adormecida bloqueando o caminho. 
Ele deve decidir se tentará contornar a criatura com cuidado ou acordá-la para passar.\n") 
cadeia decisao 
enquanto (verdadeiro) { 
escreva("Agora decida seu destino, escreva 'acordar' para despertar a criatura ou 
'contornar' para cuidadoramente seguir seu caminho:\n") 
leia(decisao) 
se (decisao == "acordar") { 
escreva("A Criatura é um monstro sanguinário impiedoso, infelizmente seu destino foi 
selado e sua morte foi brutal.\n") 
escreva("Você perdeu!\n") 
pare // Sai do loop após resposta válida 
} 
senao se (decisao == "contornar") { 
escreva("Você passou pela criatura com total silencio.\n") 
2.1.5. Função caminho_das_criaturas() 
Objetivo: Criar um labirinto onde o jogador deve encontrar o tesouro, evitando 
armadilhas e obstáculos. 
Desafios: Caminhos sem saída, paredes, e uma armadilha que leva o jogador de volta 
ao início. 
Estrutura: O labirinto é representado por uma matriz 5x5, com caminhos livres, 
paredes, armadilhas e o tesouro em posições aleatórias. 
 escreva("No caminho você encontrou uma arvore encantada que lhe condeceu uma 
habilidade especial de camuflagem e ganhando também 75 pontos.\n") 
escreva("Você venceu!\n") 
pare // Sai do loop após resposta válida 
} 
senao { 
escreva("Resposta inválida. Por favor, escolha entre 'acordar' ou 'contornar'.\n") 
} 
} 
} 
• Propósito: Representa o cenário do "Caminho das Criaturas", onde o jogador 
deve decidir como lidar com uma criatura mágica. 
Lógica: 
Descreve o cenário e apresenta as opções de ação (acordar a criatura ou 
contorná-la). 
Utiliza um loop enquanto para garantir que o jogador escolha uma opção válida. 
O resultado depende da escolha do jogador: acordar resulta em derrota, 
enquanto contornar resulta em vitória. 
• 
• 
• 
• 
 
2.2. Labirinto do Tesouro Perdido 
2.2.1. Análise do Cenário 
programa
{ 
inclua biblioteca Util --> u // Biblioteca necessária para utilizar a função "aleatorio" 
A função gerarLabirinto() inicializa o labirinto, preenchendo os caminhos livres e 
adicionando paredes e uma armadilha. 
O tesouro é colocado em uma posição aleatória com a função sorteia(), garantindo 
que não fique na posição inicial do explorador. 
// Função que gera o labirinto 
funcao gerarLabirinto() 
{ 
// Inicializar o labirinto com caminhos livres (0) 
para (inteiro i = 0; i> 0) 
novoX-- 
senao se (direcao == 's' e posX 0) 
novoY-- 
senao se (direcao == 'd' e posY 
#include 
#include 
#define MAX_NOME 100 
#define MAX_ALUNOS 50 
// Definição da estrutura Aluno 
2.3 Classificação de Alunos
2.3.1. Análise de Cenário 
typedef struct { 
char nome[MAX_NOME];
float media_disciplina1;
float media_disciplina2;
float media_geral; int
classificacao; 
} Aluno;
2.3.2. Criação de Variáveis e Constantes 
Define-se a estrutura para armazenar os dados dos alunos, como o nome, as notas
nas disciplinas, a média geral e a classificação. As constantes MAX_NOME e MAX_ALUNOS
determinam os limites de entrada. 
Aqui está a função que calcula a média geral das disciplinas e outra função para comparar
as médias dos alunos para ordenação em ordem decrescente, usada pela função qsort. 
// Função para comparar as médias dos alunos (usada para ordenação) 
int compararMedias(const void *a, const void *b) { 
const Aluno *alunoA = (const Aluno *)a; 
const Aluno *alunoB = (const Aluno *)b; 
if (alunoA->media_geral media_geral) return 1; 
if (alunoA->media_geral > alunoB->media_geral) return -1; 
return 0; 
} 
2.3.4. Entrada de Dados (Cadastro de Alunos) 
// Função para calcular a média geral 
float calcularMediaGeral(float media_disciplina1, float media_disciplina2) { 
return (media_disciplina1 + media_disciplina2) / 2; 
} 
2.3.3. Cálculo da Média e Ordenação 
 
Essa parte do código recebe os dados dos alunos, incluindo nome e notas, e calcula 
a média geral para cada aluno. 
int main() { 
int num_alunos; 
Aluno alunos[MAX_ALUNOS]; 
// Solicitar o número de alunos 
printf("Quantos alunos deseja registrar? (maximo %d): ", MAX_ALUNOS); 
scanf("%d", &num_alunos); 
getchar(); // Limpa o caractere de nova linha do buffer 
// Loop para registrar os dados de cada aluno 
for (int i = 0; i 
#include 
Após registrar os dados e salvar no arquivo, o programa informa ao usuário que os 
dados foram salvos com sucesso e finaliza a execução. 
// Salvar os dados dos alunos e informar o usuário 
salvarDados(alunos, num_alunos); 
printf("Dados dos alunos salvos no arquivo 'notas_alunos.txt'.\n"); 
return 0; 
} 
2.3.7. Finalização 
2.4 Sistema de Aprovação de Empréstimos
2.4.1. Análise de Cenário 
int main() { 
// Declaração de variáveis
float rendaMensal, valorEmprestimo;
char historicoCredito, estabilidadeEmprego;
int valorEntrada; 
// Limpar a tela (opcional, pode não funcionar em todos os sistemas) 
system("clear"); // Para Windows, use system("cls"); 
// Cabeçalho do programa 
printf("** Empréstimo Financeiro **\n"); 
As variáveis são declaradas para capturar a renda mensal, o valor solicitado do empréstimo, o
histórico de crédito (bom ou ruim), a estabilidade do emprego (estável ou instável), e o valor da
entrada. Em seguida, o programa solicita ao usuário as informações necessárias. 
// Leitura das informações 
printf("Digite sua renda mensal: "); 
scanf("%f", &rendaMensal); 
printf("Digite o valor do empréstimo: "); 
scanf("%f", &valorEmprestimo); 
printf("Digite seu histórico de crédito (B=Bom, R=Ruim): "); 
scanf(" %c", &historicoCredito); // Espaço antes de %c para ignorar caracteres de 
nova linha 
printf("Digite a sua estabilidade no emprego (E=Estável, I=Instável): "); 
scanf(" %c", &estabilidadeEmprego); // Espaço antes de %c para ignorar caracteres 
de nova linha 
printf("Digite o valor da entrada: "); 
scanf("%d", &valorEntrada); 
2.4.2. Criação de Variáveis e Entrada de Dados 
2.4.4. Finalização 
2.4.3. Cálculo e Condições para Aprovação 
A lógica do programa verifica se o valor do empréstimo solicitado é viável, de acordo 
com os seguintes critérios: 
O valor do empréstimo não pode exceder 30% da renda mensal. 
O histórico de crédito deve ser bom. 
A estabilidade no emprego deve ser considerada estável. 
O valor da entrada deve ser, no mínimo, 20% do valor do empréstimo. 
Se qualquer um desses critérios não for atendido, o empréstimo será negado; caso 
contrário, será aprovado. 
// Cálculo do valor máximo permitido do empréstimo 
float valorMaximoEmprestimo = rendaMensal * 0.30; 
// Verificação dos critérios para aprovação do empréstimo 
if (valorEmprestimo > valorMaximoEmprestimo) { 
printf("Empréstimo negado! O valor do empréstimo excede 30%% da renda 
mensal.\n"); 
} else if (historicoCredito == 'R') { 
printf("Empréstimo negado! Histórico de crédito ruim.\n"); 
} else if (estabilidadeEmprego == 'I') { 
printf("Empréstimo negado! Estabilidade no emprego instável.\n"); 
} else if (valorEntradaser pelo menos 20% do valor do empréstimo 
printf("Empréstimo negado! O valor da entrada deve ser pelo menos 20%% do 
valor do empréstimo.\n"); 
} else { 
printf("Parabéns! Seu empréstimo foi aprovado.\n"); 
} 
Ao final, o programa exibe uma mensagem de acordo com os resultados da análise, 
indicando se o empréstimo foi aprovado ou negado com base nos critérios. 
// Finalização do programa 
return 0; 
} 
 
Esses quatro códigos demonstram um portfólio diversificado e sólido,
abrangendo desde jogos interativos até aplicações de utilidade prática, como
classificação acadêmica e sistemas de crédito. Cada um dos projetos utiliza diferentes
estruturas de programação, como loops, condicionais e manipulação de dados,
oferecendo uma excelente demonstração das habilidades em lógica de programação
e resolução de problemas. Além disso, eles enfatizam a importância de clareza na
lógica e organização do código, tornando-o legível, funcional e fácil de manter. 
 
CONSIDERAÇÕES FINAIS 
REFERÊNCIAS BIBLIOGRAFICAS 
CORMEN, Thomas. Algoritmos – Teoria e Prática. 3.ed. Rio de Janeiro: LTC, 2022.
MENÉNDEZ, Andrés. Simplificando algoritmos. 1. ed. - Rio de Janeiro: LTC, 2023.
SILVA, Flávio Soares Corrêa D.; FINGER, Marcelo; MELO, Ana Cristina Vieira. Lógica para
computação. 2. ed. São Paulo: Cengage Learning, 2017.