(Creado por el analista de sistemas y docente Leonel Iván Saafigueroa)

---

PIEDRA, PAPEL O TIJERA

La piedra rompe a la tijera, la tijera corta al papel, el papel envuelve a la piedra. Este es un juego de niños en donde se puede ganar, perder o empatar, en esta clase vamos a recrearlo con un sencillo programa.

Este es un juego dinámico, ambos jugadores deciden al mismo tiempo una de las tres opciones, por ello las reglas del juego tendrán que adaptarse a la mecánica de nuestro programa, donde tendremos que confiar en que la computadora elige sus jugadas sin tener en cuenta las nuestras.

Veamos el código:

En esta primera versión nos concentramos para que la computadora pueda elegir entre piedra, papel o tijera.

Con esta versión podemos pensar mentalmente cuál sería nuestra jugada y reiniciar el programa para ver la respuesta y ver si ganamos, perdimos o empatamos.

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int jugada;

int main()
{
    srand(time(NULL)); // Iniciamos la semilla random con la hora.
    jugada = (rand() % 3)+1; // Genera un valor entre 1 y 3.
    switch(jugada)
    {
        case 1:
            cout << "PIEDRA." << endl;
            break;
        case 2:
            cout << "PAPEL." << endl;
            break;
        case 3:
            cout << "TIJERA." << endl;
            break;
        }
    return 0;
}

Vamos a analizar línea por línea este código en C++:

Línea 1: #include <iostream>

• Esta línea incluye la biblioteca estándar iostream, que permite leer y escribir datos desde y hacia la pantalla (nos permite utilizar funciones como cout para imprimir texto en la pantalla).

Línea 2: #include <cstdlib>

• Esta línea incluye la biblioteca cstdlib, que proporciona funciones de manipulación de memoria y generación de números aleatorios (utilizando funciones como rand() para generarlos).

Línea 3: #include <ctime>

• Esta línea incluye la biblioteca ctime, que proporciona funciones para trabajar con fechas y horas.

Línea 5: using namespace std;

• Esta línea declara que queremos usar el espacio de nombres estándar (std) en lugar de tener que escribir std:: antes de cada función o variable que utilice, por ejemplo std::cout.

Línea 7: int jugada;

• Esta línea declara una variable entera llamada jugada.
• La variable jugada será utilizada para almacenar el resultado de la tirada aleatoria.

Línea 9-26: main()

• Esta es la función principal del programa.
• La función main() es el punto de entrada del programa, donde comienza a ejecutarse.

Línea 11: srand(time(NULL));

• Esta línea inicializa la semilla aleatoria con la hora actual del sistema.
• La función time(NULL) devuelve la hora actual en segundos desde la época unix.
• La función srand() establece la semilla para generar números aleatorios.

Línea 12: jugada = (rand() % 3)+1;

• Esta línea genera un valor aleatorio entre 1 y 3 y lo asigna a la variable jugada.
• La función rand() devuelve un número entero aleatorio.
• El operador % es el módulo, que devuelve el resto de la división entre 3, y a este resultado se le suma 1.
• Por lo tanto, los valores posibles son: 1 (cuando rand() = 0), 2 (cuando rand() = 1) o 3 (cuando rand() = 2).

Línea 13-24: switch(jugada){...}

• Esta es una estructura de control de flujo switch.
• La variable jugada se utiliza como condición para determinar qué bloque de código ejecutar.
• El valor de jugada solo será uno de los valores posibles (1, 2 o 3).

Línea 16: case 1: cout << "PIEDRA." << endl;

• Esta línea imprime en la pantalla el resultado de la tirada aleatoria cuando es igual a 1.
• El texto “PIEDRA” se escribirá en la pantalla.

Línea 18 y 21: case 2: ... y case 3: ...

• Son equivalentes a la línea 16, pero para los casos en que jugada es igual a 2 o 3 respectivamente.
• Los resultados son “PAPEL” cuando jugada es igual a 2 y “TIJERA” cuando jugada es igual a 3.

Línea 17, 20 y 23: break;

Es necesario escribir esta línea para que el programa se termine correctamente.

Esta línea termina la ejecución del bloque de código dentro del switch.

Línea 25: return 0;

