c++ - tiene - cuantos reyes hay en una baraja
Generando una baraja de cartas (12)
Estoy tratando de hacer un simple programa de blackjack. Lamentablemente, estoy teniendo problemas desde el principio al generar una baraja de cartas.
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<char> deck;
char suit[] = {''h'',''d'',''c'',''s''};
char card[] = {''2'',''3'',''4'',''5'',''6'',''7'',''8'',''9'',''10'',''J'',''Q'',''K'',''A''};
for (int j=0; j<13; j++) {
for (int i=0; i<4; i++) {
deck.push_back(card[j] suit[i]);
}
}
return 0;
}
Sé que mi problema comienza cuando intento asignar el valor ''10'' a un char. Obviamente no pude hacer esto para compilar, pero estoy seguro de que cuando intento asignar los valores de la tarjeta al mazo vectorial, también obtendré un error ya que utilicé el tipo de variable ''char''. Saber qué tipo de tipo de variable usar parece matarme. Además, would ''deck.push_back (tarjeta [j] suit [i]);'' ser el código correcto para combinar la carta y el palo, o tienes que poner algo entre la carta [j] y el palo [i]? Agradecería que alguno de ustedes pudiera llevarme en la dirección correcta. También como una pequeña nota al margen, esto es parte de una tarea de tarea así que por favor no me den solo bloques enteros de código. Gracias por tu ayuda.
Creo que lo que buscas usar es una enumeración. Hará su código más claro y resolverá su problema.
enum SUIT { HEART, CLUB, DIAMOND, SPADE };
enum VALUE { ONE, TWO, THREE, ..., TEN, JACK, QUEEN, KING};
¿Has intentado reemplazar J por 11, Q con 12 y K con 13? Entonces podría usar int egers en lugar de caracteres. Reemplace 11-13 con la letra apropiada más adelante.
Bueno, antes que nada, el mazo [0] es un char, pero lo intentas, meter "2h" en él. (por el momento, ignoraremos que la forma en que lo está haciendo está mal).
Básicamente, necesitarás hacer que deck sea un vector<std::string> . Haga que la tarjeta sea una matriz de const char * sy convierta los elementos en una cadena.
luego usa:
deck.push_back(std::string(card[j]) + suit[i]);
La forma en que lo modelas realmente depende de lo que estás tratando de hacer.
¿Estás creando un juego real, y las estructuras de datos solo necesitan soportar el juego?
Si es así, crearía una clase de tarjeta, con un campo de enumeración para el palo y un tipo numérico (con los valores 1 - 13) para el valor nominal.
Por otro lado, si está creando una aplicación de análisis o un reproductor AI, entonces el modelo podría ser un poco diferente.
Hace algunos años, escribí un simulador para calcular las probabilidades en varios escenarios de Texas Holdem, y quería que los números se redujeran REALMENTE rápidamente. Comencé con un modelo muy sencillo (clase de tarjeta, enum de traje, etc.) pero después de una gran cantidad de perfiles y optimización, terminé con una representación bit a bit.
Cada carta tenía un valor de dieciséis bits, con los trece bits de orden superior que representaban el valor nominal, los dos bits de orden inferior que representaban el palo y con el bit [2] como bandera especial que indicaba un as (utilizado solo en los casos en que ace puede aparecer en un A2345 directo).
Aquí están algunos ejemplos:
0000000000001001 <---- Two of hearts
0100000000000011 <---- King of spades
1000000000000110 <---- Ace of diamonds
^^^^^^^^^^^^^ ("face-value" bits)
^ ("low-ace" flag)
^^ ("suit" bits)
Puedes imaginar cómo, con un diseño como este, se ilumina rápido para buscar pares, tríos y escaleras (las descargas son un poco más complicadas).
No abordaré todas las operaciones en particular, pero basta con decir que este tipo de modelo admite millones de operaciones por segundo ...
Por supuesto, tenga en cuenta que, en realidad, no defiendo que use un diseño como este en una implementación sencilla del juego. La única razón por la que terminé con este diseño es porque necesitaba realizar simulaciones estadísticas masivas.
Así que piense cuidadosamente sobre cómo quiere modelar:
- Cada tarjeta
- La mano de un jugador
- Toda la baraja
- El estado de la mesa ... incluyendo todas las manos de los jugadores (incluidos los jugadores que han dividido su mano inicial), tal vez un zapato de seis mazos, la pila de descartes, etc.
El modelo de aplicación general y los objetivos de la aplicación en general determinarán, en gran medida, los tipos de estructuras de datos que serán más apropiados.
¡¡¡Que te diviertas!!!
Use ''T'' en lugar de 10.
Puede que esto no compile, pero este es el enfoque que usaría (y habría usado). Vas a querer utilizar ints para representar tus cartas, pero puedes abstraerlo fácilmente en una clase. Que voy a escribir para ti.
class Card
{
public:
enum ESuit
{
kSuit_Heart,
kSuit_Club,
kSuit_Diamond,
kSuit_Spade,
kSuit_Count
};
enum ERank
{
kRank_Ace,
kRank_Two,
kRank_Three,
kRank_Four,
kRank_Five,
kRank_Six,
kRank_Seven,
kRank_Eight,
kRank_Nine,
kRank_Ten,
kRank_Jack,
kRank_Queen,
kRank_King,
kRank_Count
};
static int const skNumCards = kSuit_Count * kRank_Count;
Card( int cardIndex )
: mSuit( static_cast<ESuit>( cardIndex / kRank_Count ) )
, mRank( static_cast<ERank>( cardIndex % kRank_Count ) )
{}
ESuit GetSuit() const { return mSuit );
ERank GetRank() const { return mRank );
private:
ESuit mSuit;
ERank mRank;
}
Ahora es muy fácil de agregar a esta clase para obtener todo lo que quieras de ella. Generar la lista es tan simple como a continuación.
rstl::vector<Card> mCards;
mCards.reserve( Card::skNumCards );
for ( int cardValue = 0; cardValue < Card::skNumCards; ++cardValue )
{
mCards.push_back( Card( cardValue ) );
}
¿Necesita barajar?
#include <algorithm>
std::random_shuffle( mCards.begin(), mCards.end() );
¿Qué tal ver cuál es el valor de la primera tarjeta?
if ( mCards[0].GetSuit() == Card::kRank_Club && mCards[0].GetRank() == Card::kRank_Ace )
{
std::cout << "ACE OF CLUBS!" << std::endl;
}
No recopilé nada de esto, pero debería estar cerca.
Como esto es tarea para C ++, voy a adivinar que se espera que uses clases. De lo contrario, use las enumeraciones, y si esta fuera C use una estructura o algo.
Y para algunos juegos, aparte del valor de los puntos, querrás almacenar algún tipo de rango para la carta, que dependería del modo de juego actual.
No he hecho la C simple para siempre, pero me refiero a algo como esto:
typedef struct struct_card {
unsigned short int suit:2;
unsigned short int card:4;
// unsigned short int valu:4;
} card;
int main() {
card a_card;
card std_deck[52];
const unsigned short int rummy_value[13] = {1,2,3,4,5,6,7,8,9,10,10,10,10};
const char *std_card_name[13] = {"Ace","Two","Three","Four","Five","Six",
"Seven","Eight","Nine","Ten","Jack","Queen","King"};
const char *std_suit_name[4] = {"Spades","Clubs","Hearts","Diamonds"};
int j, k, i=0;
for(j=0; j<4; j++){
for(k=0; k<13; k++){
a_card.suit=j; a_card.card=k;
std_deck[i++] = a_card;
}
}
//check our work
printf("In a game of rummy:/n");
for(i=0;i<52;i++){
printf(" %-5s of %-8s is worth %2d points./n",
std_card_name[std_deck[i].card],
std_suit_name[std_deck[i].suit],
rummy_value[std_deck[i].card]);
}
//a different kind of game.
enum round_mode {SHEILD_TRUMP, FLOWER_TRUMP, BELL_TRUMP, ACORN_TRUMP, BOCK, GEISS} mode;
const card jass_deck[36]={
{0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},
{1,1},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},
{2,2},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},
{3,3},{3,1},{3,2},{3,3},{3,4},{3,5},{3,6},{3,7},{3,8},
};
#define JASS_V {11,0,0,0,0,10,2,3,4}
const unsigned short int jass_value[9] = JASS_V;
#define JASS_TRUMP_V {11,0,0,0,14,10,20,3,4}
const unsigned short int jass_trump_value[9] = JASS_TRUMP_V;
#define JASS_BOCK_V {11,0,0,8,0,10,2,3,4}
const unsigned short int jass_bock_value[9] = JASS_BOCK_V;
#define JASS_GEISS_V {0,11,0,8,0,10,2,3,4}
const unsigned short int jass_geiss_value[9] = JASS_GEISS_V;
const char *jass_card_name[9] = {"Ace","Six","Seven","Eight","Nine","Banner",
"Under","Ober","King"};
const char *jass_suit_name[4] = {"Sheilds","Flowers","Bells","Acorns"};
const unsigned short int jass_all_value[6][4][9] = {
{ JASS_TRUMP_V, JASS_V, JASS_V, JASS_V },
{ JASS_V, JASS_TRUMP_V, JASS_V, JASS_V },
{ JASS_V, JASS_V, JASS_TRUMP_V, JASS_V },
{ JASS_V, JASS_V, JASS_V, JASS_TRUMP_V },
{ JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V },
{ JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V }
};
//check our work 2: work goes on summer vacation
printf("In a game of jass with trump (Sheilds | Flowers | Bells | Acorns) | Bock | Geiss/n");
for(i=0;i<36;i++){
printf(" %-6s of %-7s is worth %8d%10d%8d%9d%8d%8d/n",
jass_card_name[jass_deck[i].card],
jass_suit_name[jass_deck[i].suit],
jass_all_value[SHEILD_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[FLOWER_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[BELL_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[ACORN_TRUMP][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[BOCK][jass_deck[i].suit][jass_deck[i].card],
jass_all_value[GEISS][jass_deck[i].suit][jass_deck[i].card]);
}
return 0;
}
La salida se ve así:
In a game of rummy:
Ace of Spades is worth 1 points.
Two of Spades is worth 2 points.
Three of Spades is worth 3 points.
Four of Spades is worth 4 points.
Five of Spades is worth 5 points.
...
Nine of Diamonds is worth 9 points.
Ten of Diamonds is worth 10 points.
Jack of Diamonds is worth 10 points.
Queen of Diamonds is worth 10 points.
King of Diamonds is worth 10 points.
In a game of jass with trump (Sheilds | Flowers | Bells | Acorns) | Bock | Geiss
Ace of Sheilds is worth 11 11 11 11 11 0
Six of Sheilds is worth 0 0 0 0 0 11
Seven of Sheilds is worth 0 0 0 0 0 0
Eight of Sheilds is worth 0 0 0 0 8 8
Nine of Sheilds is worth 14 0 0 0 0 0
Banner of Sheilds is worth 10 10 10 10 10 10
...
Under of Acorns is worth 2 2 2 20 2 2
Ober of Acorns is worth 3 3 3 3 3 3
King of Acorns is worth 4 4 4 4 4 4
Blackjack es aburrido. Este código se compila.
Cuando creé mi clase de baraja de cartas C ++ , me encontré con algunos problemas propios. Primero, intenté convertir mi baraja de cartas PHP en C ++, con un mínimo de suerte. Decidí sentarme y simplemente ponerlo en papel. Decidí ir con una configuración orientada a objetos, principalmente porque creo que es la más fácil de usar para la expansión. Utilizo los objetos Card y Deck , así que, por ejemplo, si quieres poner 10 barajas en el Shoe de tu juego de blackjack, puedes crear 10 mazos, lo que sería bastante simple, porque decidí que todo fuera autosuficiente. De hecho, es tan independiente, para crear su zapato el código sería:
#include "AnubisCards.cpp"
int main() {
Deck *shoe = new Deck(10);
}
Pero eso fue por simplicidad, no exactamente necesario en juegos más pequeños donde solo necesitas un mazo.
DE TODOS MODOS, Cómo generé el mazo creando una matriz de 52 objetos de Carta. Las cubiertas son bastante fáciles, porque sabes que tienes 4 Trajes y 13 Cartas en cada palo , también sabes que tienes 2,3,4,5,6,7,8,9,10, Jack, Reina, Rey, As en cada palo . Esos nunca cambiarán. Así que usé dos bucles, uno para el traje y el otro para el valor .
Fue algo como esto:
for(int suit = 1; suit <= 4; suit++){
for(int card = 1; card <= 13; card++){
// Add card to array
}
}
Ahora, notarás que en cada uno de esos bucles, utilizo un valor entero. La razón es simple, las tarjetas son números. 4 palos 13 valores. Incluso el valor numérico en el juego de Blackjack. Valor facial, hasta que toques Face cards, que son valores numéricos 10 hasta que toques Ace, que es el valor numérico 1 u 11. Todo es números. Entonces puede usar esos números para no solo asignar el valor de la tarjeta, sino el palo de la tarjeta, y el número en la secuencia numérica.
Una idea sería almacenar un mapa en la clase de Tarjeta, con los nombres de Caracteres o Cadenas de las tarjetas, con 1,2,3 ... siendo los índices de cada uno.
Como lo mencionaron otros, puede usar ''T'' para diez, J, Q y K para las figuras. En cuanto a push_back ... dado que deck es un vector de caracteres, puedes pasar solo un carácter a push_back como argumento. Pasar el valor de la tarjeta (1 ... 9, T, J, Q, K) y su suite no funciona.
Personalmente crearía una pequeña estructura, para representar una Tarjeta, con una propiedad de Valor y Suite. Entonces, puedes hacer que tu mazo sea un vector de cartas.
Editado: fijación de la última palabra desde el vector (menor que) La tarjeta (mayor que) se procesó como vector (nada).
Como se trata de un programa de blackjack, agregará y comparará el valor de las cartas.
Siendo ese el caso, puedes ahorrarte un poco de programación y dolor adicionales dando a las cartas valores int (1-13) en lugar de valores de char .
Intenta crear una clase de Tarjeta con palo y carta como miembro y configúrala como un tipo de vector. Me gusta
public class Card {
public:
Card(char suit, char card);
char suit, card;
};
int main() {
vector<Card> deck;
char suit[] = {''h'',''d'',''c'',''s''};
char card[] = {''2'',''3'',''4'',''5'',''6'',''7'',''8'',''9'',''T'',''J'',''Q'',''K'',''A''};
for (int j=0; j<13; j++) {
for (int i=0; i<4; i++) {
deck.push_back(new Card(card[j],suit[i]));
}
}
return 0;
}
también el uso de enumeraciones en lugar de caracteres en el palo y la tarjeta lo aclararía.
Me gustaría ir con la sugerencia de Ross de usar números enteros. La mayoría de los juegos de cartas incluirán algunos bits de matemática, por lo que es una mejor representación.
Convierta a ''A'' o ''ACE'', etc. en la salida.