撲克代碼清理修改......不太對勁

Question

通過更多的書examples-這一個工作是部分撲克計劃專 這部分涉及直手....

第一隻什麼是得到N-相關配件....將提供完整的代碼，如果需要...

int suits[5]; //index 1..4- value start at 1 
int values[14]; //index 1..13- value same as rank, A = 1, K = 13 

cin.get(rankCh); 
switch (toUpper(rankCh)) { 
case 'A': values = 1; break; 
case '2': values = 2; break; 
case '3': values = 3; break; 
case '4': values = 4; break; 
case '5': values = 5; break; 
case '6': values = 6; break; 
case '7': values = 7; break; 
case '8': values = 8; break; 
case '9': values = 9; break; 
case 'T': values = 10; break; 
case 'J': values = 11; break; 
case 'Q': values = 12; break; 
case 'K': values = 13; break; 
default: 
badCard = true; 
} 

其它功能：

bool isFlush(int suits[]) { 
    for(i = 1; i <= 4; i++) 
     if (suits[i] == 5)  //5 here is Number of Cards 
      return true; 
    return false; 
} 

是啊，我知道了數組聲明但這是豪這是它的定義 - 很好的理由它在文本...開始數字在1 我希望我的直手處理王牌高和低權利現在定義以上王牌是低...

兩個版本：第一次出現不知道正確的低尖子...

CODE

bool isStraight(int values[]) //Version one only straight- low aces only 
{ 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
      count++; 
     } else 
      count = 0; 

     if (count == 5) //5 is NUMCARDS 
      return true; 
    } 
    return false; 
} 

現在，這是我需要一些建議：有一個函數來處理這兩個王牌高和低：

bool isStraight(int values[]) //Version handles both high and low 
{ 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
      count++; 
      // if(i == 1 && values[1] != 0) //Check for high and low 
      // count++; 
     } else 
      count = 0; 

     if (count == 5) //5 is NUMCARDS 
      return true; 
    } 
    return false; 
} 

請問我有什麼意見中要處理的工作都王牌高和低...

因i = 1表示爲ACE和不知道是什麼值[1]是正確的它應該是值[13]或者是什麼......也許像

if (i == 1) 
    values[13] //not sure... 

建議 -

• 不想批發changes-正好與我有什麼......我不想排序或用暴力解決小的改動即像值[1] == 1 & &個值[2] == 1你的文中已經但是我想這種方式重寫它的點 - ...

謝謝...希望我在我的修改讓我想...

Answer 1

編輯：我想我會先直接回答你的問題。讓我們先澄清原始算法的工作原理。基本上它從1到13循環，並且每次它在該插槽中看到一張卡時，它都會增加計數。如果有任何事情中斷了序列，它會重置計數器。最後，如果計數器達到5，你有一個直線。

如果您的解決方案可行，我不能說脫手，我說給它一個。然而，簡單快速的補丁原來可能會去是這樣的：

//Version handles both high and low 
bool isStraight(int values[]) { 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
       count++; 
     } else 
       count = 0; 

     if (count == 5) //5 is NUMCARDS 
       return true; 
    } 

     // handle ace high. 
     if(count == 4 && values[1] != 0) { 
      return true; 
     } 

    return false; 
} 

基本上是做什麼的說：「如果我們已經有4成一排，和我們剛剛看了最後卡（循環結束），然後檢查一個王牌是否在那裏，如果是的話，我們確實有一條直線，這是一個高點「。

原來的答案： 我認爲最簡單的方法來處理王牌高和低是有「獲取等級」功能有兩種模式，一種是它返回王牌高，它返回王牌低其他。然後只需計算每種情況下的手牌值並採取更好的方式。

此外，您的排名可能會更簡單：-P。

int get_rank(char card) { 
    static const char *cards = "A23456789TJQK"; 
    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

所以，如果你想擁有它有一個ace_high或ace_low一個get_rank，你可以這樣做：

int get_rank(char card, bool ace_high) { 
    static const char *cards_high = "23456789TJQKA"; 
    static const char *cards_low = "A23456789TJQK"; 

    const char *cards = ace_high ? cards_high : cards_low; 

    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

編輯：

爲了好玩，我做了一個快速和骯髒的程序，檢測直道（處理高和低的王牌）。這是相當簡單的，但可能是短（也注意，在這些陣列緩衝安全沒有嘗試，生產質量的東西應該使用的東西更安全，如std::vector：

#include <algorithm> 
#include <iostream> 
#include <cstring> 

int get_rank(char card, bool ace_high) { 
    static const char *cards_high = "23456789TJQKA"; 
    static const char *cards_low = "A23456789TJQK"; 
    const char *cards = ace_high ? cards_high : cards_low; 

    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

bool is_rank_less_low(int card1, int card2) { 
    return get_rank(card1, false) < get_rank(card2, false); 
} 

bool is_rank_less_high(int card1, int card2) { 
    return get_rank(card1, true) < get_rank(card2, true); 
} 

bool is_straight(int hand[], bool ace_high) { 

    std::sort(hand, hand + 5, ace_high ? is_rank_less_high : is_rank_less_low); 
    int rank = get_rank(hand[0], ace_high); 
    for(int i = 1; i < 5; ++i) { 
     int new_rank = get_rank(hand[i], ace_high); 
     if(new_rank != rank + 1) { 
      return false; 
     } 
     rank = new_rank; 
    } 
    return true; 
} 

bool is_straight(int hand[]) { 
    return is_straight(hand, false) || is_straight(hand, true); 
} 

int main() { 
    int hand1[5] = { 'T', 'J', 'Q', 'K', 'A' }; 
    int hand2[5] = { 'A', '2', '3', '4', '5' }; 
    std::cout << is_straight(hand1) << std::endl; 
    std::cout << is_straight(hand2) << std::endl; 
} 

Answer 2

的情況下一個王牌高。

if (count == 5 || count == 4 && values[1] == 1) // 2nd case handles ace-high straight 
    return true; 

這是一個特殊情況，所以必須分開處理