Раздача карт и оценка комбинации

@Liss29 · Регистрация: 18.11.2012

Студворк — интернет-сервис помощи студентам

Привет! Думаю, ничего нового в моей теме не будут, но все же интересно, очередное задание из Дейтелов, звучит так:

Кликните здесь для просмотра всего текста

Измените программу на рис. 8.27 так, чтобы функция раздачи сдавала по пять
карт для игры в покер. Затем напишите следующие дополнительные ф функции,
которые могут:
a) Определить, имеется ли на руках у игрока пара.
b ) Определить, имеется ли на руках у игрока две пары.
c) Определить, имеется ли на руках тройка (например, три валета).
d) Определить, имеет ли игрок каре (например, четыре туза).
e) Определить, имеется ли на руках флеш (т.е. пять карт одной масти).
f) Определить, имеется ли на руках стрит (т.е. пять карт последовательных номиналов).

Программа на рис 8.27 выглядит так

первый файл: DeckOfCards.h

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
//Рис. 8.25: DeckOfCards.h 
//Определение класса DeckOfCards, представляющего колоду игральных карт.
 
//Определение класса DeckOfCards 
class DeckOfCards
{
   public:
    DeckOfCards(); //инициализирует колоду 
    void shuffle(); //тасует карты в колоде 
    void deal(); //сдаёт карты
   private: 
    int deck[4][13]; //представляет колоду карт 
};

второй файл: DeckOfCards.cpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//Рис. 8.26: DeckOfCards.cpp
//Определения элемент-функций класса DeckOfCards, моделирующего
//тасование и сдачу колоды карт 
#include <iostream>
//using std::cout;
//using std::left;
//using std::right;
 
#include <iomanip>
//using std::setw;
 
#include <cstdlib>
//using std::rand;
//using std::srand;
 
#include <ctime>
//using std::time;
 
#include "DeckofCards.h" //опеределение класса DeckOfCards 
 
 
//конструктор по умолчанию DeckOfCards инициализирует колоду
DeckOfCards::DeckOfCards()
{
    //цикл по строкам Deck 
    for(int row = 0; row <= 3; row++)
    {
        //цикл по столбцам в текущей строке Deck 
        for(int column = 0; column <= 12; column++)
        {
            deck[row][column] = 0; //установить ячейку в ноль 
        }
    }
    srand(time(0)); //засеять генератор случайных чисел 
}
 
//Перетасовать карты в колоде 
void DeckOfCards::shuffle()
{
    int row; //представляет масть карты 
    int column; //представляет численный номинал карты 
    
    //для каждой из 52 карт случайно выбрать ячейку deck 
    for(int card = 1; card <= 52; card++)
    {
        do//выбрать новую позицию, пока не найдётся свободная ячейа
        {
            row = rand() % 4; //случайно выбрать строку 
            column = rand() % 13; //случайно выбрать столбец 
        }
        while(deck[row][column] != 0);
        
        //поместить номер карты в выбранную ячейку deck 
        deck[row][column] = card;
    }
 
}   
 
//сдать карты 
void DeckOfCards::deal()
{
    //инициализировать массив мастей 
    /*static const char *suit[4] = 
    { "Hearts", "Diamonds", "Clubs", "Spades" };
    
    //инициализировать массив номиналов
    static const char *face[13] = 
    { "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King", "Ace" };*/
    static const char *suit[4] =
    { "Червы", "Бубны", "Треф", "Пики" };
    
    static const char *face[13] = 
    { "Двойка", "Три", "Четыре", "Пять", "Шесть", "Семь", "Восемь", "Девять", "Десять", "Валет", "Дама", "Король", "Туз" };
    
    //для каждой из 52 карт 
    for(int card = 1; card <= 52; card++)
    {
        //цикл по строкам deck
        for(int row = 0; row <= 3; row++)
        {
            //цикл по столбцам в текущей строке deck 
            for(int column = 0; column <= 12; column++)
            {
                //если ячейка содержит текущую карту, вывести карту
                if(deck[row][column] == card)
                {
                    cout << setw(5) << right << face[column]
                         << " of " << setw(8) << left << suit[row] << (card % 2 == 0 ? '\n' : '\t');
                }
            }
        }
    }
}

третий файл:Fig08_27.cpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
//Рис. 8.27: Fig08_27.cpp
//Программа тасования и сдачи карт 
#include "DeckOfCards.h" //определение класса DeckOfCards 
using namespace std;
int main()
{
    DeckOfCards deckOfCards; //создать объект DeckOfCards 
    
    deckOfCards.shuffle(); //перетасовать карты колоды 
    deckOfCards.deal(); //сдать карты колоды
    return 0;
}

