Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - problema esercizio sul poker
Forum - C/C++ - problema esercizio sul poker

Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 1:00
Giovedì, 01/01/1970
salve, sto cercando di svolgere un' esercizio abbastanza complesso del manuale C Deitel, l'esercizio chiede di modificare un programma mostrato negli esempi, esso dovrebbe estrarre una mano di poker randomicamente e attraverso delle funzioni stabilire se si è in presenza di poker, scala, coppia ecc...
il mio codice è questo:
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <stdbool.h>
  5.  
  6. void shuffle(int wDeck[][13]);
  7. void deal(const int wDeck[][13], const char *wFace[], const char *wSuit[], bool hand[][13]);
  8. bool pair(bool hand[][13]);
  9. bool two_pairs(bool hand[][13]);
  10. bool tris(bool hand[][13]);
  11. bool poker(bool hand[][13]);
  12. bool color(bool hand[][13]);
  13. bool flush(bool hand[][13]);
  14.  
  15. int main(){
  16.     const char *suit[4]={"Hearts", "Diamond", "Clubs", "Spades"};
  17.     const char *face[13]={"Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"};
  18.     int deck[4][13]={0};
  19.     bool hand[4][13]={false};
  20.  
  21.     srand(time(NULL));
  22.     shuffle(deck);
  23.     deal(deck, face, suit, hand);
  24.     if(poker(hand)){
  25.         printf("Poker!");
  26.     }else if(tris(hand)){
  27.              printf("Tris!");
  28.         }else if(two_pairs(hand)){
  29.                 printf("Two pairs!");
  30.             }else if(pair(hand))
  31.                     printf("\nPair!\n");
  32.     if(color(hand))
  33.         printf("Color!");
  34.     if(flush(hand))
  35.         printf("Flush!");
  36.     return 0;
  37. }
  38.  
  39. void shuffle(int wDeck[][13]){
  40.     int row, column, card;
  41.  
  42.     for(card=1; card<=52; card++){
  43.         do{
  44.             row=rand()%4;
  45.             column=rand()%13;
  46.         }while(wDeck[row][column] != 0);
  47.         wDeck[row][column]=card;
  48.     }
  49. }
  50.  
  51. void deal(const int wDeck[][13], const char *wFace[], const char *wSuit[], bool hand[][13]){
  52.     int card, row, column;
  53.  
  54.     for(card=1; card<=5; card++){
  55.         for(row=0; row<=3; row++){
  56.             for(column=0; column<=12; column++){
  57.                 if(wDeck[row][column]==card){
  58.                     printf("%5s of %-8s%c", wFace[column], wSuit[row], card%2==0 ? '\n' : '\t');
  59.                     hand[row][column]=true;
  60.                 }
  61.             }
  62.         }
  63.     }
  64. }
  65.  
  66. bool pair(bool hand[][13]){
  67.     int row, column, count=0;
  68.     bool r=false;
  69.  
  70.     for(column=0; column<=12 && count!=2 ; column++){
  71.         for(row=0; row<=3; row++){
  72.             if(hand[row][column])
  73.                 count++;
  74.         }
  75.         if(count!= 2)
  76.             count=0;
  77.     }
  78.     if(count==2)
  79.         r=true;
  80.     return r;
  81. }
  82. bool two_pairs(bool hand[][13]){
  83.     int row, column, acc=0, count=0;
  84.     bool r=false;
  85.  
  86.     for(column=0; column<=12 && count!=4 ; column++){
  87.         count=0;
  88.         for(row=0; row<=3; row++){
  89.             if(hand[row][column])
  90.                 count++;
  91.         }
  92.         if(count == 2)
  93.             acc+=count;
  94.     }
  95.     if(acc==4)
  96.         r=true;
  97.     return r;
  98. }
  99. bool tris(bool hand[][13]){
  100.     int row, column, count=0;
  101.     bool r=false;
  102.  
  103.     for(column=0; column<=12 && count!=3 ; column++){
  104.         for(row=0; row<=3; row++){
  105.             if(hand[row][column])
  106.                 count++;
  107.         }
  108.         if(count!= 3)
  109.             count=0;
  110.     }
  111.     if(count==3)
  112.         r=true;
  113.     return r;
  114. }
  115. bool poker(bool hand[][13]){
  116.     int row, column, count=0;
  117.     bool r=false;
  118.  
  119.     for(column=0; column<=12 && count!=4 ; column++){
  120.         for(row=0; row<=4; row++){
  121.             if(hand[row][column])
  122.                 count++;
  123.         }
  124.         if(count!= 4)
  125.             count=0;
  126.     }
  127.     if(count==4)
  128.         r=true;
  129.     return r;
  130. }
  131. bool color(bool hand[][13]){
  132.     int row, column, count=0;
  133.     bool r=false;
  134.  
  135.     for(row=0; row<=3 && count!=2 ; row++){
  136.         for(column=0; column<=3; column++){
  137.             if(hand[row][column])
  138.                 count++;
  139.         }
  140.         if(count!= 5)
  141.             count=0;
  142.     }
  143.     if(count==5)
  144.         r=true;
  145.     return r;
  146. }
  147. bool flush(bool hand[][13]){
  148.     int row, column, v[5], i=0;
  149.     bool r=true;
  150.     void exchange_sort(int v[], int dim);
  151.  
  152.     for(row=0; row<=3; row++){
  153.         for(column=0; column<=3; column++){
  154.             if(hand[row][column]){
  155.                 v[i]=column;
  156.                 i++;
  157.             }
  158.         }
  159.     }
  160.     exchange_sort(v, 5);
  161.     for(i=0; i<5 && r==true; i++){
  162.         if(v[i+1]-v[i]!=1)
  163.             r=false;
  164.     }
  165.     return r;
  166. }
  167. void exchange_sort(int v[], int dim){
  168.         int i,j;
  169.         void swap(int *aPtr, int *bPtr);
  170.  
  171.         for(i=0; i<dim; i++)
  172.                 for(j=i+1; j<dim; j++)
  173.                         if(v[i]>v[j])
  174.                                 swap(&v[i], &v[j]);
  175. }
  176. void swap(int *aPtr, int *bPtr){
  177.     int t;
  178.         t = *aPtr;
  179.         *aPtr = *bPtr;
  180.         *bPtr = t;
  181. }


