int try_all_perm_random_restart(int n, int restart_at, int stop_after) {
int curr_best = get_current_score(n, dbname);
int n1_score = get_current_score(n-1, dbname);
perm deck(n), best(n);
init_deck(deck);
shuffle_no_fix(deck);
int highest_count_so_far = 0;
int count = 0;
int iterations = 0;
// while (next_perm_swap1(deck)) {
//while (next_perm_rand_swap2(deck)) {
while (next_permutation(deck.begin(), deck.end())) {
//while (next_perm_seq_pair(deck)) {
//while (next_perm_all_pair(deck)) {
//while (next_perm_all_pair_rev(deck)) {
++iterations;
if (iterations >= stop_after) return highest_count_so_far;
++count;
if (deck[0] == 1) {
shuffle_no_fix(deck);
count = 0;
ping('1');
}
if (count >= restart_at) {
count = 0;
shuffle_no_fix(deck);
ping('.');
}
const int score = do_all_top_swops_copy(deck);
/*
// Heuristic cut-off: if the last number is home, then re-start if
// the previous perm's best score plus the current score is less
// than the highest score so far.
if (deck.back() == n && n1_score + score < highest_count_so_far) {
count = 0;
shuffle_no_fix(deck);
ping('c');
}
*/
if (score > highest_count_so_far) {
highest_count_so_far = score;
best = deck;
if (highest_count_so_far > curr_best) {
ping('!');
//int diff = highest_count_so_far - curr_best;
curr_best = highest_count_so_far;
set_current_perm(n, best, dbname);
}
}
}
// cout << best << " (n=" << n << ", optimal_count=" << highest_count_so_far
// << ")" << endl;
return highest_count_so_far;
}
void test_perm() {
vector<int> deck(4);
init_deck(deck);
while (next_permutation(deck.begin(), deck.end())) {
cout << deck << endl;
}
cout << "done\n";
}
JNIEXPORT void JNICALL Java_handevaluator_jni_JNIHandEvaluator_runOverhead(JNIEnv *env , jclass clazz, jint trials) {
init_random(trials);
deck_struct deck;
init_deck(&deck);
int i, j;
char cards[7];
for (i=0; i < trials; i++) {
reset_deck(&deck);
for (j=0; j < 7; j++) {
cards[j] = draw_random_card(&deck);
}
}
}
void main(){
stats s;
s.plys_in_game = 6;
s.bigblind = 20;
s.cards_on_table = 0;
init_players(&s);
init_window(&s);
while(1){
init_deck(dec);
s.cards_on_table = 0;
game(&s);
}
}
int main() {
std::vector<int> deck, dealtCards;
init_deck(deck);
std::chrono::high_resolution_clock::time_point t1 = std::chrono::high_resolution_clock::now();
for (int n = 0; n < 50; ++n) {
dealtCards = deal(deck, PREFLOP);
std::cout << "######## New Deal #######" << std::endl;
for (auto i = dealtCards.begin(); i != dealtCards.end(); ++i) {
std::cout << hexToCard(*i) << std::endl;
}
}
std::chrono::high_resolution_clock::time_point t2 = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();
std::cout << duration << std::endl;
return 0;
}
main()
{
int deck[52], hand[5], freq[10];
int a, b, c, d, e, i, j;
// seed the random number generator
srand48( getpid() );
// initialize the deck
init_deck( deck );
// zero out the frequency array
for ( i = 0; i < 10; i++ )
freq[i] = 0;
// loop over every possible five-card hand
for(a=0;a<48;a++)
{
hand[0] = deck[a];
for(b=a+1;b<49;b++)
{
hand[1] = deck[b];
for(c=b+1;c<50;c++)
{
hand[2] = deck[c];
for(d=c+1;d<51;d++)
{
hand[3] = deck[d];
for(e=d+1;e<52;e++)
{
hand[4] = deck[e];
i = eval_5hand( hand );
j = hand_rank(i);
freq[j]++;
}
}
}
}
}
for(i=1;i<=9;i++)
printf( "%15s: %8d\n", value_str[i], freq[i] );
}
void setup(){
init_deck();
shuffle();
dealer[0] = top();
dealer[1] = top();
dnumcards = 2;
dnum = dealer[0]->value + dealer[1]->value;
player[0] = top();
player[1] = top();
pnumcards = 2;
pnum = player[0]->value + player[1]->value;
send_msg("msg", client_sock);
sprintf(String, "Dealer: X %s\n", dealer[1]->rep);
send_msg(String, client_sock);
send_msg("msg", client_sock);
sprintf(String, "Player: %s %s\n", player[0]->rep, player[1]->rep);
send_msg(String, client_sock);
}
int main()
{
struct board_t boardd;
int player = 0;
init_board(&boardd);
init_deck(&boardd.Player[player].deck);
card_generator( &boardd, player);
//deck_from_file(&boardd, "ggop.txt", player);
init_player(&boardd.Player[player]);
init_manapool(&boardd.Player[player].manapool);
init_deck(&boardd.Player[player + 1].deck);
//card_generator( *boardd, player + 1);
deck_from_file(&boardd, "ggopme.txt", player + 1);
init_player(&boardd.Player[player +1]);
init_manapool(&boardd.Player[player + 1].manapool);
int i;
for(i = 0; i < 5; i++){
turn_begin( &boardd.Player[player]);
turn_begin( &boardd.Player[player + 1]);
}
int card;
int board_num = 0;
int board_num2 = 0;
int choice;
player++;
do{
if ( bot(&boardd,&board_num2) == 1 ) board_num2++;
PrintBoard(boardd);
scanf("%d",&choice);
if (choice > 0 && choice <= 5 ){
card = choice - 1;
if (play_card(&boardd, player, card, board_num) == 1 ) {
boardd.Card_Positions[board_num][player] = 0;
board_num++;
boardd.Player[player].manapool.left -= boardd.Player[player].cards_in_hand[card].magic_cost;
/*struct card_t card_to_use;
draw_card(&boardd.Player[player].deck, &card_to_use);
boardd.Player[player].cards_in_hand[card] = card_to_use;*/
}
}
PrintBoard(boardd);
turn_end(&boardd, player, &board_num, &board_num2);
PrintBoard(boardd);
char a; scanf("%s",&a);
//system("cls");
printf("\033[2J\033[1;1H");
if(board_num >= 5) board_num = 0;
if(board_num2 >= 5) board_num2 = 0;
}while(boardd.Player[player].health > 0 && boardd.Player[1 - player].health > 0);
if(boardd.Player[player].health > 0) printf("Ti pechelish ;) \n");
else printf("Ti gubish\n");
return 0;
}
int main() {
Game *game = init_game();
char username[50];
Deck *deck = init_deck();
Strategy *strategy;
int exchange[] = {1,2,4,5,0};
int i;
Player *playerptr;
strategy = init_strategy(4, &exchange[0]);
printf("\n\nWelcome to Five-Card Draw!\n\n\nPlease enter your name: ");
scanf("%s",username);
/*add players to game*/
/*add live user first*/
game_insert_player(game, NULL, username, HUMAN);
/*add three CPU players*/
game_insert_player(game, game->head->prev, "Dennis Ritchie", CPU);
game_insert_player(game, game->head->prev, "Brian Kernighan", CPU);
game_insert_player(game, game->head->prev, "Kyle Loudon", CPU);
printf("\n\nWelcome, %s. You will begin with $%.2f in chips.\n\n",game->human->name, game->human->chips);
/*human player is dealer in the first game. dealer designation rotates afterward*/
set_dealer(game, game->human);
while (game->continue_game) {
/*
player may quit by pressing CTRL+C at any time and will be given the option to continue after the game
has been settled. if the player does not have enough in chips remaining to pay the ante, s/he will be
removed from the table.
*/
/*announce dealer*/
if(game->dealer->type == HUMAN)
printf("You are the dealer.\n\n");
else
printf("%s is the dealer.\n\n", game->dealer->name);
/*players ante*/
playerptr = game->dealer->next;
for (i = 0; i < NUMPLAYERS; ++i) {
make_bet(game, playerptr, (float) ANTE);
playerptr = playerptr->next;
}
/*deal cards*/
shuffle_deck(deck, NUMCARDS, NULL, 0);
printf("Dealing...\n\n");
deal_game(deck, game);
/*bet_round(game);*/
/*if (game->folded < 4) {*/
exchange_round(game, deck);
/*} else {
printf("Just one player remains.\n");
settle_game(game);
}
bet_round(game);
*/
settle_game(game);
}
printf("Thanks for playing!\n\n\n");
return 0;
}
int main (int argc, char *argv[]) {
Card deck[DECK_SIZE];
Card starting_deck[DECK_SIZE];
char in_message[MAX_MESSAGE_LENGTH];
char out_message[MAX_MESSAGE_LENGTH];
int mode = 0; //encrypt = 0, decrypt = 1
if (argc != 1) {
printf("usage: SolitareEncryption1\n");
printf("SEKEY environment variable must be set to the key value\n");
exit(1);
}
init_deck(starting_deck);
while (1) {
//set the deck to the key starting position
memcpy(deck, starting_deck, sizeof(Card) * DECK_SIZE);
print_deck(deck);
if (!mode) {
printf("Enter message to be encrypted (type '/help' for help):\n");
} else {
printf("Enter message to be decrypted (type '/help' for help):\n");
}
fflush(stdout);
if (fgets(in_message, MAX_MESSAGE_LENGTH, stdin) == NULL) {
printf("fgets failure\n");
exit(1);
}
//get rid of the newline from fgets
int i;
for (i = 0; in_message[i] != '\0'; i++) {
if (in_message[i] == '\n') {
in_message[i] = '\0';
break;
}
}
if (!strcmp(in_message, "/quit")) {
break;
} else if (!strcmp(in_message, "/encrypt")) {
mode = 0;
printf("Encryption mode\n");
} else if (!strcmp(in_message, "/decrypt")) {
mode = 1;
printf("Decryption mode\n");
} else if (!strcmp(in_message, "/help")) {
printf("/encrypt: switch to encryption mode\n"
"/decrypt: switch to decryption mode\n"
"/quit: quit program\n");
} else {
if (!mode) {
printf("Unencrypted: %s\n", in_message);
printf("Encrypted: %s\n",
encrypt(deck, in_message, out_message));
} else {
printf("Encrypted: %s\n", in_message);
printf("Decrypted: %s\n",
decrypt(deck, in_message, out_message));
}
}
}
return 0;
}
int main () {
srand(time(NULL));
board_t *board = NULL;
/*int finished = 0;
char blank[255];
while(!finished)
{
write(1,"\E[H\E[2J",7);
print_menu();
int option = validate_input(1, 4);
switch(option)
{
case 1: */
board = (board_t*)malloc(sizeof(board_t));
init_deck(&board->p[P_ONE].deck);
load_deck(&board->p[P_ONE].deck, "player_deck.csv");
switch(shuffleChoice()){
case 1:{
if(RandomShuffling(&(board->p[P_ONE].deck))){
file_save(&(board->p[P_ONE].deck));
//printf("ns\n");
}
break;
}
case 2:{
if(manaOrder(&(board->p[P_ONE].deck))){
file_save(&(board->p[P_ONE].deck));
}
break;
}
case 3:{
if(lifeOrder(&(board->p[P_ONE].deck))){
file_save(&(board->p[P_ONE].deck));
}
break;
}
case 4:{
if(attackOrder(&(board->p[P_ONE].deck))){
file_save(&(board->p[P_ONE].deck));
}
break;
}
case 5:{
if(costattackOrder(&(board->p[P_ONE].deck))){
file_save(&(board->p[P_ONE].deck));
}
break;
}
}
//printf("ns\n");
//printf("ls\n");
init_deck(&board->p[P_TWO].deck);
load_deck(&board->p[P_TWO].deck, "enemy_deck.csv");
//printf("ns\n");
//printf("ls\n");
// the board inits the player and the player needs a deck
/*board_init(board);
printf("ls\n");
if(rand() % 2 == 0)
{
printf("The enemy goes first!\n");
sleep(2);
write(1,"\E[H\E[2J",7);
turn_begin(&board->p[P_TWO]);
print_field(*board);
sleep(1);
write(1,"\E[H\E[2J",7);
enemy_AI(board);
write(1,"\E[H\E[2J",7);
print_field(*board);
sleep(1);
printf("\nEnemy's turn is over!\n");
//--board.p[P_TWO].manapool.max_mana; // the turn_begin function
//--board.p[P_TWO].manapool.current_mana; // increments these
}
else
{
printf("The player goes first!\n");
sleep(2);
}
write(1,"\E[H\E[2J",7);
int i;
while(1)
{
turn_begin(&board->p[P_ONE]);
turn_begin(&board->p[P_TWO]);
print_field(*board);
printf("\nGo, go, go!! :)\n");
if(turn(board))
{
break;
}
write(1,"\E[H\E[2J",7);
print_field(*board);
sleep(1);
printf("\nPlayer's turn is over!\n");
sleep(2);
enemy_AI(board);
write(1,"\E[H\E[2J",7);
print_field(*board);
sleep(1);
printf("\nEnemy's turn is over!\n");
sleep(2);
turn_attacks(board);
printf("End-of-turn attacks!\n");
if(is_player_dead(board->p[P_ONE]))
{
printf("Game over! \nThe player is dead!\n");
break;
}
if(is_player_dead(board->p[P_TWO]))
{
printf("Game over! \nThe enemy is dead!\n");
break;
}
sleep(2);
write(1,"\E[H\E[2J",7);
}
free(board);
break;
case 2:
write(1,"\E[H\E[2J",7);
read_file("instructions.txt");
printf("\n\nEnter anything to go back to the main menu.\n");
scanf("%s", blank);
break;
case 3:
write(1,"\E[H\E[2J",7);
read_file("about.txt");
printf("\nEnter anything to go back to the main menu.\n");
scanf("%s", blank);
break;
case 4:
printf("Thank you for using this software! Please call us to get your free Awesome Person certificate!\n");
finished = 1;
break;
}
}*/
return 0;
}
int main()
{
//struct card_t card_to_push;
struct card_t one = { "card_one", 1, 7, 3 };
struct card_t two = { "card_two", 3, 7, 10 };
struct card_t three = { "card_three", 3, 2, 5 };
struct card_t four = { "card_four", 1, 2, 2 };
struct card_t five = { "card_five", 3, 2, 4 };
struct card_t six = { "card_six", 5, 4, 1 };
struct card_t seven = { "card_seven", 6, 2, 4 };
struct card_t eight = { "card_eight", 1, 7, 2 };
struct card_t nine = { "card_nine", 3, 7, 1 };
struct card_t ten = { "card_ten", 3, 2, 2 };
struct card_t eleven = { "card_eleven", 1, 2, 2 };
struct card_t twelve = { "card_twelve", 3, 2, 4 };
struct card_t thirteen = { "card_thirteen", 5, 4, 2 };
struct card_t fourteen = { "card_fourteen", 2, 2, 1 };
struct card_t one_special = { "special_card_one", -1, 0, 1};// +5 life
struct card_t two_special = { "special_card_two", -2, 0, 1};// *2 card_power and +5 card_life
struct card_t three_special = { "special_card_three", -3, 0, 5};// +1 mana
struct card_t shaman = {"shaman", 4, 5, 2};
struct card_t grivna = {"grivna", 6, 3, 3};
struct card_t kolelo = {"kolelo", 5, 2, 2};
//printf("%d\n", attack(&one, &two));
//---------------------------------------------------------------
//struct deck_t player_deck;
//struct player_t player;
struct player_t first_player;
struct player_t second_player;
struct deck_t first_player_deck;
struct deck_t second_player_deck;
first_player.name_player = "TGS";
second_player.name_player = "Baba Gusi";
init_deck(&first_player_deck);
init_deck(&second_player_deck);
push_card(one, &first_player_deck);
push_card(two, &first_player_deck);
push_card(three, &first_player_deck);
push_card(four, &first_player_deck);
push_card(five, &first_player_deck);
push_card(six, &first_player_deck);
push_card(seven, &first_player_deck);
push_card(eight, &first_player_deck);
push_card(nine, &first_player_deck);
push_card(ten, &first_player_deck);
push_card(eleven, &second_player_deck);
push_card(twelve, &second_player_deck);
push_card(thirteen, &second_player_deck);
push_card(fourteen, &second_player_deck);
push_card(one_special, &second_player_deck);
push_card(two_special, &second_player_deck);
push_card(three_special, &second_player_deck);
push_card(shaman, &second_player_deck);
push_card(grivna, &second_player_deck);
push_card(kolelo, &second_player_deck);
print_stack(first_player_deck);
print_stack(second_player_deck);
Null_player_hand(&first_player);
Null_player_hand(&second_player);
init_player(&first_player_deck, &first_player);
init_player(&second_player_deck, &second_player);
down_hp(&second_player,5);
up_hp(&second_player,2);
turn_begin(&first_player_deck, &first_player);
turn_begin(&second_player_deck, &second_player);
printf("\n--------------------------------------------------------");
printf("\nTGS hand:\n");
print_cards_in_hand(&first_player);
printf("\n--------------------------------------------------------");
printf("\nBaba Gusi hand:\n");
print_cards_in_hand(&second_player);
//play_card_from_hand(&player, "card_four");
struct board_t board;
init_board(&board);
turn_end(&board, &first_player, 0);
turn_end(&board, &second_player, 1);
turn_end(&board, &first_player, 0);
turn_end(&board, &second_player, 1);
turn_end(&board, &first_player, 0);
turn_end(&board, &second_player, 1);
turn_end(&board, &first_player, 0);
turn_end(&board, &second_player, 1);
turn_end(&board, &first_player, 0);
turn_end(&board, &second_player, 1);
turn_end(&board, &first_player, 0);
can_play_card(&board, &first_player, 0, six, 3);// players 0 or 1
play_card(&board, &first_player, 0, six, 3);// players 0 or 1
can_play_card(&board, &second_player, 1, grivna, 3);// players 0 or 1
play_card(&board, &second_player, 1, grivna, 3);// players 0 or 1
print_board(board, first_player, second_player, 1);
printf("\n--------------------------------------------------------\n");
turn_begin(&first_player_deck, &first_player);
turn_begin(&second_player_deck, &second_player);
play_card(&board, &first_player, 0, seven, 2);// players 0 or 1
play_card(&board, &second_player, 1, two_special, 3);// players 0 or 1
print_board(board, first_player, second_player, 3);
printf("\n--------------------------------------------------------\n");
turn_begin(&first_player_deck, &first_player);
turn_begin(&second_player_deck, &second_player);
play_card(&board, &first_player, 0, eight, 1);// players 0 or 1
play_card(&board, &second_player, 1, shaman, 1);// players 0 or 1
print_board(board, first_player, second_player, 5);
printf("\n--------------------------------------------------------\n");
winner(first_player, second_player);
printf("\n--------------------------------------------------------\n");
/*
//---------------------------------------------------------------
// manapool
struct manapool_t pool;
init_mana(&pool);
print_manapool(&pool);
push_mana(&pool);//2 mana
push_mana(&pool);//3 mana
push_mana(&pool);//4 mana
push_mana(&pool);//5 mana
push_mana(&pool);//6 mana
printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(one, &pool));
take_mana(one, &pool);//1 mana
push_mana(&pool);//7 mana
printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(two, &pool));
take_mana(two, &pool);//3 mana
push_mana(&pool);//8 mana
push_mana(&pool);//9 mana
push_mana(&pool);//10 mana
push_mana(&pool);//10 mana
printf("\nCan we put card?(yes-1, no-0): %d\n", can_put_card(two, &pool));
take_mana(three, &pool);//6 mana
push_mana(&pool);//=> 10 mana
//---------------------------------------------------------------
// board
//---------------------------------------------------------------
*/
return 0;
}
int main(int argc, char *argv[]){
char *ep;
u_long temp, trials;
struct state *gp;
struct state game;
/* structures to hold the stats */
struct stats b_before;
struct stats b_after;
struct stats b_both;
struct stats m_card, m_dice;
struct stats game_stats;
struct card deck[DECKS*CARDS*SUITS];
int i;
int card_index = 0;
float outcome;
int die_total;
gp = &game;
if (argc != 2)
usage();
temp = strtoul(argv[1], &ep, 10);
if (*argv[1] == '\0'|| *ep != '\0'){
fprintf(stderr, "%s - not a number\n", argv[1]);
usage();
}
if (argv[1][0] == '-'){
fprintf(stderr, "%s - no negative numbers\n", argv[1]);
usage();
}
if (( errno == ERANGE && temp == ULONG_MAX ) && (temp > 1)){
fprintf(stderr, "%s - value out of range\n", argv[1]);
usage();
}
trials = temp;
/* seed the random number generator */
srand(time(NULL));
/* initialize the deck */
init_deck(deck);
/* shuffle the cards */
shuffle(deck);
/* initialize the statistics structs */
init_stats(&b_before);
init_stats(&b_after);
init_stats(&b_both);
init_stats(&m_card);
init_stats(&m_dice);
init_stats(&game_stats);
/* run the simulations */
for (i = 0 ; i < trials ; i++){
/* initialize the game */
game.die_1 = rand()%6 + 1;
game.die_2 = rand()%6 + 1;
die_total = game.die_1 + game.die_2;
game.before_card = deck[card_index];
game.after_card = deck[card_index+1];
card_index+=2;
/* beat before */
if (die_total == 12)
outcome = 4.0;
else if ( die_total > game.before_card.value )
outcome = 1.0;
else if ( die_total < game.before_card.value )
outcome = -1.0;
else
outcome = 0.0;
inc_update_stats(&b_before, outcome, i+1);
inc_update_stats(&game_stats, outcome, i+1);
/* beat after */
if (die_total == 12)
outcome = 4.0;
else if ( die_total > game.after_card.value )
outcome = 1.0;
else if ( die_total < game.after_card.value )
outcome = -1.0;
else
outcome = 0.0;
inc_update_stats(&b_after, outcome, i+1);
inc_update_stats(&game_stats, outcome, i+1);
/* beat both */
if (die_total == 12)
outcome = 6.0;
else if ( (die_total > game.after_card.value) &&
(die_total > game.before_card.value) )
outcome = 3.0;
else if ( (die_total == game.after_card.value) &&
(die_total == game.before_card.value))
outcome = 0.0;
else
outcome = -1.0;
inc_update_stats(&b_both, outcome, i+1);
inc_update_stats(&game_stats, outcome, i+1);
/* match card */
outcome = match_card(gp);
inc_update_stats(&m_card, outcome, i+1);
inc_update_stats(&game_stats, outcome, i+1);
/* match dice */
outcome = match_dice(gp);
inc_update_stats(&m_dice, outcome, i+1);
inc_update_stats(&game_stats, outcome, i+1);
if(card_index > (DECKS*SUITS*CARDS - 52)){
card_index = 0;
shuffle(deck);
}
}
/* finalize the standard deviations */
b_before.stddev = sqrt(b_before.stddev/(trials-1));
b_after.stddev = sqrt(b_after.stddev/(trials-1));
b_both.stddev = sqrt(b_both.stddev/(trials-1));
m_card.stddev = sqrt(m_card.stddev/(trials-1));
m_dice.stddev = sqrt(m_dice.stddev/(trials-1));
game_stats.stddev = sqrt(game_stats.stddev/(trials-1));
/* Print the statistics of the each game's square */
printf("Beat Before:\n");
print_stats(&b_before);
printf("Beat After:\n");
print_stats(&b_after);
printf("Beat Both:\n");
print_stats(&b_both);
printf("Match Card:\n");
print_stats(&m_card);
printf("Match Dice:\n");
print_stats(&m_dice);
/* Print the game's overall EV */
printf("Game Statistics:\n");
print_stats(&game_stats);
return 0;
}
int main() {
int i;
double start_time;
card_t high_card1[5]; /* now we're going to generate several hands and test the ranking stuff */
card_t high_card2[5];
card_t one_pair1[5];
card_t one_pair2[5];
card_t two_pair1[5];
card_t two_pair2[5];
card_t three_kind1[5];
card_t three_kind2[5];
card_t straight1[5];
card_t straight2[5];
card_t flush1[5];
card_t flush2[5];
card_t full_house1[5];
card_t full_house2[5];
card_t four_kind1[5];
card_t four_kind2[5];
card_t straight_flush1[5];
card_t straight_flush2[5];
card_t royal_flush1[5];
card_t royal_flush2[5];
card_t deck[52];
init_deck(deck);
/* construct high card */
high_card1[0] = deck[26]; /* Ace of Hearts */
high_card1[1] = deck[5]; /* 6 of Clubs */
high_card1[2] = deck[28]; /* 3 of Hearts */
high_card1[3] = deck[19]; /* 7 of Diamonds */
high_card1[4] = deck[48]; /* 10 of Spades */
high_card2[0] = deck[9]; /* 10 of Clubs */
high_card2[1] = deck[20]; /* 8 of Diamonds */
high_card2[2] = deck[18]; /* 6 of Diamonds */
high_card2[3] = deck[16]; /* 4 of Diamonds */
high_card2[4] = deck[40]; /* 2 of Spades */
/* one pair */
one_pair1[0] = deck[43]; /* 5 of Spades */
one_pair1[1] = deck[30]; /* 5 of Hearts */
one_pair1[2] = deck[14]; /* 2 of Diamonds */
one_pair1[3] = deck[6]; /* 7 of Clubs */
one_pair1[4] = deck[3]; /* 4 of Clubs */
one_pair2[0] = deck[43]; /* 5 of Spades */
one_pair2[1] = deck[4]; /* 5 of Clubs */
one_pair2[2] = deck[21]; /* 9 of Diamonds */
one_pair2[3] = deck[44]; /* 6 of Spades */
one_pair2[4] = deck[33]; /* 8 of Hearts */
/* two pair */
two_pair1[0] = deck[26]; /* Ace of Hearts */
two_pair1[1] = deck[0]; /* Ace of Clubs */
two_pair1[2] = deck[20]; /* 8 of Diamonds */
two_pair1[3] = deck[46]; /* 8 of Spades */
two_pair1[4] = deck[28]; /* 3 of Hearts */
two_pair2[0] = deck[9]; /* 10 of Clubs */
two_pair2[1] = deck[22]; /* 10 of Diamonds */
two_pair2[2] = deck[14]; /* 2 of Diamonds */
two_pair2[3] = deck[40]; /* 2 of Spades */
two_pair2[4] = deck[46]; /* 8 of Spades */
/* three of a kind */
three_kind1[0] = deck[26]; /* Ace of Hearts */
three_kind1[1] = deck[0]; /* Ace of Clubs */
three_kind1[2] = deck[39]; /* Ace of Spades */
three_kind1[3] = deck[19]; /* 7 of Diamonds */
three_kind1[4] = deck[50]; /* Queen of Spades */
three_kind2[0] = deck[21]; /* 9 of Diamonds */
three_kind2[1] = deck[47]; /* 9 of Spades */
three_kind2[2] = deck[8]; /* 9 of Clubs */
three_kind2[3] = deck[6]; /* 7 of Clubs */
three_kind2[4] = deck[13]; /* Ace of Diamonds */
/* straight */
straight1[0] = deck[43]; /* 5 of Spades */
straight1[1] = deck[5]; /* 6 of Clubs */
straight1[2] = deck[32]; /* 7 of Hearts */
straight1[3] = deck[7]; /* 8 of Clubs */
straight1[4] = deck[21]; /* 9 of Diamonds */
straight2[0] = deck[40]; /* 2 of Spades */
straight2[1] = deck[2]; /* 3 of Clubs */
straight2[2] = deck[29]; /* 4 of Hearts */
straight2[3] = deck[43]; /* 5 of Spades */
straight2[4] = deck[31]; /* 6 of Hearts */
/* flush */
flush1[0] = deck[14]; /* 2 of Diamonds */
flush1[1] = deck[20]; /* 8 of Diamonds */
flush1[2] = deck[17]; /* 5 of Diamonds */
flush1[3] = deck[13]; /* Ace of Diamonds */
flush1[4] = deck[18]; /* 6 of Diamonds */
flush2[0] = deck[14]; /* 2 of Diamonds */
flush2[1] = deck[16]; /* 4 of Diamonds */
flush2[2] = deck[18]; /* 6 of Diamonds */
flush2[3] = deck[21]; /* 9 of Diamonds */
flush2[4] = deck[22]; /* 10 of Diamonds */
/* full house */
full_house1[0] = deck[19]; /* 7 of Diamonds */
full_house1[1] = deck[45]; /* 7 of Spades */
full_house1[2] = deck[6]; /* 7 of Clubs */
full_house1[3] = deck[1]; /* 2 of Clubs */
full_house1[4] = deck[27]; /* 2 of Hearts */
full_house2[0] = deck[22]; /* 10 of Diamonds */
full_house2[1] = deck[9]; /* 10 of Clubs */
full_house2[2] = deck[35]; /* 10 of Hearts */
full_house2[3] = deck[6]; /* 7 of Clubs */
full_house2[4] = deck[19]; /* 7 of Diamonds */
/* four of a kind */
four_kind1[0] = deck[24]; /* Queen of Diamonds */
four_kind1[1] = deck[37]; /* Queen of Hearts */
four_kind1[2] = deck[50]; /* Queen of Spades */
four_kind1[3] = deck[11]; /* Queen of Clubs */
four_kind1[4] = deck[43]; /* 5 of Spades */
four_kind2[0] = deck[21]; /* 9 of Diamonds */
four_kind2[1] = deck[34]; /* 9 of Hearts */
four_kind2[2] = deck[47]; /* 9 of Spades */
four_kind2[3] = deck[8]; /* 9 of Clubs */
four_kind2[4] = deck[19]; /* 7 of Diamonds */
/* straight flush */
straight_flush1[0] = deck[43]; /* 5 of Spades */
straight_flush1[1] = deck[44]; /* 6 of Spades */
straight_flush1[2] = deck[45]; /* 7 of Spades */
straight_flush1[3] = deck[46]; /* 8 of Spades */
straight_flush1[4] = deck[47]; /* 9 of Spades */
straight_flush2[0] = deck[5]; /* 6 of Clubs */
straight_flush2[1] = deck[6]; /* 7 of Clubs */
straight_flush2[2] = deck[7]; /* 8 of Clubs */
straight_flush2[3] = deck[8]; /* 9 of Clubs */
straight_flush2[4] = deck[9]; /* 10 of Clubs */
/* royal flush */
royal_flush1[0] = deck[35]; /* 10 of Hearts */
royal_flush1[1] = deck[36]; /* Jack of Hearts */
royal_flush1[2] = deck[37]; /* Queen of Hearts */
royal_flush1[3] = deck[38]; /* King of Hearts */
royal_flush1[4] = deck[26]; /* Ace of Hearts */
royal_flush2[0] = deck[9]; /* 10 of Clubs */
royal_flush2[1] = deck[10]; /* Jack of Clubs */
royal_flush2[2] = deck[11]; /* Queen of Clubs */
royal_flush2[3] = deck[12]; /* King of Clubs */
royal_flush2[4] = deck[0]; /* Ace of Clubs */
/* print each of the above hands and pass them to rank_hand()
* A star is printed next to the one that's greater, or both if they're equal */
printf("1: ");
print_hand(high_card1);
if (handcmp(high_card1, high_card2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(high_card2);
if (handcmp(high_card2, high_card1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(one_pair1);
if (handcmp(one_pair1, one_pair2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(one_pair2);
if (handcmp(one_pair2, one_pair1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(two_pair1);
if (handcmp(two_pair1, two_pair2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(two_pair2);
if (handcmp(two_pair2, two_pair1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(three_kind1);
if (handcmp(three_kind1, three_kind2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(three_kind2);
if (handcmp(three_kind2, three_kind1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(straight1);
if (handcmp(straight1, straight2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(straight2);
if (handcmp(straight2, straight1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(flush1);
if (handcmp(flush1, flush2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(flush2);
if (handcmp(flush2, flush1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(full_house1);
if (handcmp(full_house1, full_house2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(full_house2);
if (handcmp(full_house2, full_house1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(four_kind1);
if (handcmp(four_kind1, four_kind2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(four_kind2);
if (handcmp(four_kind2, four_kind1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(straight_flush1);
if (handcmp(straight_flush1, straight_flush2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(straight_flush2);
if (handcmp(straight_flush2, straight_flush1) > -1)
printf(" *");
puts("");
puts("-----");
printf("1: ");
print_hand(royal_flush1);
if (handcmp(royal_flush1, royal_flush2) > -1)
printf(" *");
puts("");
printf("2: ");
print_hand(royal_flush2);
if (handcmp(royal_flush2, royal_flush1) > -1)
printf(" *");
puts("");
/* testing comparations using simple ranks */
printf("\n Royal Flush ");
if (handcmp(royal_flush1, high_card1) > -1)
putchar('>');
else
putchar('<');
puts(" High Card");
printf(" One Pair ");
if (handcmp(one_pair1, straight_flush1) > -1)
putchar('>');
else
putchar('<');
puts(" Straight Flush");
printf(" Four of a Kind ");
if (handcmp(four_kind1, two_pair1) > -1)
putchar('>');
else
putchar('<');
puts(" Two Pair");
printf("Three of a Kind ");
if (handcmp(three_kind1, full_house1) > -1)
putchar('>');
else
putchar('<');
puts(" Full House");
printf(" Flush ");
if (handcmp(flush1, straight1) > -1)
putchar('>');
else
putchar('<');
puts(" Straight");
/* and now, benchmarking! */
start_time = get_time();
for (i = 0; i < 5000000; i++) {
rank_hand(royal_flush1);
}
printf("\nProcessed 5,000,000 Royal Flushes in %f\n", get_time() - start_time);
start_time = get_time();
for (i = 0; i < 5000000; i++) {
handcmp(one_pair1, one_pair2);
}
printf("Compared 5,000,000 sets of One Pair in %f\n", get_time() - start_time);
return 0;
}