Representar la baraja de cartas en C++ Array

  2. HowTo
  3. C++ Howtos
  4. Representar la baraja de cartas en C++ …
Abdul Mateen 12 octubre 2023
C++ C++ Array
  1. La baraja de cartas
  2. Representación de tarjetas individuales en C++
  3. Representaciones de matriz de baraja de cartas en C++
Representar la baraja de cartas en C++ Array

Este tutorial presentará una representación de una baraja de cartas a través de matrices C++.

Primero, discutiremos los preliminares del mazo de cartas, seguido de posibles formas de representación de cartas en C++. Finalmente, presentaremos un ejemplo práctico para la representación de la baraja de cartas.

La baraja de cartas

Una baraja de cartas estándar tiene cuatro suites o tipos: corazón, trébol, picas y diamante. Cada suite tiene trece cartas: As, 2, 3, 4, 5, 6, 7, 8, 9, 10, Jota, Reina y Rey; por lo tanto, toda la baraja tiene 52 cartas en total.

Las cartas tienen muchos juegos; sin embargo, no vamos a entrar en detalles sobre esto. En diferentes juegos, la jota, la reina y el rey tienen el valor de 10, 11 y 12, respectivamente.

En algunos juegos, el As se puede considerar como 13 o 1, o incluso como ambos.

Representación de tarjetas individuales en C++

Debemos almacenar el tipo de tarjeta/información de suite y el número/valor de tarjeta para cada tarjeta. El valor de la tarjeta es simplemente un número que se puede almacenar en una variable entera, mientras que el tipo de tarjeta se puede codificar como tipo 0, tipo 1, tipo 2 y tipo 3.

Podemos almacenar 0 para el tipo 0 (digamos que es un tipo para los Corazones). De manera similar, podemos almacenar 1 para el tipo 1 para tal vez Tréboles y así sucesivamente para Picas y Diamantes.

Echemos un vistazo al siguiente código para la realización de este concepto:

// Representation of jack of hearts
int type = 0;
int value = 11;
// Representation of king of club
int type = 1;
int value = 13;
// Representation of three of spade
int type = 2;
int value = 3;

Esta representación puede servir para la entrega de cualquier juego de cartas. Por ejemplo, ahora podemos comparar la variable valor para comprobar qué jugador tiene la carta de mayor valor.

Si queremos comprobar el tipo de carta que tiene el jugador en cuestión, podemos comprobar la variable tipo.

Representaciones de matriz de baraja de cartas en C++

Hemos discutido la representación de una sola tarjeta. Veamos diferentes representaciones de C++ para una baraja de cartas.

Representación a través de matrices paralelas en C++

Para representar la baraja de cartas, podemos tomar dos matrices paralelas. Una matriz para almacenar el tipo de tarjeta y la otra matriz para almacenar el valor en la posición correspondiente.

Aquí está la declaración e inicialización de la matriz para estas matrices paralelas:

int type[52] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
                1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
                2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};
int value[52] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

En este código, type[i] y value[i] representan la i-ésima carta de la baraja.

Representación mediante el empleo de módulos y divisiones enteras en C++

Hay otra forma inteligente de representación, que es incluso mejor que este esquema. Podemos almacenar del 0 al 51 en una matriz de enteros.

Podemos usar la operación de división y resto de enteros para obtener el tipo de tarjeta y el valor.

Asignaremos del 0 al 12 a los primeros 13 índices. El operador de división aritmética en C++ realiza la división de enteros de forma predeterminada; por lo tanto, si dividimos los números del 0 al 12 por 13, obtendremos el 0 como un tipo de carta (es decir, un palo de corazón en nuestro caso).

Además, si tomamos el resto de cualquier número con 13, obtendremos 0 a 12. Este valor restante puede servir como el valor real de la tarjeta.

Por lo tanto, asignaremos del 13 al 25 a los siguientes 13 índices y así sucesivamente para las tarjetas restantes.

Nuevamente, si hacemos una división entera de estas cartas con 13, obtendremos un valor de 1 (es decir, un tipo de carta para los clubes en nuestro caso). Nuevamente, si tomamos el resto con 13, obtendremos 0 a 12, que es el valor de la tarjeta.

Echemos un vistazo a un código de ejemplo que resume esta idea:

int card[52] = {0, 1,  2,  3,  4,  5,  6,  7,     8,
                9, 10, 11, 12, 13, 14, 15, 16..., 51};
int type = card[i] / 13;
int value = card[i] % 13;

En esta representación, la complejidad del espacio es mucho mejor (es decir, no tenemos que usar dos arreglos paralelos).

En la representación anterior, si queríamos intercambiar elementos en una matriz, teníamos que intercambiar elementos correspondientes en la segunda matriz para mantener el tipo y el valor consistentes en las posiciones correspondientes. En esta segunda representación, podemos barajar sin preocuparnos por eso.

La razón es que solo un número representa tanto el tipo como el valor de la tarjeta.

El uso de números como 10 y 11 reducirá la legibilidad del código. Por lo tanto, para que el código sea más legible, podemos definir algunas constantes:

