Hey, pessoal! Já imaginaram juntar a paixão pelo futebol com a lógica da programação? Pois é, hoje vamos mergulhar em exercícios resolvidos de PSeInt focados no sistema de controle de estoque (SCE) do Campeonato Brasileiro de Futebol de 1960. Sim, você não leu errado! Vamos usar a nostalgia do futebol brasileiro daquela época para aprender e aprimorar nossas habilidades em algoritmos. Preparem-se para uma viagem no tempo com muita lógica e diversão!

    O Que é PSeInt e Por Que Usá-lo?

    Antes de começarmos a resolver os exercícios, vamos relembrar o que é o PSeInt. PSeInt é um software livre, educativo e multiplataforma, ideal para iniciantes em programação. Ele utiliza uma linguagem de pseudocódigo em português, facilitando o aprendizado dos conceitos básicos de programação sem a complexidade de linguagens mais robustas. Com PSeInt, podemos criar algoritmos de forma visual e intuitiva, o que é ótimo para entender a lógica por trás dos programas.

    Usar PSeInt para resolver problemas do dia a dia, como o controle de estoque, é uma excelente maneira de praticar a lógica de programação. A clareza do pseudocódigo permite que você se concentre na estrutura do algoritmo, em vez de se preocupar com a sintaxe complexa. Além disso, o PSeInt oferece ferramentas de depuração que ajudam a identificar e corrigir erros, tornando o aprendizado ainda mais eficaz. Para quem está começando, o PSeInt é uma ferramenta indispensável para construir uma base sólida em programação.

    Por Que o Campeonato Brasileiro de 1960?

    Você deve estar se perguntando: por que o Campeonato Brasileiro de 1960? A escolha desse tema não é aleatória. Além de ser um período icônico do futebol brasileiro, ele oferece um contexto interessante para criar exercícios de controle de estoque. Imagine que você é responsável por gerenciar os materiais esportivos, uniformes e outros itens essenciais para os times daquela época. Como você faria isso de forma eficiente? É aí que entra o PSeInt, ajudando a organizar e otimizar esse processo.

    Ao contextualizar os exercícios com o Campeonato Brasileiro de 1960, tornamos o aprendizado mais divertido e relevante. Em vez de resolver problemas abstratos, você estará aplicando a lógica de programação em um cenário real, o que facilita a compreensão e a memorização dos conceitos. Além disso, essa abordagem estimula a criatividade e o pensamento crítico, incentivando você a encontrar soluções inovadoras para os desafios propostos. Então, prepare sua chuteira e vamos começar a programar!

    Exercício 1: Controle de Uniformes

    Problema: O Campeonato Brasileiro de 1960 precisa controlar o estoque de uniformes dos times. Cada time possui dois tipos de uniforme: titular e reserva. Crie um algoritmo em PSeInt que permita:

    1. Cadastrar a quantidade inicial de uniformes de cada tipo para cada time.
    2. Registrar a entrada de novos uniformes (doação, compra, etc.).
    3. Registrar a saída de uniformes (uso em jogos, vendas, etc.).
    4. Mostrar o estoque atual de cada tipo de uniforme para um time específico.

    Solução:

    Algoritmo ControleDeUniformes
    Definir times Como Vetor de Caracteres
    Definir estoqueTitular, estoqueReserva Como Matriz de Inteiro
    Definir numTimes, i, opcao, timeEscolhido, quantidade Como Inteiro
    Definir tipoUniforme Como Caracter

    // Inicialização
    numTimes <- 2 // Exemplo com 2 times
    Dimensão times[numTimes]
    Dimensão estoqueTitular[numTimes], estoqueReserva[numTimes]

    times[0] <- "Santos"
    times[1] <- "Palmeiras"

    Para i <- 0 Até numTimes-1 Faça
        estoqueTitular[i] <- 100 // Quantidade inicial de uniformes titulares
        estoqueReserva[i] <- 50  // Quantidade inicial de uniformes reservas
    FimPara

    Repetir
        Escrever "\nMenu Principal:"
        Escrever "1. Registrar Entrada de Uniformes"
        Escrever "2. Registrar Saída de Uniformes"
        Escrever "3. Mostrar Estoque Atual"
        Escrever "4. Sair"
        Ler opcao

        Escolher opcao
            Caso 1:
                Escrever "\nQual time? (0 - Santos, 1 - Palmeiras)"
                Ler timeEscolhido
                Escrever "Qual tipo de uniforme? (T - Titular, R - Reserva)"
                Ler tipoUniforme
                Escrever "Qual a quantidade a ser adicionada?"
                Ler quantidade
                Se tipoUniforme = "T" Então
                    estoqueTitular[timeEscolhido] <- estoqueTitular[timeEscolhido] + quantidade
                Senão
                    estoqueReserva[timeEscolhido] <- estoqueReserva[timeEscolhido] + quantidade
                FimSe

            Caso 2:
                Escrever "\nQual time? (0 - Santos, 1 - Palmeiras)"
                Ler timeEscolhido
                Escrever "Qual tipo de uniforme? (T - Titular, R - Reserva)"
                Ler tipoUniforme
                Escrever "Qual a quantidade a ser removida?"
                Ler quantidade
                Se tipoUniforme = "T" Então
                    estoqueTitular[timeEscolhido] <- estoqueTitular[timeEscolhido] - quantidade
                Senão
                    estoqueReserva[timeEscolhido] <- estoqueReserva[timeEscolhido] - quantidade
                FimSe

            Caso 3:
                Escrever "\nQual time? (0 - Santos, 1 - Palmeiras)"
                Ler timeEscolhido
                Escrever "Estoque de uniformes titulares: ", estoqueTitular[timeEscolhido]
                Escrever "Estoque de uniformes reservas: ", estoqueReserva[timeEscolhido]

            Caso 4:
                Escrever "Saindo..."

            De Outro Modo:
                Escrever "Opção inválida!"
        FimEscolher
    Até Que opcao = 4
