質問

単純なブラックジャックプログラムを作成しようとしています。残念ながら、すぐにカードのデッキを作成するのに問題があります。

#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;
}

私の問題は、値「10」をcharに割り当てようとすることから始まることを知っています。明らかにこれをコンパイルすることはできませんでしたが、ベクトルデッキにカード値を割り当てようとすると、変数型 'char'を使用したため、エラーも発生します。使用する変数の種類を知ることは私を殺しているようです。また、「deck.push_back(card [j] suit [i]);」カードとスーツを組み合わせる正しいコードであるか、card [j]とsuit [i]の間に何かを挿入する必要がありますか?あなたのいずれかが私を正しい方向に導くことができれば、私はそれを感謝します。また、ちょっとした補足として、これは宿題の一部ですので、単にコードのブロック全体を教えてはいけません。ご協力ありがとうございます。

役に立ちましたか?

解決

スーツとカードをメンバーとしてカードのクラスを作成し、ベクターのタイプとして設定してみてください。いいね

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;
}

また、スーツとカードで文字の代わりに列挙型を使用すると、明確になります。

他のヒント

使用しようとしているのは列挙型だと思います。コードが明確になり、問題が解決します。

enum SUIT { HEART, CLUB, DIAMOND, SPADE }; 
enum VALUE { ONE, TWO, THREE, ..., TEN, JACK, QUEEN, KING};

モデル化の方法は、実際に何をしようとしているかによって異なります。

実際のゲームを作成していますか?データ構造はゲームプレイをサポートする必要があるだけですか?

もしそうなら、スーツの列挙型フィールドと額面の数値型(1〜13の値)を持つカードクラスを作成します。

一方、分析アプリケーションまたはAIプレーヤーを構築している場合、モデルは少し異なる可能性があります。

数年前、テキサスホールデムのさまざまなシナリオで確率を計算するシミュレータを作成しました。最初は非常に単純なモデル(カードクラス、スーツ列挙など)で始めましたが、プロファイリングと最適化をたくさん行った後、ビット単位の表現になりました。

各カードは16ビット値で、13の上位ビットが額面を表し、2つの下位ビットがスーツを表し、bit [2]がエースを示す特別なフラグとして使用されました( A2345ストレートにエースが表示される場合があります)。

例をいくつか示します。

0000000000001001  <----  Two of hearts
0100000000000011  <----  King of spades
1000000000000110  <----  Ace of diamonds

^^^^^^^^^^^^^            ("face-value" bits)
             ^           ("low-ace" flag)
              ^^         ("suit" bits)

このようなデザインでは、ペア、スリーカード、ストレートを探すのにどのように速く点灯するか想像できます(フラッシュは少しトリッキーです)。

すべての特定の操作については説明しませんが、この種のモデルは毎秒数百万の操作をサポートしていると言えば十分です...

もちろん、覚えておいてください、私はあなたがこのようなデザインを簡単なゲーム実装で使用することを実際に主張しているわけではありません。この設計になった唯一の理由は、大規模な統計シミュレーションを実行する必要があったためです。

そのため、モデル化の方法について慎重に検討してください:

  • 各カード
  • プレーヤーの手
  • デッキ全体
  • すべてのプレーヤーのハンド(最初のハンドを分割したプレーヤーを含む)、6デッキシューズ、パイルの破棄などを含むテーブルの状態

全体的なアプリケーションモデル、および一般的なアプリケーションの目標により、最も適切なデータ構造のタイプが大幅に決定されます。

お楽しみください!!!

10の代わりに「T」を使用します。

Jを11、Qを12、Kを13に置き換えてみましたか?次に、int actersではなくchar egersを使用できます。 11-13を後で適切な文字に置き換えます。

まあ、まず第一に、deck [0]は1文字ですが、あなたは<!> quot; 2h <!> quotを詰め込もうとしています。それに。 (今のところ、あなたのやり方が間違っていることは無視します。)

基本的に、デッキをvector<std::string>にする必要があります。カードをconst char *の配列にし、要素を文字列に変換します。

次に使用:

deck.push_back(std::string(card[j]) + suit[i]);

他の人が述べたように、数字には「T」、数字にはJ、Q、Kを使用できます。 push_back ..に関する限り、deckは文字のベクトルであるため、1つの文字のみをpush_backに引数として渡すことができます。カード値(1 ... 9、T、J、Q、K)とそのスイートの両方を渡すことはできません。

