预测洗牌后的扑克牌顺序

#include #include

using namespace std;

// 洗牌方法的枚举 enum ShuffleMethod { BOTTOM_TO_TOP, // 底牌洗牌法 TOP_TO_BOTTOM, // 顶牌洗牌法 TOP_TO_BOTTOM_THREE_TIMES, // 顶牌洗牌法三次 TOP_TO_BOTTOM_FOUR_TIMES, // 顶牌洗牌法四次 BOTTOM_TO_TOP_THREE_TIMES, // 底牌洗牌法三次 BOTTOM_TO_TOP_FOUR_TIMES, // 底牌洗牌法四次 TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_THREE_TIMES, // 顶牌洗牌法三次、底牌洗牌法三次 TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_FOUR_TIMES, // 顶牌洗牌法三次、底牌洗牌法四次 TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_THREE_TIMES, // 顶牌洗牌法四次、底牌洗牌法三次 TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_FOUR_TIMES // 顶牌洗牌法四次、底牌洗牌法四次 };

// 洗牌法的名称 const string shuffleMethodNames[] = { 'BOTTOM_TO_TOP', 'TOP_TO_BOTTOM', 'TOP_TO_BOTTOM_THREE_TIMES', 'TOP_TO_BOTTOM_FOUR_TIMES', 'BOTTOM_TO_TOP_THREE_TIMES', 'BOTTOM_TO_TOP_FOUR_TIMES', 'TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_THREE_TIMES', 'TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_FOUR_TIMES', 'TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_THREE_TIMES', 'TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_FOUR_TIMES' };

// 根据洗牌法的名称获取洗牌方法 ShuffleMethod getShuffleMethod(const string& shuffleMethodName) { for (int i = 0; i < 10; i++) { if (shuffleMethodName == shuffleMethodNames[i]) { return static_cast(i); } } return BOTTOM_TO_TOP; // 默认返回底牌洗牌法 }

// 底牌洗牌法 void shuffleBottomToTop(vector& cards) { int bottomCard = cards.back(); cards.pop_back(); cards.insert(cards.begin(), bottomCard); }

// 顶牌洗牌法 void shuffleTopToBottom(vector& cards) { int topCard = cards.front(); cards.erase(cards.begin()); cards.push_back(topCard); }

// 洗牌法三次 void shuffleThreeTimes(vector& cards) { shuffleTopToBottom(cards); shuffleTopToBottom(cards); shuffleTopToBottom(cards); }

// 洗牌法四次 void shuffleFourTimes(vector& cards) { shuffleTopToBottom(cards); shuffleTopToBottom(cards); shuffleTopToBottom(cards); shuffleTopToBottom(cards); }

// 洗牌法三次、底牌洗牌法三次 void shuffleThreeTimesAndBottomToTopThreeTimes(vector& cards) { shuffleThreeTimes(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); }

// 洗牌法三次、底牌洗牌法四次 void shuffleThreeTimesAndBottomToTopFourTimes(vector& cards) { shuffleThreeTimes(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); }

// 洗牌法四次、底牌洗牌法三次 void shuffleFourTimesAndBottomToTopThreeTimes(vector& cards) { shuffleFourTimes(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); }

// 洗牌法四次、底牌洗牌法四次 void shuffleFourTimesAndBottomToTopFourTimes(vector& cards) { shuffleFourTimes(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); shuffleBottomToTop(cards); }

int main() { int n; cin >> n;

vector<vector<int>> shuffleMethods(n);
for (int i = 0; i < n; i++) {
    shuffleMethods[i].resize(52);
    for (int j = 0; j < 52; j++) {
        cin >> shuffleMethods[i][j];
    }
}

int k;
cin >> k;

vector<int> cards(52);
for (int i = 0; i < 52; i++) {
    cards[i] = i + 1;
}

ShuffleMethod shuffleMethod = getShuffleMethod(shuffleMethodNames[k - 1]);
switch (shuffleMethod) {
    case BOTTOM_TO_TOP:
        shuffleBottomToTop(cards);
        break;
    case TOP_TO_BOTTOM:
        shuffleTopToBottom(cards);
        break;
    case TOP_TO_BOTTOM_THREE_TIMES:
        shuffleThreeTimes(cards);
        break;
    case TOP_TO_BOTTOM_FOUR_TIMES:
        shuffleFourTimes(cards);
        break;
    case BOTTOM_TO_TOP_THREE_TIMES:
        shuffleThreeTimesAndBottomToTopThreeTimes(cards);
        break;
    case BOTTOM_TO_TOP_FOUR_TIMES:
        shuffleThreeTimesAndBottomToTopFourTimes(cards);
        break;
    case TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_THREE_TIMES:
        shuffleFourTimesAndBottomToTopThreeTimes(cards);
        break;
    case TOP_TO_BOTTOM_THREE_TIMES_BOTTOM_TO_TOP_FOUR_TIMES:
        shuffleFourTimesAndBottomToTopFourTimes(cards);
        break;
    case TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_THREE_TIMES:
        shuffleFourTimesAndBottomToTopThreeTimes(cards);
        break;
    case TOP_TO_BOTTOM_FOUR_TIMES_BOTTOM_TO_TOP_FOUR_TIMES:
        shuffleFourTimesAndBottomToTopFourTimes(cards);
        break;
}

for (int i = 0; i < 52; i++) {
    int card = cards[i];
    int suit = (card - 1) / 13;
    int value = (card - 1) % 13 + 2;
    string suitName;
    string valueName;
    switch (suit) {
        case 0:
            suitName = 'Clubs';
            break;
        case 1:
            suitName = 'Diamonds';
            break;
        case 2:
            suitName = 'Hearts';
            break;
        case 3:
            suitName = 'Spades';
            break;
    }
    switch (value) {
        case 2:
            valueName = '2';
            break;
        case 3:
            valueName = '3';
            break;
        case 4:
            valueName = '4';
            break;
        case 5:
            valueName = '5';
            break;
        case 6:
            valueName = '6';
            break;
        case 7:
            valueName = '7';
            break;
        case 8:
            valueName = '8';
            break;
        case 9:
            valueName = '9';
            break;
        case 10:
            valueName = '10';
            break;
        case 11:
            valueName = 'Jack';
            break;
        case 12:
            valueName = 'Queen';
            break;
        case 13:
            valueName = 'King';
            break;
        case 14:
            valueName = 'Ace';
            break;
    }
    cout << valueName << ' of ' << suitName << endl;
}

return 0;

}