FimAlgoritmo

    Explicação:

    Este algoritmo simula um sistema básico de controle de estoque de uniformes. Primeiramente, definimos as variáveis necessárias: times para armazenar os nomes dos times, estoqueTitular e estoqueReserva para controlar as quantidades de cada tipo de uniforme. Utilizamos uma matriz para organizar os estoques de cada time, facilitando o acesso e a manipulação dos dados. No início, inicializamos os estoques com valores padrão, como 100 uniformes titulares e 50 uniformes reservas para cada time, proporcionando um ponto de partida para as operações subsequentes.

    O menu principal oferece quatro opções: registrar entrada, registrar saída, mostrar estoque atual e sair. As opções de entrada e saída permitem adicionar ou remover uniformes de um time específico, atualizando os estoques de acordo com a escolha do usuário. Ao selecionar a opção de mostrar estoque, o algoritmo exibe as quantidades de uniformes titulares e reservas para o time selecionado, fornecendo uma visão clara do estado atual do estoque. A opção de sair encerra o programa, finalizando a execução do algoritmo. Este sistema, embora simples, ilustra os princípios básicos de controle de estoque e pode ser expandido para incluir mais funcionalidades e detalhes, como o registro de datas, responsáveis e motivos das movimentações.

    Exercício 2: Controle de Bolas

    Problema: O Brasileirão de 1960 precisa controlar o estoque de bolas de futebol. Crie um algoritmo em PSeInt que permita:

    1. Cadastrar a quantidade inicial de bolas.
    2. Registrar a entrada de novas bolas.
    3. Registrar a saída de bolas (uso em jogos, treinamento, etc.).
    4. Mostrar o estoque atual de bolas.
    5. Mostrar quantas bolas foram usadas em cada jogo do campeonato.

    Solução:

    Algoritmo ControleDeBolas
    Definir estoqueInicial, estoqueAtual, entradaBolas, saidaBolas, bolasPorJogo, numJogos, i Como Inteiro

    // Inicialização
    estoqueInicial <- 200 // Quantidade inicial de bolas
    estoqueAtual <- estoqueInicial
    numJogos <- 10       // Exemplo com 10 jogos
    Dimensão bolasPorJogo[numJogos]

    Para i <- 0 Até numJogos-1 Faça
        bolasPorJogo[i] <- 5 // Quantidade de bolas usadas em cada jogo
        estoqueAtual <- estoqueAtual - bolasPorJogo[i]
    FimPara

    Repetir
        Escrever "\nMenu Principal:"
        Escrever "1. Registrar Entrada de Bolas"
        Escrever "2. Registrar Saída de Bolas"
        Escrever "3. Mostrar Estoque Atual"
        Escrever "4. Mostrar Bolas Usadas por Jogo"
        Escrever "5. Sair"
        Ler opcao

        Escolher opcao
            Caso 1:
                Escrever "\nQual a quantidade de bolas a serem adicionadas?"
                Ler entradaBolas
                estoqueAtual <- estoqueAtual + entradaBolas

            Caso 2:
                Escrever "\nQual a quantidade de bolas a serem removidas?"
                Ler saidaBolas
                estoqueAtual <- estoqueAtual - saidaBolas

            Caso 3:
                Escrever "\nEstoque atual de bolas: ", estoqueAtual

            Caso 4:
                Escrever "\nBolas usadas por jogo:"
                Para i <- 0 Até numJogos-1 Faça
                    Escrever "Jogo ", i+1, ": ", bolasPorJogo[i], " bolas"
                FimPara

            Caso 5:
                Escrever "Saindo..."

            De Outro Modo:
                Escrever "Opção inválida!"
        FimEscolher
    Até Que opcao = 5
