Randomize (перетасовка) многомерного массива в другой массив 2D

Question

// deck of cards 
// below are initializations 
#include <iostream> 
#include <fstream> 
#include <ctime> 

using namespace std; 

int main() 
{ 
ofstream myfile; //setup for copy to text file 
const char usdeck[4][13][14] = //create 3d array of 52 cards 
{ 
{"heart two", "heart three", "heart four", 
"heart five", "heart six", "heart seven", 
"heart eight","heart nine", "heart ten", 
"heart jack","heart queen", "heart king", 
"heart ace"}, 
{"diamond two", "diamond three", "diamond four", 
"diamond five", "diamond six", "diamond seven", 
"diamond eight", "diamond nine", "diamond ten", 
"diamond jack", "diamond queen", "diamond king", 
"diamond ace"}, 
{"club two", "club three", "club four", "club five", 
"club six", "club seven", "club eight", "club nine", 
"club ten", "club jack", "club queen", "club king", 
"club ace"}, 
{"spade two", "spade three", "spade four", 
"spade five", "spade six", "spade seven", 
"spade eight", "spade nine", "spade ten", 
"spade jack", "spade queen", "spade king", 
"spade ace"} 
}; 

for(int row=0;row<4; row++) 
{ 
for(int column=0;column<13;column++) 
    { 
    for(int element=0;element<14;element++) 
     { 
    cout << usdeck[row][column][element] << " "; 
     } 
    cout <<endl; 
} 
} 

myfile.open("UnshuffledDeck.txt");//creates a text file to place unshuffled deck into 
for(int row=0;row<4; row++) 
{ 
for(int column=0;column<13;column++) 
    { 
    for(int element=0;element<14;element++) 
     { 
    myfile << usdeck[row][column][element] << " "; 
//this creates the unshuffled deck text file 
     } 
    myfile <<endl; 
} 
} 
myfile.close(); //closes unshuffled deck text file 




return 0; 

} 

void Shuffle() 
{ 
int temp; 
char theDeck[4][13]; 
srand(time(0)); 

for (int i=0; i<=51; i++) 
{ 

int j = 1 + rand()%52; 
int k = 1 + rand()%52; 

temp = theDeck[j]; 
theDeck[j]=theDeck[k]; 
theDeck[k]=temp; 
} 
} 

Я пытаюсь перетасовать карты в моей колоде .. я написал ниже функции Перемешать, которые я считаю, будет тасовать колоду карт, но я не уверен, о том, как для его реализации. Моя «перетасованная» колода должна быть реализована в 2D-массиве .. пожалуйста, помогите!

Answer 1

Я бы порекомендовал использовать вашу обычную процедуру для использования Knuth Shuffle. Кунт-тасование требует только 52 свопов для колоды с 52 карточками.

Переплет Knuth можно обобщить на несколько измерений. Однако проще перемешать и использовать его, как если бы это был массив 1D, но получить доступ к нему, если это был трехмерный массив.

Википедии есть очень простой код Псевдо вы могли бы использовать для его реализации:

http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm

Если вам нужна помощь в обучении, как лечить 1D массив, как если бы это был 3D массив, искать какой-то материал на Роу-майором упорядоченности: https://courses.engr.illinois.edu/ece390/books/artofasm/CH05/CH05-2.html#HEADING2-105

Answer 2

вы можете сделать вашу жизнь намного проще, если вы:

1. Использование целое число от 0 - 51 для представления карты.
2. Предоставлено 0 <= N <= 51, вы можете рассматривать N/13 как набор карт и N%13 как лицо карты.
3. Вы можете представить строковые версии наборов и граней, используя статические массивы, и получить имя пакета и имя лица карты, индексируя эти статические массивы.
4. Вы можете начать с упорядоченной колоды, а затем перетасовать их столько раз, сколько хотите, используя std::shuffle.

Вот программа, которая делает это.

#include <cassert> 
#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <random> 
#include <chrono> 

// Represent cards by numbers 0 - 51. 
// Given 0 <= N <= 51, 
// suite = N/13 
// face = N%13. 

std::string const& getSuiteName(unsigned int index) 
{ 
    static std::string suites[4] = {"Club", "Diamond", "Heart", "Spade"}; 
    assert(index < 4); 
    return suites[index]; 
} 

std::string const& getFaceName(unsigned int index) 
{ 
    static std::string cards[13] = 
    { 
     "Two", "Three", "Four", "Five", 
     "Six", "Seven", "Eight", "Nine", 
     "Ten", "Jack", "Queen", "King", "Ace" 
    }; 
    assert(index < 13); 
    return cards[index]; 
} 

unsigned int getSuiteIndex(unsigned int card) 
{ 
    return card/13; 
} 

unsigned int getFaceIndex(unsigned int card) 
{ 
    return card%13; 
} 

void printCards(std::vector<unsigned int> const& cards) 
{ 
    std::cout << "---------------\n"; 
    for(auto card : cards) 
    { 
     std::cout 
     << getSuiteName(getSuiteIndex(card)) << " " 
     << getFaceName(getFaceIndex(card)) << std::endl; 
    } 
    std::cout << "---------------\n\n"; 
} 

void shuffleCards(std::vector<unsigned int>& cards) 
{ 
    // obtain a time-based seed: 
    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count(); 

    // Shuffle the deck. 
    std::shuffle(cards.begin(), cards.end(), std::default_random_engine(seed)); 
} 

void testShuffle() 
{ 
    std::vector<unsigned int> cards; 
    for (unsigned int i = 0; i < 52; ++i) 
    { 
     cards.push_back(i); 
    } 

    printCards(cards); 

    shuffleCards(cards); 
    printCards(cards); 

    shuffleCards(cards); 
    printCards(cards); 
} 

int main() 
{ 
    testShuffle(); 
    return 0; 
}