tutto sembra andare bene fino a quando non capita un tris, ma il programma lo riconosce come poker!
A parte l'ottimizzazione e il rischio di differimento indefinito (di cui sono a conoscenza), cosa sbaglio?

PM Quote
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 9:29
Sabato, 30/07/2016
problema risolto, chiedo l'eliminazione del post

PM Quote
Avatar
lumo (Member)
Expert


Messaggi: 413
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 10:02
Sabato, 30/07/2016
Sarebbe più utile se condividessi la soluzione, rimarrebbe ai posteri.

PM Quote
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 10:14
Sabato, 30/07/2016
Testo quotato

Postato originariamente da lumo:

Sarebbe più utile se condividessi la soluzione, rimarrebbe ai posteri.



bhe, allora appena posso provvederò subito a mettere la versione senza errori e commentata. :k:

PM Quote
Avatar
()
Newbie


Messaggi:
Iscritto:

Segnala al moderatore
Postato alle 15:12
Sabato, 30/07/2016
Come potete vedere ho aggiunto i commenti, l'errore era causato da un ciclo for con condizioni errate.
Spero che sarà utile a futuri apprendisti!
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <stdbool.h>
  5.  
  6. void shuffle(int wDeck[][13]);
  7. void deal(const int wDeck[][13], const char *wFace[], const char *wSuit[], bool hand[][13]);
  8. /*Prototipi delle funzioni usate per stabilire le combinazioni*/
  9. bool pair(bool hand[][13]);
  10. bool two_pairs(bool hand[][13]);
  11. bool tris(bool hand[][13]);
  12. bool poker(bool hand[][13]);
  13. bool color(bool hand[][13]);
  14. bool flush(bool hand[][13]);
  15.  
  16. int main(){
  17.     /*Vettori di stringhe contenenti i semi e i valori delle carte*/
  18.     const char *suit[4]={"Hearts", "Diamond", "Clubs", "Spades"};
  19.     const char *face[13]={"Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Jack", "Queen", "King"};
  20.     int deck[4][13]={0};    /*Matrice usata per mescolare le carte*/
  21.     bool hand[4][13]={false};   /*Matrice usata per copiare la mano di 5 carte*/
  22.  
  23.     srand(time(NULL));
  24.     shuffle(deck);
  25.     deal(deck, face, suit, hand);
  26.     /*If annidati e accatastati per stabilire le combinazioni create*/
  27.     if(poker(hand)){
  28.         printf("Poker!");
  29.     }else if(tris(hand)){
  30.              printf("Tris!");
  31.         }else if(two_pairs(hand)){
  32.                 printf("Two pairs!");
  33.             }else if(pair(hand))
  34.                     printf("\nPair!\n");
  35.     if(color(hand))
  36.         printf("Color!");
  37.     if(flush(hand))
  38.         printf("Flush!");
  39.     return 0;
  40. }
  41. /*NB questa funzione non è ben ottimizzata, si potrebbe riscontrare un differimento indefinito*/
  42. void shuffle(int wDeck[][13]){
  43.     int row, column, card;
  44.  
  45.     for(card=1; card<=52; card++){
  46.         do{
  47.             row=rand()%4;
  48.             column=rand()%13;
  49.         }while(wDeck[row][column] != 0);
  50.         wDeck[row][column]=card;
  51.     }
  52. }
  53. /*funzione di distribuzione modificata per distribuire una sola mano e copiare le carte in una matrice booleana*/
  54. void deal(const int wDeck[][13], const char *wFace[], const char *wSuit[], bool hand[][13]){
  55.     int card, row, column;
  56.  
  57.     for(card=1; card<=5; card++){
  58.         for(row=0; row<=3; row++){
  59.             for(column=0; column<=12; column++){
  60.                 if(wDeck[row][column]==card){
  61.                     printf("%5s of %-8s%c", wFace[column], wSuit[row], card%2==0 ? '\n' : '\t');
  62.                     hand[row][column]=true;
  63.                 }
  64.             }
  65.         }
  66.     }
  67. }
  68.  
  69. bool pair(bool hand[][13]){
  70.     int row, column, count=0;
  71.     bool r=false;
  72.  
  73.     for(column=0; column<=12 && count!=2 ; column++){  /*I due cicli "scansionano" la matrice in cerca di due valori uguali*/
  74.         for(row=0; row<=3; row++){
  75.             if(hand[row][column])
  76.                 count++;
  77.         }
  78.         if(count!= 2)       /*se nella colonna attuale non trova una coppia azzera il contatore*/
  79.             count=0;
  80.     }
  81.     if(count==2)
  82.         r=true;
  83.     return r;
  84. }
  85. bool two_pairs(bool hand[][13]){
  86.     int row, column, acc=0, count=0;
  87.     bool r=false;
  88.  
  89.     for(column=0; column<=12 && acc!=4 ; column++){ /*è stato aggiunto un accumulatore per sommare le coppie*/
  90.         count=0;
  91.         for(row=0; row<=3; row++){
  92.             if(hand[row][column])
  93.                 count++;
  94.         }
  95.         if(count == 2) /*in presenza di una coppia il valore viene sommato all'accumulatore*/
  96.             acc+=count;
  97.     }
  98.     if(acc==4)
  99.         r=true;
  100.     return r;
  101. }
  102. /*per tris(), poker() e color() ho usato lo stesso concetto delle precedenti funzioni*/
  103. bool tris(bool hand[][13]){
  104.     int row, column, count=0;
  105.     bool r=false;
  106.  
  107.     for(column=0; column<=12 && count!=3 ; column++){
  108.         for(row=0; row<=3; row++){
  109.             if(hand[row][column])
  110.                 count++;
  111.         }
  112.         if(count!= 3)
  113.             count=0;
  114.     }
  115.     if(count==3)
  116.         r=true;
  117.     return r;
  118. }
  119. bool poker(bool hand[][13]){
  120.     int row, column, count=0;
  121.     bool r=false;
  122.  
  123.     for(column=0; column<=12 && r!=true ; column++){
  124.         count=0;
  125.         for(row=0; row<=3; row++){
  126.             if(hand[row][column])
  127.                 count++;
  128.         }
  129.         if(count==4)
  130.             r=true;
  131.     }
  132.     return r;
  133. }
  134. bool color(bool hand[][13]){
  135.     int row, column, count=0;
  136.     bool r=false;
  137.  
  138.     for(row=0; row<=3 && r!=true ; row++){
  139.         count=0;
  140.         for(column=0; column<=12; column++){
  141.             if(hand[row][column])
  142.                 count++;
  143.         }
  144.         if(count== 5)
  145.             r=true;
  146.     }
  147.     return r;
  148. }
  149.  
  150. bool flush(bool hand[][13]){
  151.     int row, column, v[5], i=0;
  152.     bool r=true;
  153.     void exchange_sort(int v[], int dim);
  154.  
  155.     for(row=0; row<=3; row++){              /*i cicli sono stati invertiti poichè la scala si basa sui valori e non sul seme*/
  156.         for(column=0; column<=3; column++){
  157.             if(hand[row][column]){
  158.                 v[i]=column;        /*in presenza di una carta si trasferisce il valore in un vettore di interi*/
  159.                 i++;
  160.             }
  161.         }
  162.     }
  163.     exchange_sort(v, 5);            /*il vettore viene riordinato per rendere possibile verificare se siamo in presenza di valori consecutivi*/
  164.     for(i=0; i<5 && r==true; i++){
  165.         if(v[i+1]-v[i]!=1)              /*if per trovare i valori non consecutivi*/
  166.             r=false;                    /*se la condizione è rispettata viene interrotto il ciclo for e ritornerà false*/
  167.     }
  168.     return r;
  169. }
  170. void exchange_sort(int v[], int dim){
  171.         int i,j;
  172.         void swap(int *aPtr, int *bPtr);
  173.  
  174.         for(i=0; i<dim; i++)
  175.                 for(j=i+1; j<dim; j++)
  176.                         if(v[i]>v[j])
  177.                                 swap(&v[i], &v[j]);
  178. }
  179. void swap(int *aPtr, int *bPtr){
  180.     int t;
  181.         t = *aPtr;
  182.         *aPtr = *bPtr;
  183.         *bPtr = t;
  184. }


Ps: Se avete idee su come migliorare il codice delle funzioni per le combinazioni scrivete pure :)

PM Quote