• Esta línea indica al compilador que el programa ha finalizado su ejecución correctamente.
• El valor de retorno (0) es un código estándar que indica que la ejecución del programa fue exitosa.
• Si el programa no tiene una instrucción return explícita, el compilador asume que el programa termina en la función principal (main()).
• En este caso, la instrucción return 0; es opcional, pero se recomienda incluirla para indicar claramente al compilador que el programa ha finalizado su ejecución.

Ahora creamos una versión en donde podamos elegir nuestra jugada:

Veamos el código:

Ahora vamos a mostrar las tres posibilidades para que el jugador pueda elegir entre 1, 2 y 3, guardando lo ingresado en la variable “jugador“, también tenemos la variable “computadora” con la jugada al azar de la computadora, ambas serán comparadas a través de varios condicionales si-entonces para ver si empatamos, perdimos o ganamos la partida.

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int jugador;
int computadora;

int main()
{
    cout << "1 - Piedra." << endl;
    cout << "2 - Papel." << endl;
    cout << "3 - Tijera." << endl;
    cout << "Elija su jugada:" << endl;
    cin >> jugador;
    srand(time(NULL)); // Iniciamos la semilla random con la hora.
    computadora = (rand() % 3)+1; // Genera un valor entre 1 y 3.
    // Mostramos la jugada de la computadora.
    switch(computadora)
    {
        case 1:
            cout << "LA COMPUTADORA ELIJE PIEDRA." << endl;
            break;
        case 2:
            cout << "LA COMPUTADORA ELIJE PAPEL." << endl;
            break;
        case 3:
            cout << "LA COMPUTADORA ELIJE TIJERA." << endl;
            break;
        }
    // Analizamos si EMPATAMOS, PERDIMOS O GANAMOS.
    if(computadora==jugador)
    {
        cout << endl << "NO HAY GANADOR." << endl;
    }
    else if(jugador==1 && computadora==2)
    {
        cout << endl << "PERDISTE." << endl;
    }
    else if(jugador==2 && computadora==3)
    {
        cout << endl << "PERDISTE." << endl;
    }
        else if(jugador==3 && computadora==1)
    {
        cout << endl << "PERDISTE." << endl;
    }
    else
    {
        cout << endl << "GANAS LA PARTIDA." << endl;
    }
return 0;
}

Podemos afirmar mirando el programa que realmente el juego es justo, la computadora elige realmente sin saber que vamos a elegir nosotros, no hay trampa.

Vamos a analizar línea por línea este código en C++:

Línea 1: #include <iostream>

• Esta línea incluye la biblioteca estándar iostream para utilizar funciones de entrada y salida.

Línea 2: #include <cstdlib>

• Esta línea incluye la biblioteca estándar cstdlib para utilizar funciones de manipulación de memoria y generación de números aleatorios.

Línea 3: #include <ctime>

• Esta línea incluye la biblioteca estándar ctime para utilizar funciones relacionadas con el tiempo.

Línea 4: using namespace std;

• Esta línea utiliza el prefijo std:: para acceder a las clases y funciones de la biblioteca estándar sin tener que utilizar el nombre completo.

Líneas 6-7: int jugador; int computadora;

• Estas líneas declaran dos variables enteras llamadas jugador y computadora.

Línea 9: int main() {

• Esta línea define la función principal del programa.

Línea 11: cout << "1 - Piedra." << endl;

• Esta línea imprime en la pantalla el texto “1 – Piedra.“.

Líneas 12-14: Estas líneas imprimen en la pantalla los textos correspondientes a las opciones del juego.

Línea 15: cin >> jugador;

• Esta línea lee desde la entrada estándar el valor de la variable jugador.

Líneas 16-17: Estas líneas generan un número aleatorio entre 1 y 3 y lo asignan a la variable computadora.

Línea 19: switch(computadora) {`

• Esta línea utiliza una estructura de control switch para evaluar el valor de computadora.

Líneas 21-29: Estas líneas imprimen en la pantalla el texto correspondiente a la opción del juego elegida por la computadora.

Líneas 32-51: Estas líneas analizan si hay un ganador, perdedor o empate, e imprimen el resultado en la pantalla.

Línea 24: return 0;

Esta línea indica que la función principal del programa ha terminado de ejecutarse.