Este artigo explora o desenvolvimento de um jogo clássico de adivinhação de números. O objetivo é criar um programa que interage com o usuário para adivinhar um número secreto, fornecendo feedback adequado e gerenciando o número de tentativas.

Regras do Jogo

A mecânica do jogo é a seguinte:

• Um número inteiro positivo, dentro do intervalo de 1 a 100, é definido (ou fornecido como parte da entrada inicial).
• O jogador deve tentar adivinhar este número.
• Após cada tentativa, o programa deve informar se o número secreto é "Too big" (maior que o palpite) ou "Too small" (menor que o palpite).
• O jogo é concluído quando o jogador acerta o número secreto ou quando o limite máximo de tentativas é atingido.
• Caso o jogador insira um palpite negativo, o jogo é encerrado imediatamente, exibindo "Game Over".

Mensagens de Feedback

Mensagens específicas são exibidas com base na quantidade de tentativas realizadas:

• "Bingo!": Se o número for adivinhado na primeira tentativa.
• "Lucky You!": Se o número for adivinhado em até 3 tentativas (incluindo a primeira).
• "Good Guess!": Se o número for adivinhado em mais de 3 tentativas, mas dentro do limite máximo de N tentativas.
• "Game Over": Exibido se o número não for adivinhado após N tentativsa ou se um palpite negativo for inserido em qualquer momento.

Formato de Entrada

A entrada para o programa é estruturada da seguinte forma:

• Primeira linha: Contém dois inteiros positivos. O primeiro representa o número secreto a ser adivinhado (entre 1 e 100), e o segundo é o número máximo de tentativas permitidas (N).
• Linhas subsequenets: Cada linha consiste em um palpite do usuário. As entradas continuam até que o número secreto seja adivinhado, o limite de tentativas seja alcançado, ou um palpite negativo seja inserido.

Formato de Saída

A saída do programa consiste em uma mensagem por palpite, que pode ser "Too big", "Too small", "Bingo!", "Lucky You!", "Good Guess!" ou "Game Over". A saída cessa assim que o jogo é finalizado.

Exemplo de Entrada

58 4
70
50
56
58
60
-2

Exemplo de Saída

Too big
Too small
Too small
Good Guess!

Solução em C++

Apresentamos abaixo uma implementação em C++ que encapsula a lógica do jogo de adivinhação. O código lida com a leitura das entradas, compara os palpites com o número secreto, rastreia o número de tentativas e emite as mensagens apropriadas de acordo com as regras estabelecidas.

#include <iostream> // Inclui a biblioteca para operações de entrada/saída (std::cin, std::cout)

int main() {
    int numeroSecreto;      // O valor numérico a ser adivinhado pelo jogador
    int maxTentativas;      // O limite superior de tentativas permitidas no jogo

    // Lê o número secreto e o máximo de tentativas da entrada padrão
    std::cin >> numeroSecreto >> maxTentativas;

    int tentativasFeitas = 0;      // Contador para o número de tentativas já realizadas
    bool numeroAdivinhado = false; // Sinalizador que indica se o número secreto foi encontrado

    // Loop principal do jogo, executando por um número limitado de vezes (maxTentativas)
    for (int i = 0; i < maxTentativas; ++i) {
        int palpiteDoUsuario; // Variável para armazenar o palpite atual do jogador
        std::cin >> palpiteDoUsuario;

        // Verifica se o palpite é um número negativo, o que indica o fim imediato do jogo
        if (palpiteDoUsuario < 0) {
            break; // Sai do loop
        }

        tentativasFeitas++; // Incrementa o contador de tentativas para cada palpite válido

        // Avalia o palpite do usuário em relação ao número secreto
        if (palpiteDoUsuario == numeroSecreto) {
            numeroAdivinhado = true; // Marca que o número foi adivinhado com sucesso

            // Imprime a mensagem de sucesso baseada na quantidade de tentativas
            if (tentativasFeitas == 1) {
                std::cout << "Bingo!" << std::endl;
            } else if (tentativasFeitas <= 3) { // Entre 2 e 3 tentativas
                std::cout << "Lucky You!" << std::endl;
            } else { // Mais de 3 tentativas, mas dentro do limite
                std::cout << "Good Guess!" << std::endl;
            }
            break; // Encerra o jogo após um palpite correto
        } else if (palpiteDoUsuario > numeroSecreto) {
            std::cout << "Too big" << std::endl; // O palpite é maior que o número secreto
        } else { // palpiteDoUsuario < numeroSecreto
            std::cout << "Too small" << std::endl; // O palpite é menor que o número secreto
        }
    }

    // Após o loop, se o número não foi adivinhado (seja por esgotar tentativas ou palpite negativo)
    if (!numeroAdivinhado) {
        std::cout << "Game Over" << std::endl; // Imprime a mensagem de fim de jogo
    }

    return 0; // Retorna 0 para indicar que o programa foi executado com sucesso
}