es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo puedo obtener múltiples variables aleatorias de múltiples arreglos?

Soy un traductor de español que traduce documentos de TI. Traduzca lo siguiente al español. No traduzca el código ni la salida en markdown

Soy muy nuevo en c++ y realmente, en programación en general. Para aprender a usar el lenguaje, estoy tratando de crear un juego muy simple de blackjack.

Actualmente tengo el siguiente código, que define lo que es una carta y agrega las variables necesarias para una antes de presentar algunas matrices que definen las posibilidades para esas variables.


#include <iostream> #include <ctime> #include <stdio.h> #include <string> using std::string; using std::cout; using std::cin; using std::endl; struct DefineCard { char cardSuit; int cardFace; int cardValue; int cardStatus; } Deck [53]; int main() { string cardSuits [4] = { "clubs", "spades", "hearts", "diamonds" }; string cardFaces [13] = { "ace", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "jack", "queen", "king" }; string cardStatus [3] = { "in play", "in deck", "discarded" }; int cardValue [13] = {11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10}; }

Desde este código, suponiendo que lo tengo correcto, ¿cómo dibujaría una carta al azar que contenga todas estas variables al azar y luego asegurarse de que la misma carta no se dibuje dos veces?

Gracias por toda la ayuda, y disculpe cualquier malentendido flagrante de mi parte, soy muy nuevo en esto 🙂

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Para dibujar una carta al azar que contenga todas estas variables de forma aleatoria y asegurarse de que la misma carta no se dibuje dos veces, se puede crear una función que genere un número aleatorio dentro del rango de cartas disponibles en el mazo (de 0 a 51) y compruebe si esa carta ya ha sido dibujada anteriormente.

    Una forma de implementar esto es agregar una nueva variable a la estructura DefineCard llamada “cardDrawn”, que se inicializa en falso para todas las cartas del mazo. Luego, se puede escribir una función que genere un número aleatorio entre 0 y 51 (inclusive) y verifique si la carta correspondiente ya ha sido dibujada. Si la carta no ha sido dibujada, se marca como “cardDrawn = true” y se devuelve la carta. Si la carta ya ha sido dibujada, se genera un nuevo número aleatorio y se repite el proceso hasta que se encuentre una carta no utilizada.

    Aquí hay un código de ejemplo que implementa esta lógica:

    “`c ++
    #include
    #include
    #include <stdio.h>
    #include
    #include

    using namespace std;

    struct DefineCard {

    char cardSuit;
    int cardFace;
    int cardValue;
    int cardStatus;
    bool cardDrawn;
    

    } Mazo[52];

    void inicializarMazo() {
    string cardSuits[4] = { “treboles”, “espadas”, “corazones”, “diamantes” };
    string cardFaces[13] = { “as”, “dos”, “tres”, “cuatro”, “cinco”,
    “seis”, “siete”, “ocho”, “nueve”, “diez”, “jota”, “reina”, “rey” };
    string cardStatus[3] = { “en juego”, “en mazo”, “descartada” };
    int cardValue[13] = { 11, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10, 10 };

    int cardIndex = 0;
    for (int suit = 0; suit < 4; suit++) {
        for (int face = 0; face < 13; face++) {
            Mazo[cardIndex].cardSuit = cardSuits[suit][0];
            Mazo[cardIndex].cardFace = face;
            Mazo[cardIndex].cardValue = cardValue[face];
            Mazo[cardIndex].cardStatus = 1;
            Mazo[cardIndex].cardDrawn = false;
            cardIndex++;
        }
    }
    

    }

    DefineCard dibujarCartaAleatoria() {
    int cardIndex;
    do {
    cardIndex = rand() % 52;
    } while (Mazo[cardIndex].cardDrawn);

    Mazo[cardIndex].cardDrawn = true;
    
    return Mazo[cardIndex];
    

    }

    int main() {
    srand(time(NULL));
    inicializarMazo();

    DefineCard randomCard1 = dibujarCartaAleatoria();
    DefineCard randomCard2 = dibujarCartaAleatoria();
    
    cout << "La primera carta aleatoria es " << cardFaces[randomCard1.cardFace] << " de " << randomCard1.cardSuit << endl;
    cout << "La segunda carta aleatoria es " << cardFaces[randomCard2.cardFace] << " de " << randomCard2.cardSuit << endl;
    
    return 0;
    

    }
    “`

    En este ejemplo, la función inicializarMazo() configura el mazo con todas las cartas e inicializa la variable “cardDrawn” en falso para cada carta. La función dibujarCartaAleatoria() genera un número aleatorio entre 0 y 51 (inclusive) y verifica si la carta correspondiente ya ha sido dibujada mediante la comprobación de la variable “cardDrawn”. Si la carta no ha sido dibujada, se marca como “cardDrawn = true” y se devuelve la carta. Si la carta ya ha sido dibujada, se genera un nuevo número aleatorio y se repite el proceso hasta que se encuentre una carta no utilizada.

    En la función principal, llamamos a inicializarMazo() para configurar el mazo y luego llamamos a dibujarCartaAleatoria() dos veces para dibujar dos cartas aleatorias del mazo. Imprimimos la cara y el palo de cada carta para verificar que sean diferentes y aleatorias.

    Tenga en cuenta que esta es solo una forma de implementar el dibujo de cartas aleatorias de un mazo: hay muchas otras posibles aproximaciones dependiendo de sus requisitos y limitaciones específicas.</stdio.h>

Comments are closed.