FimAlgoritmo

    Explicação:

    Neste algoritmo, o foco é o controle do estoque de bolas utilizadas no Campeonato Brasileiro de 1960. Inicialmente, definimos variáveis como estoqueInicial para registrar a quantidade inicial de bolas, estoqueAtual para rastrear o estoque atual, e bolasPorJogo para armazenar a quantidade de bolas utilizadas em cada jogo. A variável numJogos define o número de jogos no campeonato, permitindo que o algoritmo calcule o consumo total de bolas ao longo da competição.

    O menu principal oferece cinco opções: registrar entrada de bolas, registrar saída de bolas, mostrar o estoque atual, mostrar as bolas usadas por jogo e sair. As opções de entrada e saída permitem adicionar ou remover bolas do estoque, atualizando o valor de estoqueAtual. Ao selecionar a opção de mostrar estoque, o algoritmo exibe a quantidade atual de bolas disponíveis, fornecendo uma visão geral do estoque. A opção de mostrar bolas usadas por jogo itera sobre cada jogo, exibindo a quantidade de bolas utilizadas em cada partida, o que permite analisar o consumo de bolas ao longo do campeonato. A opção de sair encerra o programa, finalizando a execução do algoritmo.

    Este algoritmo é uma representação simplificada de um sistema de controle de estoque, mas ilustra os princípios básicos de rastreamento e gerenciamento de recursos em um contexto esportivo. Ele pode ser expandido para incluir mais detalhes, como o registro de datas, responsáveis e motivos das movimentações, tornando-o mais robusto e preciso.

    Exercício 3: Controle de Ingressos

    Problema: O Brasileirão de 1960 precisa controlar a venda de ingressos. Crie um algoritmo em PSeInt que permita:

    1. Cadastrar a quantidade total de ingressos disponíveis para cada jogo.
    2. Registrar a venda de ingressos para um jogo específico.
    3. Mostrar a quantidade de ingressos vendidos para um jogo específico.
    4. Mostrar a quantidade de ingressos restantes para um jogo específico.
    5. Calcular a arrecadação total de um jogo, considerando o preço do ingresso.

    Solução:

    Algoritmo ControleDeIngressos
    Definir totalIngressos, ingressosVendidos, ingressosRestantes Como Vetor de Inteiro
    Definir precoIngresso Como Real
    Definir numJogos, i, jogoEscolhido, quantidadeVendida Como Inteiro
    Definir arrecadacaoTotal Como Real

    // Inicialização
    numJogos <- 5        // Exemplo com 5 jogos
    precoIngresso <- 10.0 // Preço do ingresso
    Dimensão totalIngressos[numJogos]
    Dimensão ingressosVendidos[numJogos]
    Dimensão ingressosRestantes[numJogos]

    Para i <- 0 Até numJogos-1 Faça
        totalIngressos[i] <- 1000 // Quantidade total de ingressos por jogo
        ingressosVendidos[i] <- 0  // Inicialmente, nenhum ingresso vendido
        ingressosRestantes[i] <- totalIngressos[i]
    FimPara

    Repetir
        Escrever "\nMenu Principal:"
        Escrever "1. Registrar Venda de Ingressos"
        Escrever "2. Mostrar Ingressos Vendidos"
        Escrever "3. Mostrar Ingressos Restantes"
        Escrever "4. Calcular Arrecadação Total"
        Escrever "5. Sair"
        Ler opcao

        Escolher opcao
            Caso 1:
                Escrever "\nQual jogo? (0 a ", numJogos-1, ")"
                Ler jogoEscolhido
                Escrever "Quantos ingressos foram vendidos?"
                Ler quantidadeVendida
                Se ingressosRestantes[jogoEscolhido] >= quantidadeVendida Então
                    ingressosVendidos[jogoEscolhido] <- ingressosVendidos[jogoEscolhido] + quantidadeVendida
                    ingressosRestantes[jogoEscolhido] <- ingressosRestantes[jogoEscolhido] - quantidadeVendida
                Senão
                    Escrever "Não há ingressos suficientes disponíveis."
                FimSe

            Caso 2:
                Escrever "\nQual jogo? (0 a ", numJogos-1, ")"
                Ler jogoEscolhido
                Escrever "Ingressos vendidos: ", ingressosVendidos[jogoEscolhido]

            Caso 3:
                Escrever "\nQual jogo? (0 a ", numJogos-1, ")"
                Ler jogoEscolhido
                Escrever "Ingressos restantes: ", ingressosRestantes[jogoEscolhido]

            Caso 4:
                Escrever "\nQual jogo? (0 a ", numJogos-1, ")"
                Ler jogoEscolhido
                arrecadacaoTotal <- ingressosVendidos[jogoEscolhido] * precoIngresso
                Escrever "Arrecadação total: R$ ", arrecadacaoTotal

            Caso 5:
                Escrever "Saindo..."

            De Outro Modo:
                Escrever "Opção inválida!"
        FimEscolher
    Até Que opcao = 5