#define JACK 10
#define QUEEN 11
#define KING 12
#define ACE 1
#define HEART 0
#define DIAMOND 1
#define CLUB 2
#define SPADE 3

Ahora, podemos hacer una comparación como:

type = card[i] / 13;
value = card[i] % 13;
... if (type == CLUB)... if (value == JACK)...

Por último, podemos definir una matriz de cadenas para imprimir la tarjeta:

string type_name[] = {"Heart", "Diamond", "Club", "Spade"};
string value_name[]{"Ace", "Two", ..., "Jack", "Queen", "King"};
... cout << value_name[value] << "of" << type_name[type] << '\n';

La salida será así:

Three of Spade
Jack of Diamond
Queen of Diamond
...

Implementación completa de C++

Ahora, las representaciones de una baraja de cartas en una matriz de C++ deben ser claras. Sin embargo, para tener una vista cognitiva de la representación, combinemos todos los fragmentos de código anteriores en un solo código listo para compilar:

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

void Shuffle(int* Deck) {
  srand(time(NULL));
  int shufflePosition1, shufflePosition2, temp;
  int shuffleCount = 100;
  for (int i = 0; i < shuffleCount; i++) {
    shufflePosition1 = rand() % 52;
    shufflePosition2 = rand() % 52;
    // swap cards at the shuffle positions
    temp = Deck[shufflePosition1];
    Deck[shufflePosition1] = Deck[shufflePosition2];
    Deck[shufflePosition2] = temp;
  }
}

void ShowFirstTenCards(int* Deck, string* TypeName, string* ValueName) {
  int valueNamePosition;
  int typeNamePosition;
  for (int t = 0; t <= 10; t++) {
    valueNamePosition = Deck[t] % 13;
    typeNamePosition = Deck[t] / 13;
    cout << "Position " << t << ": ";
    cout << ValueName[valueNamePosition] << " of ";
    cout << TypeName[typeNamePosition] << endl;
  }
}

int main() {
  int Deck[52];
  for (int itr = 0; itr <= 51; itr++) {
    Deck[itr] = itr;
  }
  string TypeName[] = {"Heart", "Diamond", "Club", "Spade"};
  string ValueName[]{"Ace",   "Two",  "Three", "Four", "Five",  "six", "Seven",
                     "Eight", "Nine", "Ten",   "Jack", "Queen", "King"};
  cout << "Top 10 cards before shuffle:" << endl;
  ShowFirstTenCards(Deck, TypeName, ValueName);
  Shuffle(Deck);
  cout << "\nTop 10 cards After shuffle:" << endl;
  ShowFirstTenCards(Deck, TypeName, ValueName);

  return 0;
}

El ejemplo de código anterior es una implementación sencilla para representar una baraja de cartas y realizar operaciones de barajado. Antes de discutir los detalles, veamos el resultado.

Producción :

Top 10 cards before shuffle:
Position 0: Ace of Heart
Position 1: Two of Heart
Position 2: Three of Heart
Position 3: Four of Heart
Position 4: Five of Heart
Position 5: six of Heart
Position 6: Seven of Heart
Position 7: Eight of Heart
Position 8: Nine of Heart
Position 9: Ten of Heart
Position 10: Jack of Heart

Top 10 cards After shuffle:
Position 0: Queen of Diamond
Position 1: Eight of Spade
Position 2: Five of Heart
Position 3: King of Diamond
Position 4: Nine of Heart
Position 5: Eight of Heart
Position 6: Seven of Heart
Position 7: Seven of Diamond
Position 8: six of Spade
Position 9: Ace of Club
Position 10: Two of Heart

El programa anterior tiene tres segmentos de código principales:

  1. El código del controlador (principal())
  2. La función MostrarPrimerasDiezCartas()
  3. La función Aleatorio()

Comencemos discutiendo los segmentos de código de arriba a abajo. El código del controlador principal crea tres matrices:

  1. Array Mazo: Para almacenar la información de la suite de los naipes y sus valores nominales según el método comentado en el apartado anterior.
  2. TypeName: Para almacenar los nombres de las cuatro suites disponibles.
  3. ValueName: para almacenar nombres en inglés para los valores nominales para mostrar la salida de manera más decente.

Después de las declaraciones importantes, el código del controlador pasó las tres matrices como argumento al método ShowFirstTenCards(). Luego, este método utiliza la estrategia de conversión de valor y palo para mostrar las primeras diez cartas de la baraja.

Después de eso, la función del controlador llama a la función Shuffle() con la matriz Deck como argumento. Esta función Shuffle() selecciona aleatoriamente dos posiciones del rango [0-51] e intercambia contenido en esas posiciones.

Repite el mismo proceso cien veces para asegurar un buen barajado.

Además, la función shuffle() utiliza la marca de tiempo UNIX actual como valor inicial (en la función srand()) para la función rand() para garantizar que la reproducción aleatoria siga siendo única en diferentes llamadas.

Si no pasamos esta marca de tiempo como semilla a la función rand(), entonces rand() siempre generará la misma secuencia para la posición aleatoria, lo cual no es deseable para estos juegos probabilísticos. Puede encontrar más información sobre la función rand() y su semilla aquí.

Artículo relacionado - C++ Array