個人的には、ValueとSuiteプロパティを持つ、カードを表す小さな構造体を作成します。次に、デッキをカードのベクターにすることができます。

編集済み:ベクトル(小なり)カード(大なり)がベクトル(なし)としてレンダリングされてから最後の単語を修正しました。

これはコンパイルされないかもしれませんが、ここに私がする(そして使用した)アプローチがあります。カードを表すためにintを使用したいと思うでしょうが、これをクラスで簡単に抽象化できます。あなたのために書きます。

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;
}

このクラスに追加するのは非常に簡単です。 リストを生成するには、次のように簡単です。

rstl::vector<Card> mCards;
mCards.reserve( Card::skNumCards );

for ( int cardValue = 0; cardValue < Card::skNumCards; ++cardValue )
{
    mCards.push_back( Card( cardValue ) );
}

シャッフルする必要がありますか?

#include <algorithm>
std::random_shuffle( mCards.begin(), mCards.end() );

最初のカードの価値を確認するにはどうすればよいですか

if ( mCards[0].GetSuit() == Card::kRank_Club && mCards[0].GetRank() == Card::kRank_Ace )
{
    std::cout << "ACE OF CLUBS!" << std::endl;
}

このいずれもコンパイルしませんでしたが、近いはずです。

これはブラックジャックプログラムであるため、カードの価値を追加および比較します。

その場合、 char の値ではなく int の値(1〜13)をカードに与えることで、プログラミングと手間を省くことができます。

カードクラスのC ++デッキを作成したとき、私自身のいくつかの問題に遭遇しました。まず、 PHPクラスのカードクラスを変換しようとしていました。最小限の運でC ++に。私は座って紙の上に置くことにしました。主に拡張に使用するのが最も簡単だと感じたため、オブジェクト指向セットアップを使用することにしました。オブジェクト Card および Deck を使用しているため、たとえば、10枚のデッキをブラックジャックゲームの Shoe に入れたい場合は、 10個のデッキを作成できますが、これは十分に単純なものです。なぜなら、すべてを自己完結型にすることを決めたからです。実際、それは自己完結型なので、靴を作成するためのコードは次のようになります。

#include "AnubisCards.cpp"

int main() {

    Deck *shoe = new Deck(10);

}

しかし、それは単純化のためであり、単一のデッキのみが必要な小規模なゲームでは必ずしも必要ではありません。

とにかく、 I がどのようにデッキを生成したかは、52個のカードオブジェクトの配列を作成することによるものでした。デッキは簡単です。 4スーツ各スーツに13枚のカードがあることを知っているので、 2,3,4,5 、6、7、8、9、10、ジャック、クイーン、キング、エースをすべてのスーツに入れる。それらは決して変わりません。そこで、2つのループを使用しました。1つは Suit 用で、もう1つは Value 用です。

次のようなものでした:

for(int suit = 1; suit <= 4; suit++){
    for(int card = 1; card <= 13; card++){
        // Add card to array
    }
}

今、これらのループのすべての1つで気づくでしょう、整数値を使用します。理由は単純で、カードは数字です。 4スーツ。 13の値。ブラックジャックのゲームの数値でさえ。フェイスカードを押すまでの数値、フェイスカードは数値1または11のエースを押すまで数値10です。すべてが数字です。そのため、これらの番号を使用して、カードの値だけでなく、カードのスーツ、および番号順に番号を割り当てることができます。

1つのアイデアは、カードのcharまたはString名で、それぞれのインデックスである1,2,3 ...を使用して、Cardクラスにマップを格納することです。

整数を使用するというRossの提案に従います。ほとんどのカードゲームでは、多少の数学が必要になるため、より適切に表現できます。

出力で「A」または「ACE」などに変換します。

これはC ++の宿題なので、クラスを使用することが期待されると思います。 それ以外の場合は列挙型を使用し、これがCの場合は構造体などを使用します。

また、ポイント値以外の一部のゲームでは、現在のプレイモードに応じて、カードのある種のランクを保存する必要があります。

プレーンCを永遠にやったことはありませんが、次のような意味です:

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;
}

出力は次のようになります:

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

ブラックジャックは退屈です。 このコードはコンパイルされます。

ライセンス: CC-BY-SA帰属
所属していません StackOverflow
scroll top