FimAlgoritmo

    Explicação:

    Este algoritmo simula o controle de vendas de ingressos para os jogos do Campeonato Brasileiro de 1960. Inicialmente, definimos variáveis como totalIngressos para armazenar a quantidade total de ingressos disponíveis para cada jogo, ingressosVendidos para registrar a quantidade de ingressos vendidos, e ingressosRestantes para rastrear a quantidade de ingressos restantes. A variável precoIngresso define o preço de cada ingresso, permitindo calcular a arrecadação total de cada jogo.

    O menu principal oferece cinco opções: registrar venda de ingressos, mostrar ingressos vendidos, mostrar ingressos restantes, calcular a arrecadação total e sair. Ao selecionar a opção de registrar venda de ingressos, o algoritmo verifica se há ingressos suficientes disponíveis antes de atualizar as variáveis ingressosVendidos e ingressosRestantes. As opções de mostrar ingressos vendidos e mostrar ingressos restantes exibem as quantidades correspondentes para um jogo específico. A opção de calcular a arrecadação total multiplica a quantidade de ingressos vendidos pelo preço do ingresso, fornecendo o valor total arrecadado com a venda de ingressos para aquele jogo. A opção de sair encerra o programa, finalizando a execução do algoritmo.

    Este algoritmo é uma representação simplificada de um sistema de controle de vendas de ingressos, mas ilustra os princípios básicos de gerenciamento de vendas e rastreamento de receitas em um contexto esportivo. Ele pode ser expandido para incluir mais detalhes, como o registro de datas, horários e tipos de ingressos, tornando-o mais robusto e preciso.

    Conclusão

    E aí, pessoal! Chegamos ao fim da nossa jornada pelo mundo do PSeInt e do Campeonato Brasileiro de 1960. Espero que tenham se divertido e aprendido bastante com os exercícios que resolvemos juntos. Lembrem-se, a prática leva à perfeição, então continuem explorando e criando seus próprios algoritmos. O PSeInt é uma ferramenta poderosa para quem está começando na programação, e com um pouco de criatividade, podemos resolver problemas de diversas áreas, até mesmo do mundo do futebol!

    Se tiverem alguma dúvida ou sugestão, deixem nos comentários. E não se esqueçam de compartilhar este artigo com seus amigos que também amam programação e futebol. Até a próxima! 😉

Lastest News