Хотел сам сделать, но не получается, дело вот в чём, я написал как сдать пять карт, слегка подправив функцию сдачи, вот так:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
void DeckOfCards::deal()
{
    //инициализировать массив мастей 
    static const char *suit[4] = 
    { "Hearts", "Diamonds", "Clubs", "Spades" };
    
    //инициализировать массив номиналов
    static const char *face[13] = 
    { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
    int counter = 0;
    int Face[5];
    int Suit[5];    
    //для каждой из 52 карт 
    for(int card = 1; card <= 52; card++)
    {
        //цикл по строкам deck
        for(int row = 0; row <= 3; row++)
        {
            //цикл по столбцам в текущей строке deck 
            for(int column = 0; column <= 12; column++)
            {
                //если ячейка содержит текущую карту, вывести карту
                if(deck[row][column] == card && counter != 5)
                {
                    //cout << setw(5) << right << face[column]
                         //<< " of " << setw(8) << left << suit[row] << (card % 2 == 0 ? '\n' : '\t');
                         if(counter % 2 == 0) 
                         {
                            Suit[counter] = row;
                            Face[counter] = column;
                            index1++;
                         
                         counter++;
                }
                else if(counter == 5)
                {
                    pairOfCardsOfTheSameRank(Face, Suit, face, suit);
                }
            }
        }
    }
}

затем написал функции, хотя они и выглядят не примечательно, но, тем не менее, работают, вот:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
//Функция определяет есть ли у игрока на руках пара.
void pairOfCardsOfTheSameRank(int f[], int s[], const char *face[], const char *suit[])
{
    vector<int> frequency(13);//создаём массив из 13 счётчиков
    int flags = 0;
    for(int i = 0; i < 5; i++)
    {
        frequency[f[i]]++;//сколько раз выпала та или иная карта
    }
    for(int j = 0; j < frequency.size(); j++)
    {
        if(frequency[j] == 2)//если выпала две пары, то это не наш случай, в данной конкретной функции нужна одна пара
        {
            flags++;
        }
    }
    if(flags == 1)//если пара одна, отлично выводим или возвращаем результат.
    {
        for(int m = 0; m < frequency.size(); m++)
        {
            if(frequency[m] == 2)
            {
                for(int n = 0; n < 5; n++)
                {
                    if(f[n] == m)
                    {
                        cout << "Пара: " << face[f[n]] << ' ' << suit[s[n]] << ' ';
                    }
                }
            }
        }
    }
    else //иначе облом, как без этого.
    {
        cout << "Пара отсутствует!" << endl;
    }
//это альтернативный вариант решения той же задачи!
    /*if(f[0] == f[1] || f[1] == f[2] || f[2] == f[3] || f[3] == f[4])
        cout << endl << "У игрока есть пара" << endl;
    else
        cout << endl << "пары нет" << endl;*/
}
 
//функция определяет имеется ли на руках у игрока две пары карт...
void TwoPairOfCardsOfTheSameRank(int f[], int s[], const char *face[], const char *suit[])
{
    vector<int> frequency(13);
    int cnt = 0;
    int number = 1;
    for(int i = 0; i < 5; i++)
    {
        frequency[f[i]]++;
    }
    for(int j = 0; j < 13; j++)
    {
        if(frequency[j] == 2)
        {
            cnt++;
        }
    }
    if(cnt == 2)
    {
        for(int m = 0; m < 13; m++)
        {
            if(frequency[m] == 2)
            {
                cout << "Пара " << number << ": ";
                for(int n = 0; n < 5; n++)
                {
                    if(f[n] == m)
                    {
                       cout << face[f[n]] << ' ' << suit[s[n]] << ' ';
                    }
                }
                cout << '\n';
                number++;
            }
        }
    }
    else
    {
        cout << "Совпадения двух пар карт одного достоинсва нет" << endl;
    }
}
 
//Функция определяет есть ли на руках три карты одного достоинства
void threeCardsOfTheSameRank(int f[], int s[], const char *face[], const char *suit[])
{
    int frequency[13] = {0};
    
    for(int i = 0; i < 5; i++)
    {
        frequency[f[i]]++;
    }
    for(int j = 0; j < 13; j++)
    {
        if(frequency[j] == 3)
        {
            for(int m = 0; m < 5; m++)
            {
                if(f[m] == j)
                {
                    cout << face[f[m]] << ' ' << suit[s[m]] << ' ';
                }
                
 
            }
            break;
        }
        else if(frequency[j] != 3 && j + 1 == 13)
        {
            cout << "Нет трёх карт, печально!" << endl;
        }
    }
    /*//если упорядочить массив f[], то эта функция должна прокатить...???
    if(f[0] == f[1] && f[1] == f[2] || f[1] == f[2] && f[2] == f[3] || f[2] == f[3] && f[2] == f[4])
        cout << "Есть три карты одного достоинства" << endl;
    else
        cout << "Нет трёх карт одного достоинсва" << endl;*/
 
}
 
//функция выясняет имеется ли на руках комбинация карт каре...
void functionTheCaret(int f[], int s[], const char *face[], const char *suit[])
{
    sortArray(f);
    vector<int> frequency(13);
    for(int i = 0; i < 5; i++)
    {
        frequency[f[i]]++;
    }
    for(int j = 2; j < frequency.size(); j++)
    {
        if(frequency[j] == 4)
        {
            cout << "Каре: ";
            for(int m = 0; m < 5; m++)
            {
                if(f[m] == j)
                {
                    cout << face[f[m]] << ' ' << suit[s[m]] << ' ';
                }
            }
            cout << '\n';
            break;
        }
        else if(frequency[j] != 4 && j + 1 == frequency.size())
        {
            cout << "Каре остался несбыточной мечтой(" << endl;
        }
    }
    /*if(f[0] == f[1] && f[1] == f[2] && f[2] == f[3] || f[1] == f[2] && f[2] == f[3] && f[2] == f[4])
        cout << "Каре" << endl;
    else
        cout << "не каре" << endl;*/
}
 
//функция определяет есть ли комбинация флеш, пять карт одной масти...
void functionDefinitionOfFlach(int f[], int s[], const char *face[], const char *suit[])
{
    vector<int> frequency(4);
    for(int i = 0; i < 5; i++)
    {
        frequency[s[i]]++;
    }
    for(int j = 0; j < frequency.size(); j++)
    {
        if(frequency[j] == 5)
        {
            for(int m = 0; m < 5; m++)
            {
                cout << "|" << "-" << face[f[m]] << ' ' << suit[s[j]] << "-" << "|" << ' ';
            }
            cout << '\n';
            break;
        }
        else if(frequency[j] != 5 && j + 1 == frequency.size())
        {
            cout << "-----------------------------------------" << endl;
            cout << "|Данная комбинация карт не является флеш|" << endl;
            cout << "-----------------------------------------" << endl;
        }
    }
}
 
//данная функция выясняет есть ли на руках карты с комбинацией стрит 
void functionTheStreet(int f[], int s[], const char *face[], const char *suit[])
{
    sortArray(f);
    bool flags = true;
    for(int i = 0; i < 5; i++)
    {
        for(int j = i + 1; j < 5; j++)
        {
            if(f[i] - f[j] == 1)
            {
                flags = true;
                break;
            }
            else
            {
                flags = false;
                break;
            }
        }
        if(flags == false)
            break;
    }
    if(!flags)
    {
        cout << setw(5) << "-------------------------------------" << endl;
        cout << setw(5) << "| Данная комбинация карт не является стрит |" << endl;
        cout << setw(5) << "-------------------------------------" << endl;
    }
    else if(flags)
    {
        for(int m = 0; m < 5; m++)
        {
                cout << "|" << "-" << face[f[m]] << ' ' << suit[s[m]] << "-" << "|" << ' ';
        }
            
    }
}

Вывод результата делал для наглядности, чтобы понять работает или нет функция.
затем даётся следующее задание, цитирую:

Кликните здесь для просмотра всего текста

Используя функции, разработанные в упражнении 8.12, напишите программу,
которая сдаёт двум игрокам в покер на руки по пять карт и оценивает, чья карта
лучше.

Не мудрствуя долго, я просто подправил прежнюю функцию сдачи, вот так:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
struct gamer1
{
    int Face[5];
    int Suit[5];
};
 
struct gamer2
{
    int Face[5];
    int Suit[5];
};
 //инициализировать массив мастей 
           const char *suit[4] = 
           { "Hearts", "Diamonds", "Clubs", "Spades" };
    
           //инициализировать массив номиналов
           const char *face[13] = 
           { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
             int counter = 0;
             int index1 = 0;
             int index2 = 0;
    
             gamer1 g1;
             gamer2 g2;
             
           //для каждой из 52 карт 
           for(int icard = 1; icard <= 52; icard++)
           {
                 //цикл по строкам deck
                 for(int row = 0; row <= 3; row++)
                 {
                       //цикл по столбцам в текущей строке deck 
                      for(int column = 0; column <= 12; column++)
                      {
                           //если ячейка содержит текущую карту, вывести карту
                           if(deck[row][column] == icard && counter != 10)
                           {
                                //cout << setw(5) << right << face[column]
                                     //<< " of " << setw(8) << left << suit[row] << (icard % 2 == 0 ? '\n' : '\t');
                                if(counter % 2 == 0)
                                {                           
                                   g1.Suit[index1] = row;
                                   g1.Face[index1] = column;
                                   index1++;
                                }
                                else
                                {
                                    g2.Suit[index2] = row;
                                    g2.Face[index2] = column;
                                    index2++;
                                }
                                 counter++;
                           }
                           else if(counter == 10)
                           {
                               pairOfCardsOfTheSameRank(Face, Suit, face, suit);
                               TwoPairOfCardsOfTheSameRank(Face, Suit, face, suit);
                               threeCardsOfTheSameRank(Face, Suit, face, suit);
                               functionTheStreet(Face, Suit, face, suit);
                               functionDefinitionOfFlach(Face, Suit, face,suit);
                               
                               functionToFindFullHouse(g1.Face, g1.Suit, face, suit);
                               functionTheCaret(Face, Suit, face, suit);
 
                               counter = 0;
                               system("Pause");
                           }
                      }
                 }
           }

Здесь я создал ещё две структуры.
Хотел сделать так, чтобы сдавалось по одной карте каждому игроку, например, первому игроку первая карта, второму игроку вторая затем первому третья, второму четвёртая.... и.т.д. Вроде, работает, но остаётся вопрос, хотя, этого в задаче нет, а что если, потребуется, троим игрокам раздать, опять код править что ли или это можно как-то реализовать вроде запроса: "Сколько игроков?" Это до меня не доходит никак. Новые классы создавать для каждого игрока?!
Хотя, возможно, с этим я забегаю вперёд, так что это не обязательно.

Далее нужно сравнить карты игроков, и вывести на экран у кого карта сильнее, вот тут я и завис. Как это сделать, например, если возвращать из функции значения типа bool , то опять же непонятно какая функция, какая комбинация сильнее... (хотя я правила покера не знаю) Если обозначить функции в порядке возрастания, например, пара - это "0", две пары - это "1" и.т.д в предположении, что пара самая маленькая комбинация, ну, может, слабее её только, если вообще ничего не выпала, тогда встаёт вопрос, а если одинаковые комбинации выпали, то, что с чем сравнивать, чтобы понять какая карта сильнее... Ещё получается каждую функцию проверки нужно вызывать дважды для первого игрока и затем для второго игрока, как-то всё очень примитивно, на моё взгляд! Вот с этим вопросом я к вам и обращаюсь, для начала!
Я пока делаю без классов (слабо в них ориентируюсь).

@_Ivana · 13.07.2016, 23:42

Закатываешь Енум - перечень всех вариантов комбинаций - пара, две пары, тройка, ~~страйк~~ стрит, флеш и т.п. Пишешь функцию, по набору карт определяющую максимальную комбинацию (чтобы когда 4 туза выдавало каре тузов а не пару) - вектор комбинация + достоинство, например "пара троек и пара тузов". Пишешь функцию сравнения 2-х комбинаций - какая больше. И по этому компаратору находишь максимум из массива/списка/вектора/какого угодно контейнера. И потом проверка на единственность/неединственность максимальной комбинации среди всех игроков. Все.

@Liss29 · 15.07.2016, 02:59 **[ТС]**

Сообщение от _Ivana

Пишешь функцию, по набору карт определяющую максимальную комбинацию (чтобы когда 4 туза выдавало каре тузов а не пару)

Правильно ли я понял, что функции, которые я написал более не нужны?

@Liss29 · 16.07.2016, 05:47 **[ТС]**

Я что один по этим Дейтелам изучаю, такое ощущение, что на форуме никого нет.

@Liss29 · 20.07.2016, 22:15 **[ТС]**

_Ivana
Как создать указатель на вектор, почитал, нашёл такое решение:

C++
1
2
vector<int> IntVec;
int *pointer = IntVec.data();

Но у меня почему-то выдаёт сообщение об ошибке:

Code
1
error C2039: 'data' : is not a member of 'vector<int,class std::allocator<int> >'

Как тогда создать указатель на вектор, и вообще, такое возможно?

@_Ivana · 21.07.2016, 00:10

Liss29, а зачем? Имхо, или вы в чистых сях - и тогда структуры, массивы и указатели, или в плюсах с STL - и тогда ссылки и всякие контейнеры и алгоритмы из библиотеки.

@Liss29 · 21.07.2016, 04:14 **[ТС]**

Сообщение от _Ivana

а зачем?

Так как тема указатели, то я и решил попробовать соорудить такую конструкцию.
Всё до банальности просто, если из обычного массива указатель сделать возможно, то возможно ли сделать тоже самое и с вектором. Попробовал проделать те же действия, которые я проделывал для создания указателя на массив (обычный) ничего не получилось, стал искать ответ, нашёл статью, где описывалась такая вот конструкция, которую я привёл выше в вопросе, но возникла ошибка.

Не по теме:

Имхо, или вы в чистых сях - ...или в плюсах с STL - ...

Я пока делаю как получится, особо не вникаю чистые это Си или плюсики:)

@_Ivana · 21.07.2016, 04:23

Сообщение от Liss29

Так как тема указатели

Тогда и делайте на указателях, безо всяких векторов и прочего читерства.

@Liss29 · 21.07.2016, 05:46 **[ТС]**

Сообщение от _Ivana

безо всяких векторов и прочего читерства.

Так не получется почему-то. А что такое читерство?

@Liss29 · 26.07.2016, 05:15 **[ТС]**

Закатываешь Енум - перечень всех вариантов комбинаций - пара, две пары, тройка, страйк стрит, флеш и т.п. Пишешь функцию, по набору карт определяющую максимальную комбинацию (чтобы когда 4 туза выдавало каре тузов а не пару) - вектор комбинация + достоинство, например "пара троек и пара тузов".

Такая вот у меня получилась функция

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
//функция должна выяснить какая комбинция из розданных карт является наибольшей...
vector<int> maximumCombinationOfCards(int Face[], int Suit[])
{
    //enum Combination { ПАРА, ДВЕ ПАРЫ, ТРИ, КАРЕ, ФЛЕШ, СТРИТ };
    enum Combination { NOT_COMBINATION, PAIR, TWO_PAIR, THREE, STREET, FLACH, FULL_HOUSE, CARET };
    Combination cName; //имя кобинации(название)
    vector<int> frequency(13);
    vector<int> sFrequency(4);
    vector<int> maximum;
    
    int TwoCnt = 0, StreetCnt = 0;
    for(int i = 0; i < 5; i++)
    {
        frequency[Face[i]]++; //счётчик номиналов карт 
        sFrequency[Suit[i]]++;//счётчик мастей карт 
    }
    
    for(int j = 0; j < frequency.size(); j++)
    {
        if(frequency[j] == 0) //в данном случае делаю как со счётчиками т.е. каждая карта, которую сдвли игроку инкрементируется и получается точное количество розданных карт определённого номинала, например, три туза и одна пятёрка и одна двойка
        {
            //frequency.erase(frequency.begin() + j);
            continue;      //если нуль, значит тут пусто таких карт нет на руках у игрока, переходим к следующей...
        }
        if(frequency[j] == 2) //если обнаружена пара, то смотрим сколько пар одна или две...
        {
            TwoCnt++;
        }
        else if(frequency[j] == 3) //если три карты, то в массив помещаем идентификатор комбинации и номинал карты
        {
            //Проверю, есть ли фулл-хаус
            for(int three = 0; three < frequency.size(); three++)
            {
                if(frequency[three] == 2)
                {
                    cName = FULL_HOUSE;
                    maximum.push_back(cName);
                    for(int full = 0; full < frequency.size(); full++)
                    {
                        if(frequency[full] == 3 || frequency[full] == 2)
                        {
                            maximum.push_back(full);
                        }
                    }
                    TwoCnt = 0;
                    break;
                }
            }
            //если нет, то это просто тройка карт.
            if(maximum.empty())
            {
                cName = THREE;
                maximum.push_back(cName);
                maximum.push_back(j);
            }
        }
        else if(frequency[j] == 4) //если четыре, то в массив впихиваем идентификатор комбинации и наминал карты. Например, Каре тузов.
        {
            cName = CARET;
            maximum.push_back(cName);
            maximum.push_back(j);
        }
        else if(frequency[j] == 1) //здесь смотрим, сколько еденичек т.е. одиночных карт
        {
            StreetCnt++;
        }
    }
    if(TwoCnt == 1 && maximum.empty()) //пара одна
    {
        cName = PAIR;
        maximum.push_back(cName);
        for(int m = 0; m < frequency.size(); m++)
        {
            if(frequency[m] == 2)
            {
                 maximum.push_back(m);
            }
        }
    }
    else if(TwoCnt == 2 && maximum.empty())//пара не одна, а целых две...
    {
        cName = TWO_PAIR;
        maximum.push_back(cName);
        for(int n = 0; n < frequency.size(); n++)
        {
            if(frequency[n] == 2)
            {
                maximum.push_back(n);
            }
            
        }
    }
    else if(StreetCnt == 5) //все пять карт разные нужно выяснить это стрит или флеш
    {
        sortArray(Face); //сортируем массив в нисходящем порядке
        cName = STREET;
        maximum.push_back(cName); //помещаем в массив комбинацию 
        for(int s = 0; s < 5; s++)
        {
            if((Face[0] == 0 || Face[4] == 0) && (Face[s] - Face[s + 1] == 1) && (Face[3] - Face[4] != 1)) //если в начале или в конце у нас есть туз(он у меня идёт под 0), то учитываю этот факт и так как при вычитании предпоследней и последней комбинации не будет достигнут нужный мне резельтат т.е. один и это не должно считаться условием выхода из цикла, то это я обозначил в условии. На большее не хватило ума)
            {
                        maximum.push_back(Face[s]);
            }
            else if((Face[0] != 0 || Face[4] != 0) && (Face[s] - Face[s + 1] == 1)) //здесь соответственно, если тузов не присутствует, то просто без заморочек проверяем вычитанием все значения(карты на руках) и, если хоть одно не равно один, то это не стрит
            {
                maximum.push_back(Face[s]);
            }
            else   //если не стрит, очищаем вектор и выходим.
            {
                maximum.clear();
                StreetCnt = 0;
                break;
            }
        }
        for(int f = 0; f < sFrequency.size(); f++)
        {
            if(sFrequency[f] == 5 && maximum.empty()) //проверим на флеш, если есть пять карт одной масти и вектор пуст(стрита нет), то отмечаем этот факт занесением в вектор комбинации и достоинства карты.
            {
                 cName = FLACH;
                 maximum.push_back(cName);
                 maximum.push_back(f);
            }
        }
        //Если не стрит и не флеш, а карты разного достоинства, то это означает, что никакая комбинация не выпала. 
            if(maximum.empty())
            {
                cName = NOT_COMBINATION;
                maximum.push_back(cName);
                for(int notCom = 0; notCom < frequency.size(); notCom++)
                {
                    if(frequency[notCom] == 1)
                       maximum.push_back(notCom);
                }
            }
    }
    return maximum;
}

Сообщение от _Ivana

Пишешь функцию сравнения 2-х комбинаций - какая больше.

Первоначально так зделал

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//Какая карта лучше, какая комбинация выигрышна...
vector<int> cmpCards(vector<int> &max1, vector<int> &max2)
{
    if(*max1.begin() < *max2.begin())
    {
        return max2;
    }
    else if(*max1.begin() > *max2.begin())
    {
        return max1;
    }
    else if(*max1.begin() == *max2.begin())
    {
        for(int i = 1; i < max1.size(); i++)
        {
            if(max1[i] > max2[i] || max1[i] == 0)
            {
                return max1;
            }
            else
            {
                return max2;
            }
        }
    }
}

Но после попытался вникнуть в правила игры, точнее, как определяется выигрышная комбинация и оказалось, что там много нюансов, я решил эти мелочи попытаться воплотить в код, например, если выпала две пары у обоих игроков, то как определить победителся, Когда у двух игроков есть две пары, тот, у кого есть более высокая пара, выигрывает. Если старшие пары обоих – одного достоинства, выигрывает тот, чья вторая пара выше. Если и они одинаковы, то победитель определяется по старшинству кикера.

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
//Какая карта лучше, какая комбинация выигрышна...
vector<int> cmpCards(vector<int> &max1, vector<int> &max2, int Face[], int Face1[])
{
    vector<int> result;
    if(*max1.begin() < *max2.begin()) //сравниваю первые символы т.е. комбинации, если первая комбинация меньше второй, сохраним в result значение второго вектора(условного игрока)
    {
        result = max2;
    }
    else if(*max1.begin() > *max2.begin()) //если наоборот, то первый игрок победил
    {
        result = max1;
    }
    else if(*max1.begin() == *max2.begin()) //если карты равны, то проверяем по старшинству карт находящихся на руках и игроков
    {
        if(*(max1.begin()) >= 0 && *(max1.begin()) <= 2 || *(max1.begin()) == 6)
        {
            result = equalCards(max1, max2, Face, Face1); //если пара, две пары, тройка или фулл-хаус, то проверяем этой функцией
        }
        else //иначе, при любой другой комбинации, проверяем так...
        {
           for(int i = 0; i < sizeof(Face) / sizeof(int); i++)
           {
             if(Face[i] > Face1[i])
             {
                result = max1;
             }
             else
             {
                result = max2;
             }     
           }
        }
    }
    return result;
}
 
vector<int> equalCards(vector<int> &max1, vector<int> &max2, int f[], int f1[])
{
    vector<int> result;
    sortVector(max1);
    sortVector(max2);
    sortArray(f);
    sortArray(f1);
    for(int i = 0; i < 5; i++)
        cout << f[i] << ' ';
    for(int j = 0; j < max1.size(); j++)
        cout << max1[j] << ' ';
    if(*max1.begin() == 0 && *max2.begin() == 0)
    {
        for(int n_comb = 0; n_comb < 5; n_comb++)
        {
            if(f[n_comb] == 0 && f1[n_comb] == 0)
            {
                for(int next_comb = 0; next_comb < 5; next_comb++)
                {
                    if(f[next_comb] < f1[next_comb])
                    {
                        result = max2;
                    }
                    else if(f[next_comb] > f1[next_comb])
                    {
                        result = max1;
                    }
                }
            }
        }
        if(result.empty())
        { 
            for(int one_Ace = 0; one_Ace < 5; one_Ace++)
            {
                if(f[one_Ace] == 0 && f1[one_Ace] != 0)
                {
                    result = max1;
                    break;
                }
                else  if(f[one_Ace] != 0 && f1[one_Ace] == 0)
                {
                    result = max2;
                    break;
                }
            }
        }
        if(result.empty())
        {
            for(int notAce = 0; notAce < 5; notAce++)
            {
                if(f[notAce] > f1[notAce])
                {
                    result = max1;
                }
                else
                {
                    result = max2;
                }
            }
        }
    }
    if(*max1.begin() == 1 && *max2.begin() == 1)
    {
        for(int p = 1; p < max1.size(); p++)
        {
            if(max1[p] > max2[p])
            {
                result = max1;
            }
            else if(max1[p] < max2[p])
            {
                result = max2;
            }
            else if(max1[p] == max2[p])
            {
                for(int pair1 = 0; pair1 < 5; pair1++)
                {
                    if(f[pair1] != f1[pair1] && f[pair1] > f1[pair1])
                    {
                        result = max1;
                        for(int i = 0; i < 5; i++)
                        {
                            if(result[i] != max1[0] && result[i] != max1[1])
                            {
                               result.push_back(f[i]);
                            }
                        }
                        break;
                    }
                    else if(f[pair1] != f1[pair1] && f[pair1] < f1[pair1])
                    {
                        result = max2;
                        for(int j = 0; j < 5; j++)
                        {
                           if(result[j] != max1[0] && result[j] != max1[1])
                           {
                               result.push_back(f1[j]);
                           }
                        }
                        break;
                    }
                }
            }
        }
    }
        //если две пары карт равны
    else if(*max1.begin() == 2 && *max2.begin() == 2)
    {
        for(int twoPair = 1; twoPair < max1.size(); twoPair++)
        {
            if(max1[twoPair] != max2[twoPair] && max1[twoPair] > max2[twoPair])
            {
                result = max1;
                break;
            }
            else if(max1[twoPair] != max2[twoPair] && max1[twoPair] < max2[twoPair])
            {
                result = max2;
                break;
            }
            else if(max1[1] == max2[1] && max1[2] == max2[2])
            {
                if(f[4] > f1[4])
                {
                    result = max1;
                    result.push_back(f[4]);
                    break;
                }
                else if(f[4] < f1[4])
                {
                    result = max2;
                    result.push_back(f1[4]);
                    break;
                }
            }
        }   
    }
    //если фулл-хаус
    else if(*max1.begin() == 6 && *max2.begin() == 6)
    {
        for(int i = 0; i < 3; i++)
        {
            if(*(max1.begin() + 1) == f[i] && *(max2.begin() + 1) == f1[i])//если первое значение в векторе max1 и max2 повторяется три раза, то это то, что нужно, срвниваем первые три карты у обоих игроков, если первыми идёт пара, то меняем местами так чтобы первым значением после комбинации оказалось значение трёх карт, как-то так)...
            {
                continue;
            }
            else if(*(max1.begin() + 1) != f[i])
            {
                int ok = max1.back();
                int notThree = *(max1.begin() + 1);
                max1.erase(max1.begin() + 1, max1.end());
                max1.push_back(ok);
                max1.push_back(notThree);
            }
            if(*(max2.begin() + 1) != f1[i])
            {
                int three = max2.back();
                int isNotThree = *(max2.begin() + 1);
                max2.erase(max2.begin() + 1, max2.end());
                max2.push_back(three);
                max2.push_back(isNotThree);
            }
        }
        for(int j = 1; j < max1.size(); j++)
        {
            if(max1[j] > max2[j] && max2[1] != 0)
            {
                result = max1;
                break;
            }
            else if(max1[j] < max2[j] && max1[1] != 0)
            {
                result = max2;
                break;
            }
        }
    }
    return result;  
}

Вот как-то так...

@_Ivana · 26.07.2016, 18:27

Код не смотрел, а про

Сообщение от Liss29

там много нюансов, я решил эти мелочи попытаться воплотить в код

- есть несколько вариантов реализаций, например заранее заданное множество шаблонов комбинаций сортированных по приоритету по убыванию и последовательная проверка набора карт на удовлетворение первой из них.

@shilko2013 · 26.07.2016, 18:32

Liss29, Только вчера закончил Дейтейла. Там полностью весь код написан. Просто перепишите и все.

@Liss29 · 26.07.2016, 21:39 **[ТС]**

shilko2013

Сообщение от shilko2013

Там полностью весь код написан

Где?

Просто перепишите и все.

Переписать то можно, если есть откуда, но смысл?! чему ты научишься, если тупо будешь копировать у кого-то код, хотя вот свериться, когда ты уже решил, было бы не плохо, посмотреть в правильном направлении мыслишь или как.

@_Ivana · 26.07.2016, 22:00

Сообщение от shilko2013

Просто перепишите и все.

Да что уж там, можно сразу и не жить дальше - в Дейтелах все равно все написано и финал известен.

@Liss29 · 27.07.2016, 06:01 **[ТС]**

_Ivana

Сообщение от _Ivana

заранее заданное множество шаблонов комбинаций сортированных по приоритету

Хм.. боюсь ошибится, но, по моему, я это ещё не проходил, хотя раздел был в книге про указатели на массив функций, может что-то подобное имеете ввиду? Хотя шаблон функции я знаю как создать, а шаблон класса нет, но мысль мне, определённо, интересна.

А как в реализации с классами указать, что надо сдать двум игрокам, как вообще этих двух игроков создать? Создать два объекта, так?!

Добавлено через 7 минут
А вот ещё и продолжение эпопеи с покером:

Кликните здесь для просмотра всего текста

Измените программу, разработанную в упражнении 8.13, таким образом, чтобы
она исполняла роль сдающего. Карты сдающего кладутся «лицом вниз», так что
играющий с программой их не видит. Программа должна затем оценить карту
сдающего и, основываясь на качестве карт, сдающий должен взять себе одну, две
или три карты взамен не устраивающих его карт из первоначально розданных.
После этого программа должна оценить карты сдающего еще раз. [Предостере*
жение. Это трудная задача!]

У меня даже спина вспотела, три раза прочёл и не понял, что значит лицом вниз, как будто в предыдущем задании они были лицом вверх

Ужас в общем.

Добавлено через 7 часов 50 минут
_Ivana
А возможно ли структуры объявить в нутри класса, как данные или это лучше делать в отдельном файле(хедере)? И вообще допустимо объявление структур внутри класса?

Например, так:

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class DeckOfCards
{
   public:
    DeckOfCards(); //инициализирует колоду 
    void shuffle(); //тасует карты в колоде 
    void deal(); //сдаёт карты
   private: 
    int deck[4][13]; //представляет колоду карт 
    enum combination { NOT_COMBINATION, PAIR, TWO_PAIR, THREE, STREET, FLACH, FULL_HOUSE, CARET };
    struct Gamer1
    {
        int Face[5];
        int Suit[5];
    };
    struct Gamer2
    {
        int Face[5];
        int Suit[5];
    };
};

@shilko2013 · 27.07.2016, 09:45

_Ivana, Мне не понравился учебник

@Liss29 · 29.07.2016, 23:08 **[ТС]**

Добавлено через 18 часов 46 минут
Не могу понять, что значит, чтобы программа исполняла роль сдающего, пока у меня только такая идея: сдать карты пять штук игроку, затем сдать ещё пять карт как бы в банк (откуда, при необходимости, игрок будет брать карты для замены своих карт). Как бы на этом полёт моей фантазии иссяк, как сравнивать, как выбрать карту, которую надо скинуть и заменить на карту из банка, чтобы комбинация стала более сильной, а может вообще не надо менять ничего. Получается надо брать первую карту и сравнивать с картами из банка, если есть совпадения, тогда меняем, и так сравнить все карты из сданных на руки игроку с теми что в банке. Что-то надо будет скинуть, я так понимаю, что скидывать будем самую маленькую, не имеющую комбинаций, карту. Вот всё что смог придумать, правда, этот вариант мне не кажется таким уж удачным.

Карта кладутся лицом вниз, блин, но как это организовать, я не умею карты прорисовывать, может, просто знаки вопроса вывести, вместо номиналов карт...

Оценить качество карт сдающего, мне это видится так, выясняем какая карта на руках, например, пара, две пары или отсутствие комбинации, и смотрим, например, если есть пара, то нужно как-то понять, есть ли в банке карты одного ранга с этой парой, чтобы сделать комбинацию три или каре, если нет, то проверяем на другую комбинацию, остальные три карты не имеющие отношения к паре,(кароль, кароль, восемь, пять, два| Проверяем: восемь, пять два) мы сравниваем с картами из банка в надежде получить фулл-хаус, если совпадений нет, то ничего не меняем, а если есть, можно сделать из пары, комбинацию две пары...
Нужна помощь, в этой задаче без неё, видимо, никак.

@Liss29 · 31.07.2016, 21:13 **[ТС]**

deckOfCards.h

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//Рис. 8.25: DeckOfCards.h 
//Определение класса DeckOfCards, представляющего колоду игральных карт.
#include <vector>
using std::vector;
//Определение класса DeckOfCards 
class DeckOfCards
{
   public:
    DeckOfCards(); //инициализирует колоду 
    void shuffle(); //тасует карты в колоде 
    void deal(); //сдаёт карты
    
    vector<int> maximumCombinationOfCards(int [], int []);
    vector<int> cmpCards(vector<int> &, vector<int> &, int [], int []);
    vector<int> equalCards(vector<int> &, vector<int> &, int [], int []);
    template<typename T>
    void sortVector(vector<T> &array);
    void sortArray(int f[]);
    void printCards(vector<int> &r, int [], int []);
   private: 
    int deck[4][13]; //представляет колоду карт 
    struct Gamer1
    {
        int Face[5];
        int Suit[5];
    } g1;
    struct Gamer2
    {
        int Face[5];
        int Suit[5];
    } g2;
    //Gamer1 g1;
    //Gamer2 g2;
    vector<int> max1;
    vector<int> max2;
    vector<int> res;
};

@Liss29 · 31.07.2016, 21:15 **[ТС]**

deckOfCards.cpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
//Рис. 8.26: DeckOfCards.cpp
//Определения элемент-функций класса DeckOfCards, моделирующего
//тасование и сдачу колоды карт 
#include <iostream>
using std::cout;
using std::left;
using std::right;
using std::endl;
 
#include <iomanip>
using std::setw;
 
#include <cstdlib>
//using std::rand;
//using std::srand;
 
#include <ctime>
//using std::time;
 
//#include <vector>
//using std::vector;
#include "CyrIOS.h"
 
#include "DeckOfCards.h" //опеределение класса DeckOfCards 
 
 
//конструктор по умолчанию DeckOfCards инициализирует колоду
DeckOfCards::DeckOfCards()
{
    //цикл по строкам Deck 
    for(int row = 0; row <= 3; row++)
    {
        //цикл по столбцам в текущей строке Deck 
        for(int column = 0; column <= 12; column++)
        {
            deck[row][column] = 0; //установить ячейку в ноль 
        }
    }
    srand(time(0)); //засеять генератор случайных чисел 
}
 
//Перетасовать карты в колоде 
void DeckOfCards::shuffle()
{
    int row; //представляет масть карты 
    int column; //представляет численный номинал карты 
    
    //для каждой из 52 карт случайно выбрать ячейку deck 
    for(int card = 1; card <= 52; card++)
    {
        do//выбрать новую позицию, пока не найдётся свободная ячейа
        {
            row = rand() % 4; //случайно выбрать строку 
            column = rand() % 13; //случайно выбрать столбец 
        }
        while(deck[row][column] != 0);
        
        //поместить номер карты в выбранную ячейку deck 
        deck[row][column] = card;
    }
 
}   
 
//сдать карты 
void DeckOfCards::deal()
{
    //инициализировать массив мастей 
    /*static const char *suit[4] = 
    { "Hearts", "Diamonds", "Clubs", "Spades" };
    
    //инициализировать массив номиналов
    static const char *face[13] = 
    { "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King", "Ace" };*/
    static const char *suit[4] =
    { "Червы", "Бубны", "Треф", "Пики" };
    
    static const char *face[13] = 
    { "Туз", "Двойка", "Три", "Четыре", "Пять", "Шесть", "Семь", "Восемь", "Девять", "Десять", "Валет", "Дама", "Король", };
    int index1 = 0; int index2 = 0; int counter = 0;
    
    //для каждой из 52 карт 
    for(int card = 1; card <= 52; card++)
    {
        //цикл по строкам deck
        for(int row = 0; row <= 3; row++)
        {
            //цикл по столбцам в текущей строке deck 
            for(int column = 0; column <= 12; column++)
            {
                //если ячейка содержит текущую карту, вывести карту
                if(deck[row][column] == card && counter != 10)
                {
                    /*cout << setw(5) << right << face[column]
                         << " of " << setw(8) << left << suit[row] << (card % 2 == 0 ? '\n' : t');*/
                    if(counter % 2 == 0)
                    {
                        g1.Suit[index1] = row;
                        g1.Face[index1] = column;
                        index1++;
                    }
                    else
                    {
                        g2.Suit[index2] = row;
                        g2.Face[index2] = column;
                        index2++;
                    }
                        counter++;
                }
                else if(counter == 10)
                {
                    max1 = maximumCombinationOfCards(g1.Face, g1.Suit);
                    max2 = maximumCombinationOfCards(g2.Face, g2.Suit);
                    res = cmpCards(max1, max2, g1.Face, g2.Face);
                    if(!res.empty())
                        printCards(res, g1.Face, g2.Face);
                    index1 = 0;
                    index2 = 0;
                    counter = 0;
                    system("Pause");
                }
                
            }
        }
    }
}
 
//функция должна выяснить какая комбинция из розданных карт является наибольшей...
vector<int> DeckOfCards::maximumCombinationOfCards(int Face[], int Suit[])
{
    //enum Combination { ПАРА, ДВЕ ПАРЫ, ТРИ, КАРЕ, ФЛЕШ, СТРИТ };
    enum Combination { NOT_COMBINATION, PAIR, TWO_PAIR, THREE, STREET, FLACH, FULL_HOUSE, CARET };
    Combination cName; //имя кобинации(название)
    vector<int> frequency(13);
    vector<int> sFrequency(4);
    vector<int> maximum;
    
    int TwoCnt = 0, StreetCnt = 0;
    for(int i = 0; i < 5; i++)
    {
        frequency[Face[i]]++; //счётчик номиналов карт 
        sFrequency[Suit[i]]++;//счётчик мастей карт 
    }
    
    for(int j = 0; j < frequency.size(); j++)
    {
        if(frequency[j] == 0) //в данном случае делаю как со счётчиками т.е. каждая карта, которую сдвли игроку инкрементируется и получается точное количество розданных карт определённого номинала, например, три туза и одна пятёрка и одна двойка
        {
            //frequency.erase(frequency.begin() + j);
            continue;      //если нуль, значит тут пусто таких карт нет на руках у игрока, переходим к следующей...
        }
        if(frequency[j] == 2) //если обнаружена пара, то смотрим сколько пар одна или две...
        {
            TwoCnt++;
        }
        else if(frequency[j] == 3) //если три карты, то в массив помещаем идентификатор комбинации и номинал карты
        {
            //Проверю, есть ли фулл-хаус
            for(int three = 0; three < frequency.size(); three++)
            {
                if(frequency[three] == 2)
                {
                    cName = FULL_HOUSE;
                    maximum.push_back(cName);
                    for(int full = 0; full < frequency.size(); full++)
                    {
                        if(frequency[full] == 3 || frequency[full] == 2)
                        {
                            maximum.push_back(full);
                        }
                    }
                    TwoCnt = 0;
                    break;
                }
            }
            //если нет, то это просто тройка карт.
            if(maximum.empty())
            {
                cName = THREE;
                maximum.push_back(cName);
                maximum.push_back(j);
            }
        }
        else if(frequency[j] == 4) //если четыре, то в массив впихиваем идентификатор комбинации и наминал карты. Например, Каре тузов.
        {
            cName = CARET;
            maximum.push_back(cName);
            maximum.push_back(j);
        }
        else if(frequency[j] == 1) //здесь смотрим, сколько еденичек т.е. одиночных карт
        {
            StreetCnt++;
        }
    }
    if(TwoCnt == 1 && maximum.empty()) //пара одна
    {
        cName = PAIR;
        maximum.push_back(cName);
        for(int m = 0; m < frequency.size(); m++)
        {
            if(frequency[m] == 2)
            {
                 maximum.push_back(m);
            }
        }
    }
    else if(TwoCnt == 2 && maximum.empty())//пара не одна, а целых две...
    {
        cName = TWO_PAIR;
        maximum.push_back(cName);
        for(int n = 0; n < frequency.size(); n++)
        {
            if(frequency[n] == 2)
            {
                maximum.push_back(n);
            }
            
        }
    }
    else if(StreetCnt == 5) //все пять карт разные нужно выяснить это стрит или флеш
    {
        sortArray(Face); //сортируем массив в нисходящем порядке
        cName = STREET;
        maximum.push_back(cName); //помещаем в массив комбинацию 
        for(int s = 0; s < 5; s++)
        {
            if((Face[0] == 0 || Face[4] == 0) && (Face[s] - Face[s + 1] == 1) && (Face[3] - Face[4] != 1)) //если в начале или в конце у нас есть туз(он у меня идёт под 0), то учитываю этот факт и так как при вычитании предпоследней и последней комбинации не будет достигнут нужный мне резельтат т.е. один и это не должно считаться условием выхода из цикла, то это я обозначил в условии. На большее не хватило ума)
            {
                        maximum.push_back(Face[s]);
            }
            else if((Face[0] != 0 || Face[4] != 0) && (Face[s] - Face[s + 1] == 1)) //здесь соответственно, если тузов не присутствует, то просто без заморочек проверяем вычитанием все значения(карты на руках) и, если хоть одно не равно один, то это не стрит
            {
                maximum.push_back(Face[s]);
            }
            else   //если не стрит, очищаем вектор и выходим.
            {
                maximum.clear();
                StreetCnt = 0;
                break;
            }
        }
        for(int f = 0; f < sFrequency.size(); f++)
        {
            if(sFrequency[f] == 5 && maximum.empty()) //проверим на флеш, если есть пять карт одной масти и вектор пуст(стрита нет), то отмечаем этот факт занесением в вектор комбинации и достоинства карты.
            {
                 cName = FLACH;
                 maximum.push_back(cName);
                 maximum.push_back(f);
            }
        }
        //Если не стрит и не флеш, а карты разного достоинства, то это означает, что никакая комбинация не выпала. 
            if(maximum.empty())
            {
                cName = NOT_COMBINATION;
                maximum.push_back(cName);
                for(int notCom = 0; notCom < frequency.size(); notCom++)
                {
                    if(frequency[notCom] == 1)
                       maximum.push_back(notCom);
                }
            }
    }
    return maximum;
}
 
//Какая карта лучше, какая комбинация выигрышна...
vector<int> DeckOfCards::cmpCards(vector<int> &max1, vector<int> &max2, int Face[], int Face1[])
{
    vector<int> result;
    if(*max1.begin() < *max2.begin()) //сравниваю первые символы т.е. комбинации, если первая комбинация меньше второй, сохраним в result значение второго вектора(условного игрока)
    {
        result = max2;
    }
    else if(*max1.begin() > *max2.begin()) //если наоборот, то первый игрок победил
    {
        result = max1;
    }
    else if(*max1.begin() == *max2.begin()) //если карты равны, то проверяем по старшинству карт находящихся на руках и игроков
    {
        if(*(max1.begin()) >= 0 && *(max1.begin()) <= 2 || *(max1.begin()) == 6)
        {
            result = equalCards(max1, max2, Face, Face1); //если пара, две пары, тройка или фулл-хаус, то проверяем этой функцией
        }
        else //иначе, при любой другой комбинации, проверяем так...
        {
           for(int i = 0; i < sizeof(Face) / sizeof(int); i++)
           {
             if(Face[i] > Face1[i])
             {
                result = max1;
             }
             else
             {
                result = max2;
             }     
           }
        }
    }
    return result;
}
 
vector<int> DeckOfCards::equalCards(vector<int> &max1, vector<int> &max2, int f[], int f1[])
{
    vector<int> result;
    sortVector(max1);
    sortVector(max2);
    sortArray(f);
    sortArray(f1);
    if(*max1.begin() == 0 && *max2.begin() == 0)
    {
        for(int n_comb = 0; n_comb < 5; n_comb++)
        {
            if(f[n_comb] == 0 && f1[n_comb] == 0)
            {
                for(int next_comb = 0; next_comb < 5; next_comb++)
                {
                    if(f[next_comb] < f1[next_comb])
                    {
                        result = max2;
                    }
                    else if(f[next_comb] > f1[next_comb])
                    {
                        result = max1;
                    }
                }
            }
        }
        if(result.empty())
        { 
            for(int one_Ace = 0; one_Ace < 5; one_Ace++)
            {
                if(f[one_Ace] == 0 && f1[one_Ace] != 0)
                {
                    result = max1;
                    break;
                }
                else  if(f[one_Ace] != 0 && f1[one_Ace] == 0)
                {
                    result = max2;
                    break;
                }
            }
        }
        if(result.empty())
        {
            for(int notAce = 0; notAce < 5; notAce++)
            {
                if(f[notAce] > f1[notAce])
                {
                    result = max1;
                }
                else
                {
                    result = max2;
                }
            }
        }
    }
    if(*max1.begin() == 1 && *max2.begin() == 1)
    {
        for(int p = 1; p < max1.size(); p++)
        {
            if(max1[p] > max2[p])
            {
                result = max1;
            }
            else if(max1[p] < max2[p])
            {
                result = max2;
            }
            else if(max1[p] == max2[p])
            {
                for(int pair1 = 0; pair1 < 5; pair1++)
                {
                    if(f[pair1] != f1[pair1] && f[pair1] > f1[pair1])
                    {
                        result = max1;
                        for(int i = 0; i < 5; i++)
                        {
                            if(result[i] != max1[0] && result[i] != max1[1])
                            {
                               result.push_back(f[i]);
                            }
                        }
                        break;
                    }
                    else if(f[pair1] != f1[pair1] && f[pair1] < f1[pair1])
                    {
                        result = max2;
                        for(int j = 0; j < 5; j++)
                        {
                           if(result[j] != max1[0] && result[j] != max1[1])
                           {
                               result.push_back(f1[j]);
                           }
                        }
                        break;
                    }
                }
            }
        }
    }
        //если две пары карт равны
    else if(*max1.begin() == 2 && *max2.begin() == 2)
    {
        for(int twoPair = 1; twoPair < max1.size(); twoPair++)
        {
            if(max1[twoPair] != max2[twoPair] && max1[twoPair] > max2[twoPair])
            {
                result = max1;
                break;
            }
            else if(max1[twoPair] != max2[twoPair] && max1[twoPair] < max2[twoPair])
            {
                result = max2;
                break;
            }
            else if(max1[1] == max2[1] && max1[2] == max2[2])
            {
                if(f[4] > f1[4])
                {
                    result = max1;
                    result.push_back(f[4]);
                    break;
                }
                else if(f[4] < f1[4])
                {
                    result = max2;
                    result.push_back(f1[4]);
                    break;
                }
            }
        }   
    }
    //если фулл-хаус
    else if(*max1.begin() == 6 && *max2.begin() == 6)
    {
        for(int i = 0; i < 3; i++)
        {
            if(*(max1.begin() + 1) == f[i] && *(max2.begin() + 1) == f1[i])//если первое значение в векторе max1 и max2 повторяется три раза, то это то что нужно, срвниваем первые три карты у обоих игроков, если первыми удит пара, то меняем местами так чтобы первым значением после комбинации оказалось значение трёх карт, как-то так)...
            {
                continue;
            }
            else if(*(max1.begin() + 1) != f[i])
            {
                int ok = max1.back();
                int notThree = *(max1.begin() + 1);
                max1.erase(max1.begin() + 1, max1.end());
                max1.push_back(ok);
                max1.push_back(notThree);
            }
            if(*(max2.begin() + 1) != f1[i])
            {
                int three = max2.back();
                int isNotThree = *(max2.begin() + 1);
                max2.erase(max2.begin() + 1, max2.end());
                max2.push_back(three);
                max2.push_back(isNotThree);
            }
        }
        for(int j = 1; j < max1.size(); j++)
        {
            if(max1[j] > max2[j] && max2[1] != 0)
            {
                result = max1;
                break;
            }
            else if(max1[j] < max2[j] && max1[1] != 0)
            {
                result = max2;
                break;
            }
        }
    }
    return result;  
}
 
template<typename T>
void DeckOfCards::sortVector(vector<T> &array)
{
    for(int i = 1; i < array.size(); i++)
    {
        T insert = i;
        for(int j = i + 1; j < array.size(); j++)
        {
            if(array[insert] < array[j])
            {
                insert = j;
            }
        }
        T temp = array[i];
        array[i] = array[insert];
        array[insert] = temp;
    }
}
 
void DeckOfCards::sortArray(int f[])
{
    for(int i = 0; i < 5; i++)
    {
        int index = i;
        for(int j = i + 1; j < 5; j++)
        {
            if(f[index] < f[j])
                index = j;
        }
        int tmp = f[i];
        f[i] = f[index];
        f[index] = tmp;
    }
}
 
 
void DeckOfCards::printCards(vector<int> &r, int Face[], int Face1[])
{
    const char *combination[8] = {"Комбинации отсутствуют", "Пара", "Две пары", "Три", "Стрит", "Флеш", "Фулл-Хаус", "Каре" };
    
    //инициализировать массив мастей 
    const char *suit[4] = 
        { "Hearts", "Diamonds", "Clubs", "Spades" };
        
    //инициализировать массив номиналов
    const char *face[13] = 
        { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King" };
    cout << endl << "Первая комбинация " << combination[max1[0]] << ": ";
    for(int m1 = 0; m1 < 5; m1++)
    {
        cout << face[g1.Face[m1]] << ' ';
    }
    cout<< endl << endl << "Вторая Комбинация " << combination[max2[0]] << ": ";
    for(int m2 = 0; m2 < 5; m2++)
    {
        cout << face[g2.Face[m2]] <<  ' ';
    }
    cout << endl << endl;
    cout << setw(5) << "Выиграла комбинация: " << " < " << combination[r[0]] << " >" << ": ";
    if(combination[r[0]] == "Флеш")
    {
        for(int suitIndex = 1; suitIndex < r.size(); suitIndex++)
        {
            cout << suit[r[suitIndex]] << ' ';
        }
    }
    else
    {
        for(int faceIndex = 1; faceIndex < r.size(); faceIndex++)
        cout << face[r[faceIndex]] << ' ';
    }                             
    cout << endl;
    cout << "================================================================" << endl;
}

Добавлено через 42 секунды
fig08_13.cpp

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
//Рис. 8.27: Fig08_27.cpp
//Программа тасования и сдачи карт 
#include "DeckOfCards.h" //определение класса DeckOfCards 
using namespace std;
int main()
{
    DeckOfCards deckOfCards; //создать объект DeckOfCards 
    
    deckOfCards.shuffle(); //перетасовать карты колоды 
    deckOfCards.deal(); //сдать карты колоды
    return 0;
}

@Ferrari F1 · 31.07.2016, 21:19

Сообщение от Liss29

Я что один по этим Дейтелам изучаю, такое ощущение, что на форуме никого нет.

Liss29, я тоже Дейтелов читал, книжка во!

Но я ее про100 4итал, без выполнения упражнений, ибо мне хватило выполнения задач из ранее прочитанной книги Лафоре.

PS: после дейтелов идеальным вариантом будет прочтение липпмана, очень много нового по языку для себя узнаете

Новые блоги и статьи Все статьи Все блоги /
Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .	И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»	SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .
SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL3_image 8Observer8 10.02.2026 Содержание блога Библиотека SDL3_image содержит инструменты для расширенной работы с изображениями. Пошагово создадим проект для загрузки изображения формата PNG с альфа-каналом (с прозрачным. . .	Установка Qt-версии Lazarus IDE в Debian Trixie Xfce volvo 10.02.2026 В общем, достали меня глюки IDE Лазаруса, собранной с использованием набора виджетов Gtk2 (конкретно: если набирать текст в редакторе и вызвать подсказку через Ctrl+Space, то после закрытия окошка. . .	SDL3 для Web (WebAssembly): Работа со звуком через SDL3_mixer 8Observer8 08.02.2026 Содержание блога Пошагово создадим проект для загрузки звукового файла и воспроизведения звука с помощью библиотеки SDL3_mixer. Звук будет воспроизводиться по клику мышки по холсту на Desktop и по. . .

@_Ivana 4949 / 2289 / 287 Регистрация: 01.03.2013 Сообщений: 5,991 Записей в блоге: 32
	13.07.2016, 23:42
	Закатываешь Енум - перечень всех вариантов комбинаций - пара, две пары, тройка, ~~страйк~~ стрит, флеш и т.п. Пишешь функцию, по набору карт определяющую максимальную комбинацию (чтобы когда 4 туза выдавало каре тузов а не пару) - вектор комбинация + достоинство, например "пара троек и пара тузов". Пишешь функцию сравнения 2-х комбинаций - какая больше. И по этому компаратору находишь максимум из массива/списка/вектора/какого угодно контейнера. И потом проверка на единственность/неединственность максимальной комбинации среди всех игроков. Все. 0

@Liss29 225 / 39 / 4 Регистрация: 18.11.2012 Сообщений: 1,631
	16.07.2016, 05:47 [ТС]
	Я что один по этим Дейтелам изучаю, такое ощущение, что на форуме никого нет. 0

@_Ivana 4949 / 2289 / 287 Регистрация: 01.03.2013 Сообщений: 5,991 Записей в блоге: 32
	21.07.2016, 00:10
	Liss29, а зачем? Имхо, или вы в чистых сях - и тогда структуры, массивы и указатели, или в плюсах с STL - и тогда ссылки и всякие контейнеры и алгоритмы из библиотеки. 0

@shilko2013 257 / 234 / 185 Регистрация: 02.04.2016 Сообщений: 898
	26.07.2016, 18:32
	Liss29, Только вчера закончил Дейтейла. Там полностью весь код написан. Просто перепишите и все. 0

@shilko2013 257 / 234 / 185 Регистрация: 02.04.2016 Сообщений: 898
	27.07.2016, 09:45
	_Ivana, Мне не понравился учебник 0

@Liss29 225 / 39 / 4 Регистрация: 18.11.2012 Сообщений: 1,631
	29.07.2016, 23:08 [ТС]
	Добавлено через 18 часов 46 минут Не могу понять, что значит, чтобы программа исполняла роль сдающего, пока у меня только такая идея: сдать карты пять штук игроку, затем сдать ещё пять карт как бы в банк (откуда, при необходимости, игрок будет брать карты для замены своих карт). Как бы на этом полёт моей фантазии иссяк, как сравнивать, как выбрать карту, которую надо скинуть и заменить на карту из банка, чтобы комбинация стала более сильной, а может вообще не надо менять ничего. Получается надо брать первую карту и сравнивать с картами из банка, если есть совпадения, тогда меняем, и так сравнить все карты из сданных на руки игроку с теми что в банке. Что-то надо будет скинуть, я так понимаю, что скидывать будем самую маленькую, не имеющую комбинаций, карту. Вот всё что смог придумать, правда, этот вариант мне не кажется таким уж удачным. Карта кладутся лицом вниз, блин, но как это организовать, я не умею карты прорисовывать, может, просто знаки вопроса вывести, вместо номиналов карт... Оценить качество карт сдающего, мне это видится так, выясняем какая карта на руках, например, пара, две пары или отсутствие комбинации, и смотрим, например, если есть пара, то нужно как-то понять, есть ли в банке карты одного ранга с этой парой, чтобы сделать комбинацию три или каре, если нет, то проверяем на другую комбинацию, остальные три карты не имеющие отношения к паре,(кароль, кароль, восемь, пять, два\| Проверяем: восемь, пять два) мы сравниваем с картами из банка в надежде получить фулл-хаус, если совпадений нет, то ничего не меняем, а если есть, можно сделать из пары, комбинацию две пары... Нужна помощь, в этой задаче без неё, видимо, никак. 0