Algoritmos Floresta Sussurrante

Prévia do material em texto

13
universidade ANHANGUERA
ENGENHARIA CIVIL
sidval galvão prestes
ROTEIRO DE AULA PRÁTICA 
ALGORÍTMOS E LÓGICA DE PROGRAMAÇÃO
São Pedro/SP
2025
SIDVAL GALVÃO pRESTES
ROTEIRO DE AULA PRÁTICA 
ALGORÍTMOS E LÓGICA DE PROGRAMAÇÃO
Roteiro de Aula Prática apresentado a Universidade Anhanguera como requisito para obtenção de média para a disciplina Algoritmos e Lógica de Programação.
São Pedro/SP
2025
SUMÁRIO
1	INTRODUÇÃO	3
2	DESENVOLVIMENTO	4
2.1	ETAPA 1	4
2.2	ETAPA 2	9
2.3	ETAPA 3	14
2.4	ETAPA 4	19
3	CONCLUSÃO	23
REFERÊNCIAS	24
	
	
INTRODUÇÃO
A lógica de programação e o uso de algoritmos são fundamentais no desenvolvimento de qualquer sistema computacional, pois permitem a criação de soluções para problemas complexos de maneira estruturada e eficiente. A prática de elaborar algoritmos consiste na definição clara de passos lógicos que, quando implementados, resultam em programas funcionais e otimizados. 
Neste trabalho, será apresentado o roteiro prático de algoritmos e lógica de programação, abordando conceitos essenciais para a construção de algoritmos que solucionam problemas de forma lógica, além da importância de uma boa organização no desenvolvimento de código. 
O foco estará em como essas práticas contribuem para a resolução de problemas de forma eficiente e sistemática, aplicáveis a diversas áreas da tecnologia da informação.
DESENVOLVIMENTO
ETAPA 1
Para a resolução desta etapa foi utilizado o compilador on line do Portugol Dev, onde foi desenvolvido o código.
Figura 1 . Portugol WebStudio
Figura 2. Ambiente de Desenvolvimento
Este algoritmo implementa um jogo de aventura simples utilizando a linguagem de programação Portugol. O jogo simula uma jornada em uma floresta misteriosa, onde o jogador deve fazer escolhas que influenciam o curso da história e a pontuação final. A seguir, será descrito o funcionamento do código e suas principais funcionalidades.
· Estrutura do Jogo
O jogo começa com a função principal início, que é o ponto de entrada do programa. Dentro dessa função, são declaradas três variáveis: opcao, pontuacao, e resposta. A variável opcao é utilizada para armazenar a escolha do jogador sobre qual caminho seguir na floresta, pontuacao armazena a pontuação acumulada durante o jogo, e resposta é usada para capturar as respostas do jogador aos desafios apresentados ao longo do jogo.
· Introdução à Aventura
O jogo começa com uma introdução narrativa, onde o jogador é descrito como um explorador corajoso que se aventura na "Floresta Sussurrante" em busca de tesouros. Essa introdução tem o objetivo de contextualizar o jogador e criar uma atmosfera de mistério e aventura.
· Escolha de Caminhos
Após a introdução, o jogador é apresentado a um menu de escolhas com três opções de caminhos:
1. O Caminho das Sombras
2. O Caminho da Luz
3. O Caminho das Criaturas
O jogador deve escolher uma dessas opções, digitando o número correspondente. A escolha do caminho determinará qual desafio o jogador enfrentará em seguida.
· Estrutura de Decisão (Escolha)
A estrutura escolha (opcao) é utilizada para determinar qual bloco de código será executado com base na escolha do jogador. Dependendo do valor de opcao, o jogo segue por um dos três caminhos:
Código 1. Algoritmo Floresta Sussurrante
programa {
  funcao inicio() {
    inteiro opcao
    inteiro pontuacao
    cadeia resposta
    // Inicializa a pontuação
    pontuacao = 0
    // Introdução da aventura
    escreva("Você é um explorador corajoso que se aventura na 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, cada um levando a uma parte desconhecida e perigosa da floresta.\n")
    escreva("Sua missão é escolher sabiamente o caminho a seguir, enfrentando desafios e tomando decisões que impactarão sua jornada e sua pontuação final.\n\n")
    
    // Menu de opções
    escreva("Escolha o caminho que deseja seguir:\n")
    escreva("1 - O Caminho das Sombras\n")
    escreva("2 - O Caminho da Luz\n")
    escreva("3 - O Caminho das Criaturas\n")
    escreva("Digite sua escolha (1, 2 ou 3): ")
    leia(opcao)
    // Estrutura de decisão para os caminhos
    escolha (opcao){
        caso 1:
            // Caminho 1: O Caminho das Sombras
            escreva("\nVocê escolheu O Caminho das Sombras.\n")
            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("De repente, você encontra uma criatura mágica guardiã do caminho. Ela exige que você responda a um enigma para deixá-lo passar.\n")
            escreva("O enigma é: 'Quem sou eu? Tenho olhos, mas não vejo. Tenho boca, mas não falo. O que sou?'\n")
            escreva("Digite sua resposta: ")
            leia(resposta)
            
            se (resposta=="caveira"){
                escreva("Você acertou! A criatura se curva e permite que você passe.\n")
                escreva("Ao continuar, você encontra um baú escondido contendo uma gema preciosa.\n")
                pontuacao = pontuacao + 100
                escreva("Você ganhou 100 pontos!\n")
            }senao{
                escreva("Resposta incorreta. A criatura não permite que você passe.\n")
                escreva("Infelizmente, você precisa voltar ao início.\n")
            }
        pare
        caso 2:
            // Caminho 2: O Caminho da Luz
            escreva("\nVocê escolheu O Caminho da Luz.\n")
            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("No meio do caminho, você encontra uma ponte quebrada sobre um rio turbulento. Você deve decidir se tentará atravessar a ponte ou procurar um desvio.\n")
            escreva("Digite 'atravessar' para tentar atravessar a ponte ou 'desvio' para procurar outro caminho: ")
            leia(resposta)
            
            se (resposta=="atravessar") {
                escreva("Você decide atravessar a ponte com cuidado...\n")
                escreva("Com sucesso, você chega ao outro lado e encontra uma fonte mágica que restaura sua saúde.\n")
                pontuacao = pontuacao + 50
                escreva("Você ganhou 50 pontos!\n")
            }senao{
                escreva("Você decide procurar um desvio, mas acaba se perdendo na floresta.\n")
                escreva("Infelizmente, você precisa voltar ao início.\n")
            }
        pare
        caso 3:
            // Caminho 3: O Caminho das Criaturas
            escreva("\nVocê escolheu O Caminho das Criaturas.\n")
            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("De repente, você se depara com uma criatura mágica adormecida bloqueando o caminho. Você deve decidir se tentará contorná-la com cuidado ou acordá-la para passar.\n")
            escreva("Digite 'contornar' para tentar passar sem acordá-la ou 'acordar' para tentar acordá-la: ")
            leia(resposta)
            
            se (resposta=="contornar") {
                escreva("Você decide contornar a criatura com cuidado...\n")
                escreva("Com sucesso, você encontra uma árvore encantada que lhe concede uma habilidade especial de camuflagem.\n")
                pontuacao = pontuacao + 75
                escreva("Você ganhou 75 pontos!\n")
            }senao{
                escreva("Você decide acordar a criatura, mas ela se enfurece e bloqueia ainda mais o caminho.\n")
                escreva("Infelizmente, você precisa voltar ao início.\n")
            }
        pare
        caso contrario:
            escreva("Opção inválida! Por favor, escolha uma opção válida (1, 2 ou 3).\n")
        pare}
    
    // Exibe a pontuação final
    escreva("\nSua pontuação final é: ", pontuacao, " pontos.\n")
    escreva("Obrigado por jogar! Até a próxima aventura.\n")
  }
}
· Caminho das Sombras: O jogador encontra uma criatura mágica que exige a resolução de um enigma. Se a resposta estiver correta (nesse caso, "caveira"), o jogador ganha 100 pontos. Caso contrário, o jogador não avança e precisa reiniciar a aventura.
· Caminho da Luz: O jogador encontra uma ponte quebrada e deve decidir entre atravessá-la ou procurar um desvio. Se o jogador escolhe atravessar e é bem-sucedido, ganha 50 pontos. Se escolhe o desvio, acaba se perdendo, e o jogo reinicia.
· Caminho das Criaturas: O jogador encontra uma criatura adormecida e deve decidir entre contorná-la ou acordá-la. Se o jogador opta por contorná-la, ganha 75 pontos. Caso escolha acordá-la, a criatura bloqueia o caminho e o jogo reinicia.
· Pontuação Final
Após o jogador ter tomado suas decisões e enfrentado os desafios, a pontuação final é exibida. A pontuação acumulada depende das escolhas feitas durante o jogo. O jogo termina com uma mensagem de agradecimento ao jogador.
· Considerações Finais
Este algoritmo é um exemplo de um jogo interativo simples, que utiliza estruturas de controle como decisões (escolha e se/senao) para permitir que o jogador influencie o curso da história. Além disso, a pontuação serve como uma forma de feedback para o jogador, incentivando a tomada de decisões estratégicas para maximizar o resultado final. O jogo poderia ser expandido com mais caminhos, desafios e opções para aumentar a complexidade e a diversão.
Imagem 3. Executando o Código
ETAPA 2
Código 2. Algoritmo Labirinto
programa {
  // Importação da biblioteca responsável por gerar os números aleatórios no programa
  inclua biblioteca Util --> u
  // Função que mostra o mapa do jogo no prompt
  funcao mostraMatriz(inteiro xJ, inteiro yJ, inteiro matriz[][]) {
    inteiro contador1, contador2
    escreva("\n---------------MAPA--------------\n")
    para(contador1 = 0; contador1 0) {
            se(matriz[yJogador][xJogador-1] != 1) {
              xJogador = xJogador - 1
            }
          }
        pare
        caso "direita":
          se(xJogador 0) {
            se(matriz[yJogador-1][xJogador] != 1) {
              yJogador = yJogador - 1
            }
          }
        pare
        caso "baixo":
          se(yJogador u importa uma biblioteca chamada Util, responsável por gerar números aleatórios, usada posteriormente no sorteio de elementos do labirinto.
Função mostraMatriz
· Esta função exibe o mapa do jogo. Recebe as coordenadas do jogador (xJ e yJ) e a matriz que representa o labirinto.
· Ela percorre toda a matriz usando dois laços para e desenha cada célula:
· Um 'x' é exibido na posição atual do jogador.
· Um '1' representa uma parede, '0' um caminho livre, '2' um tesouro, e '3' um obstáculo.
Função inicio
· Esta função contém a lógica principal do jogo. A seguir, estão os passos do que ela faz:
1. Inicialização da matriz e variáveis do jogador e tesouro:
· A matriz é uma tabela 5x5, onde os elementos são inicializados com '0', indicando caminhos livres.
· xJogador e yJogador começam em (0,0) (a posição inicial do jogador).
· xTesouro e yTesouro armazenarão as coordenadas do tesouro.
2. Geração aleatória de paredes e obstáculos:
· Para cada célula da matriz, o programa decide se será uma parede (chance de 7,5%) ou um obstáculo (10% de chance). Essas decisões são feitas usando a função sorteia da biblioteca Util, que gera números aleatórios.
3. Posição inicial garantida como caminho livre:
· A célula (0,0), onde o jogador começa, é garantida como um caminho livre.
4. Geração da posição do tesouro:
· O programa sorteia uma posição para o tesouro que esteja em uma célula livre (ou seja, não pode ser uma parede ou obstáculo).
5. Loop do jogo:
· O jogador se movimenta pelo mapa até encontrar o tesouro.
· A cada movimento, o mapa é atualizado com a posição atual do jogador.
· O jogador pode escolher se mover para "esquerda", "direita", "cima" ou "baixo", e o movimento só ocorre se o próximo passo não for uma parede ('1').
6. Tratamento de obstáculos:
· Se o jogador cair em um obstáculo (célula com valor '3'), ele é retornado à posição inicial (0,0), representando que o jogador tropeçou e precisará começar novamente.
ETAPA 3
Código 3. Algoritmo Empréstimo
#include 
int main() {
    //Definicao das variáveis do programafloat rendaMensal, valorEmprestimo;
    char historicoCredito, estabilidadeEmprego;
    int valorEntrada;
    
    //Leitura da renda mensal do cliente
    printf("Digite sua renda mensal.....................................:");
    scanf("%f", &rendaMensal);
    
    //Leitura do valor do empréstimo pedido
    printf("Digite o valor do emprestimo................................:");
    scanf("%f", &valorEmprestimo);
    
    //Leitura do histórico do cliente
    printf("Digite seu historico de credito (B=Bom, R=Ruim).............:");
    scanf(" %c", &historicoCredito); 
    
    //Leitura da estabilidade do cliente
    printf("Digite a sua estabilidade no emprego (E=Estavel, I=Instavel):");
    scanf(" %c", &estabilidadeEmprego); 
    
    //Leitura do valor de entrada do empréstimo
    printf("Digite o valor de entrada...................................:");
    scanf("%d", &valorEntrada);
    
    //Realiza o cálculo para definir se o empréstimo será aprovado ou negado
    if(valorEmprestimo 
Esta linha importa a biblioteca stdio.h, que contém funções padrão para operações de entrada e saída, como printf e scanf.
2. Função principal 
main:
c
Copiar código
int main() {
· O programa começa sua execução dentro da função main. É aqui que todo o código será executado.
3. Declaração de variáveis:
c
Copiar código
float rendaMensal, valorEmprestimo;
char historicoCredito, estabilidadeEmprego;
int valorEntrada;
· São declaradas as variáveis:
· rendaMensal e valorEmprestimo são do tipo float para armazenar valores decimais.
· historicoCredito e estabilidadeEmprego são do tipo char, usadas para armazenar um único caractere, que será usado para a análise do crédito e estabilidade do emprego.
· valorEntrada é do tipo int, utilizado para armazenar o valor de entrada do empréstimo.
4. Leitura da renda mensal:
c
Copiar código
printf("Digite sua renda mensal.....................................:");
scanf("%f", &rendaMensal);
· O printf exibe uma mensagem solicitando ao usuário que insira sua renda mensal.
· O scanf lê o valor inserido pelo usuário e armazena na variável rendaMensal. O %f indica que está sendo lido um número decimal (float).
5. Leitura do valor do empréstimo:
c
Copiar código
printf("Digite o valor do emprestimo................................:");
scanf("%f", &valorEmprestimo);
· printf exibe a solicitação para o usuário inserir o valor do empréstimo desejado.
· scanf lê o valor e armazena na variável valorEmprestimo.
6. Leitura do histórico de crédito:
c
Copiar código
printf("Digite seu historico de credito (B=Bom, R=Ruim).............:");
scanf(" %c", &historicoCredito);
O programa pede ao usuário para informar o histórico de crédito, que pode ser 'B' (Bom) ou 'R' (Ruim).
O %c no scanf lê um único caractere. O espaço antes de %c é importante para ignorar quaisquer caracteres de nova linha (enter) anteriores, garantindo que o caractere seja lido corretamente.
 7. Leitura da estabilidade no emprego:
c
Copiar código
printf("Digite a sua estabilidade no emprego (E=Estavel, I=Instavel):");
scanf(" %c", &estabilidadeEmprego);
· O programa solicita ao usuário que informe se a estabilidade no emprego é 'E' (Estável) ou 'I' (Instável).
· Assim como no caso anterior, o %c ê um único caractere, com o espaço para garantir a correta captura da entrada.
8. Leitura do valor de entrada:
c
Copiar código
printf("Digite o valor de entrada...................................:");
scanf("%d", &valorEntrada);
· O usuário insere o valor de entrada para o empréstimo.
· O %d no scanf lê um valor inteiro e o armazena na variável valorEntrada.
9. Avaliação para aprovação ou rejeição do empréstimo:
c
Copiar código
if(valorEmprestimo 
#include 
#include 
typedef struct {
    char nome[250];
    float media_disciplina1;
    float media_disciplina2;
    float media_geral;
    int classificacao;
} Aluno;
float calcularMediaGeral(float media1, float media2) {
    return (media1 + media2) / 2;
}
void ordenarAlunos(Aluno *turma, int num_alunos) {
    Aluno temp;
    for (int i = 0; ifprintf(arquivo, "Media geral da turma: %.2f\n", media_turma);
    fclose(arquivo);
    printf("Dados salvos no arquivo 'alunos.txt'.\n");
    return 0;
}
Imagem 4. Executando o Algoritmo no VS Code
Este código pode ser descrito em três macro etapas:
1. Entrada de Dados e Cálculo das Médias Individuais:
· O programa começa solicitando o número de alunos na turma. Em seguida, para cada aluno, ele coleta o nome e as notas de duas disciplinas (media_disciplina1 e media_disciplina2).
· A média geral de cada aluno é calculada usando a função calcularMediaGeral, que faz a média aritmética simples das duas notas.
2. Ordenação dos Alunos por Desempenho:
· Após coletar e calcular as médias de todos os alunos, o programa chama a função ordenarAlunos, que organiza a lista de alunos em ordem decrescente de acordo com a média geral.
· Durante essa ordenação, também é atribuída a classificação de cada aluno com base em sua posição na lista (do melhor para o pior).
3. Gravação dos Dados em um Arquivo:
· O programa abre um arquivo de texto chamado "alunos.txt" e escreve os dados de cada aluno: nome, médias das disciplinas, média geral e sua classificação.
· Além disso, calcula e grava a média geral da turma. Por fim, o arquivo é fechado e o programa informa que os dados foram salvos com sucesso.
CONCLUSÃO
A prática de algoritmos e lógica de programação desempenha um papel essencial na formação de uma base sólida para o desenvolvimento de soluções tecnológicas. Ao longo desta atividade prática, foi possível compreender a importância de aplicar uma sequência lógica de instruções e seguir metodologias de programação para resolver problemas de maneira eficiente. 
O domínio desses conceitos não apenas facilita o desenvolvimento de programas robustos, mas também aprimora o raciocínio lógico e a capacidade de lidar com situações complexas de maneira estruturada. 
Ao concluir este roteiro prático, fica evidente que a aplicação da lógica de programação é uma habilidade indispensável para qualquer profissional da área de tecnologia, sendo a base para a criação de softwares funcionais e otimizados.
REFERÊNCIAS
MANZANO, José Augusto N. G.; OLIVEIRA, Jayr Figueiredo de. Algoritmos: lógica para desenvolvimento de programação de computadores. 27. ed. São Paulo: Érica, 2010.
NOSCHANG, Luiz Fernando et al. Portugol studio: Uma ide para iniciantes em programaçao. In: Anais do XXII Workshop sobre Educação em Computação. SBC, 2014. p. 1-10.
POCIVI, Viviane Carla Batista; SANTOS JÚNIOR, William Pereira dos. Algoritmos em Portugol. 2018.
image1.png
image2.png
image3.png
image4.png
image5.jpeg
image6.jpeg