I've wrote this code to solve project euler problem #54. It started innocently enough, hard coding winning hands conditions for the sake of 'simplicity'... Things got a little out of hand in the SolveXXXTie() functions .
#include "Windows.h"
#include "stdio.h"
#include <Vector>
using namespace std;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int NumPlayers = 2;
const int NumCardsPerHand = 5;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define TIE -1
#define PLAYER1 0
#define PLAYER2 1
enum CardSuit {
SPADES, HEARTS, DIAMONDS, CLUBS,
};
enum CardValue {
TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, JACK, QUEEN, KING, ACE,
};
enum HandResult {
HIGH_CARD, ONE_PAIR, TWO_PAIRS, THREE_OF_A_KIND, STRAIGHT, FLUSH, FULL_HOUSE, FOUR_OF_A_KIND, STRAIGHT_FLUSH, ROYAL_FLUSH,
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct CardStruct {
CardValue v;
CardSuit s;
};
struct HandStruct {
CardStruct Cards[NumCardsPerHand];
};
vector<HandStruct> PlayersCards[NumPlayers];
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CardValue CharToCardValue(char c)
{
switch(c)
{
default:
case '2': return TWO;
case '3': return THREE;
case '4': return FOUR;
case '5': return FIVE;
case '6': return SIX;
case '7': return SEVEN;
case '8': return EIGHT;
case '9': return NINE;
case 'T': return TEN;
case 'J': return JACK;
case 'Q': return QUEEN;
case 'K': return KING;
case 'A': return ACE;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CardSuit CharToCardSuit(char c)
{
switch(c)
{
default:
case 'S': return SPADES;
case 'H': return HEARTS;
case 'D': return DIAMONDS;
case 'C': return CLUBS;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int LoadFromFile(char *fname)
{
int NumRows = 0;
const int bufsize = 64;
char Buffer[bufsize];
CardStruct cs;
HandStruct hs;
FILE *f = fopen(fname, "rt");
if(f){
while(1){
ZeroMemory(Buffer, bufsize);
if(fgets(Buffer, bufsize, f) == NULL)
break;
int k = 0;
for(int p = 0; p < NumPlayers; p++){
for(int i = 0; i < NumCardsPerHand; i++){
char v,s;
v = Buffer[k++];
s = Buffer[k++];
cs.v = CharToCardValue(v);
cs.s = CharToCardSuit(s);
hs.Cards[i] = cs;
k++;
}
PlayersCards[p].push_back(hs);
}
NumRows++;
}
fclose(f);
}
return NumRows;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SwapCard(CardStruct *c1, CardStruct *c2)
{
CardStruct temp = *c1;
*c1 = *c2;
*c2 = temp;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void SortCards(HandStruct *hs)
{
bool swapped;
do
{
swapped = false;
for(int i = 1; i < NumCardsPerHand; i++){
if(hs->Cards[i-1].v > hs->Cards[i].v){
SwapCard(&hs->Cards[i-1], &hs->Cards[i]);
swapped = true;
}
}
}
while(swapped);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool RoyalFlush(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[0].v == TEN &&
c[1].v == JACK &&
c[2].v == QUEEN &&
c[3].v == KING &&
c[4].v == ACE) == false)
{
return false;
}
if((c[0].s == c[1].s &&
c[1].s == c[2].s &&
c[2].s == c[3].s &&
c[3].s == c[4].s &&
c[4].s == c[0].s) == false)
{
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool StraightFlush(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[1].v == c[0].v+1 &&
c[2].v == c[1].v+1 &&
c[3].v == c[2].v+1 &&
c[4].v == c[3].v+1) == false)
{
return false;
}
if((c[0].s == c[1].s &&
c[1].s == c[2].s &&
c[2].s == c[3].s &&
c[3].s == c[4].s &&
c[4].s == c[0].s) == false)
{
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool FourOfaKind(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
bool Found = false;
if((c[0].v == c[1].v &&
c[1].v == c[2].v &&
c[2].v == c[3].v))
{
Found = true;
}
if((c[1].v == c[2].v &&
c[2].v == c[3].v &&
c[3].v == c[4].v))
{
Found = true;
}
return Found;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool FullHouse(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
bool Found = false;
if((c[0].v == c[1].v &&
c[1].v == c[2].v) &&
(c[3].v == c[4].v))
{
Found = true;
}
if((c[0].v == c[1].v) &&
(c[2].v == c[3].v &&
c[3].v == c[4].v))
{
Found = true;
}
return Found;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Flush(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[0].s == c[1].s &&
c[1].s == c[2].s &&
c[2].s == c[3].s &&
c[3].s == c[4].s &&
c[4].s == c[0].s) == false)
{
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool Straight(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[1].v == c[0].v+1 &&
c[2].v == c[1].v+1 &&
c[3].v == c[2].v+1 &&
c[4].v == c[3].v+1) == false)
{
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool ThreeOfaKind(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if(((c[0].v == c[1].v && c[1].v == c[2].v) && (c[0].v != c[3].v && c[0].v != c[4].v)) ||
((c[1].v == c[2].v && c[2].v == c[3].v) && (c[1].v != c[0].v && c[1].v != c[4].v)) ||
((c[2].v == c[3].v && c[3].v == c[4].v) && (c[2].v != c[0].v && c[2].v != c[1].v)))
{
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool TwoPairs(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[0].v == c[1].v && c[2].v == c[3].v && c[4].v != c[3].v) ||
(c[1].v == c[2].v && c[3].v == c[4].v && c[0].v != c[1].v) ||
(c[0].v == c[1].v && c[3].v == c[4].v && c[2].v != c[1].v && c[2].v != c[3].v))
{
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool OnePair(HandStruct *hs)
{
CardStruct *c = &hs->Cards[0];
if((c[0].v == c[1].v && c[2].v != c[1].v && c[3].v != c[1].v && c[4].v != c[1].v) ||
(c[1].v == c[2].v && c[3].v != c[2].v && c[4].v != c[2].v && c[0].v != c[2].v) ||
(c[2].v == c[3].v && c[4].v != c[3].v && c[0].v != c[3].v && c[1].v != c[3].v) ||
(c[3].v == c[4].v && c[0].v != c[4].v && c[1].v != c[4].v && c[2].v != c[4].v))
{
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int AnalyseHand(int p, int i)
{
HandStruct hs = PlayersCards[p][i];
SortCards(&hs);
if(RoyalFlush(&hs))
return ROYAL_FLUSH;
if(StraightFlush(&hs))
return STRAIGHT_FLUSH;
if(FourOfaKind(&hs))
return FOUR_OF_A_KIND;
if(FullHouse(&hs))
return FULL_HOUSE;
if(Flush(&hs))
return FLUSH;
if(Straight(&hs))
return STRAIGHT;
if(ThreeOfaKind(&hs))
return THREE_OF_A_KIND;
if(TwoPairs(&hs))
return TWO_PAIRS;
if(OnePair(&hs))
return ONE_PAIR;
return HIGH_CARD;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveStraightFlushTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue HighestP1 = TWO;
CardValue HighestP2 = TWO;
for(int i = 0; i < NumCardsPerHand; i++){
if(c1[i].v > HighestP1)
HighestP1 = c1[i].v;
if(c2[i].v > HighestP2)
HighestP2 = c2[i].v;
}
if(HighestP1 > HighestP2)
return PLAYER1;
if(HighestP1 < HighestP2)
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveFourOfaKindTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue HighestP1 = TWO;
CardValue HighestP2 = TWO;
CardValue QuadValP1 = c1[2].v;
CardValue QuadValP2 = c2[2].v;
if(c1[0].v != c1[1].v){
HighestP1 = c1[0].v;
} else {
HighestP1 = c1[4].v;
}
if(c2[0].v != c2[1].v){
HighestP2 = c2[0].v;
} else {
HighestP2 = c2[4].v;
}
if(QuadValP1 > QuadValP2)
return PLAYER1;
if(QuadValP1 < QuadValP2)
return PLAYER2;
if(HighestP1 > HighestP2)
return PLAYER1;
if(HighestP1 < HighestP2)
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveFullHouseTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue PairValP1 = TWO;
CardValue PairValP2 = TWO;
CardValue TriValP1 = TWO;
CardValue TriValP2 = TWO;
if(c1[0].v == c1[1].v && c1[1].v == c1[2].v){
TriValP1 = c1[0].v;
PairValP1 = c1[4].v;
} else {
TriValP1 = c1[4].v;
PairValP1 = c1[0].v;
}
if(c2[0].v == c2[1].v && c2[1].v == c2[2].v){
TriValP2 = c2[0].v;
PairValP2 = c2[4].v;
} else {
TriValP2 = c2[4].v;
PairValP2 = c2[0].v;
}
if(TriValP1 > TriValP2)
return PLAYER1;
if(TriValP1 < TriValP2)
return PLAYER2;
if(PairValP1 > PairValP2)
return PLAYER1;
if(PairValP1 < PairValP2)
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveFlushTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
for(int i = NumCardsPerHand-1; i >= 0; i--){
if(c1[i].v > c2[i].v){
return PLAYER1;
} else if(c1[i].v < c2[i].v){
return PLAYER2;
}
}
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveStraightTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
if(c1[4].v > c2[4].v){
return PLAYER1;
} else if(c1[4].v < c2[4].v){
return PLAYER2;
}
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveThreeOfaKindTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue TriValP1 = TWO;
CardValue TriValP2 = TWO;
CardValue HighValP1[2] = {TWO, TWO};
CardValue HighValP2[2] = {TWO, TWO};
if(c1[0].v == c1[1].v && c1[1].v == c1[2].v){
TriValP1 = c1[0].v;
HighValP1[0] = c1[4].v;
HighValP1[1] = c1[3].v;
} else if(c1[1].v == c1[2].v && c1[2].v == c1[3].v){
TriValP1 = c1[1].v;
HighValP1[0] = c1[4].v;
HighValP1[1] = c1[0].v;
} else if(c1[2].v == c1[3].v && c1[3].v == c1[4].v){
TriValP1 = c1[2].v;
HighValP1[0] = c1[1].v;
HighValP1[1] = c1[0].v;
}
if(c2[0].v == c2[1].v && c2[1].v == c2[2].v){
TriValP2 = c2[0].v;
HighValP2[0] = c2[4].v;
HighValP2[1] = c2[3].v;
} else if(c2[1].v == c2[2].v && c2[2].v == c2[3].v){
TriValP2 = c2[1].v;
HighValP2[0] = c2[4].v;
HighValP2[1] = c2[0].v;
} else if(c2[2].v == c2[3].v && c2[3].v == c2[4].v){
TriValP2 = c2[2].v;
HighValP2[0] = c2[1].v;
HighValP2[1] = c2[0].v;
}
if(TriValP1 > TriValP2)
return PLAYER1;
if(TriValP1 < TriValP2)
return PLAYER2;
if(HighValP1[0] > HighValP2[0])
return PLAYER1;
if(HighValP1[0] < HighValP2[0])
return PLAYER2;
if(HighValP1[1] > HighValP2[1])
return PLAYER1;
if(HighValP1[1] < HighValP2[1])
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveTwoPairsTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue PairValP1[2] = {TWO, TWO};
CardValue PairValP2[2] = {TWO, TWO};
CardValue HighValP1 = TWO;
CardValue HighValP2 = TWO;
if(c1[0].v == c1[1].v && c1[2].v == c1[3].v && c1[4].v != c1[3].v){
PairValP1[0] = c1[2].v;
PairValP1[1] = c1[0].v;
HighValP1 = c1[4].v;
} else if(c1[1].v == c1[2].v && c1[3].v == c1[4].v && c1[0].v != c1[1].v){
PairValP1[0] = c1[3].v;
PairValP1[1] = c1[1].v;
HighValP1 = c1[0].v;
} else if(c1[0].v == c1[1].v && c1[3].v == c1[4].v && c1[2].v != c1[1].v && c1[2].v != c1[3].v){
PairValP1[0] = c1[3].v;
PairValP1[1] = c1[0].v;
HighValP1 = c1[2].v;
}
if(c2[0].v == c2[1].v && c2[2].v == c2[3].v && c2[4].v != c2[3].v){
PairValP2[0] = c2[2].v;
PairValP2[1] = c2[0].v;
HighValP2 = c2[4].v;
} else if(c2[1].v == c2[2].v && c2[3].v == c2[4].v && c2[0].v != c2[1].v){
PairValP2[0] = c2[3].v;
PairValP2[1] = c2[1].v;
HighValP2 = c2[0].v;
} else if(c2[0].v == c2[1].v && c2[3].v == c2[4].v && c2[2].v != c2[1].v && c2[2].v != c2[3].v){
PairValP2[0] = c2[3].v;
PairValP2[1] = c2[0].v;
HighValP2 = c2[2].v;
}
if(PairValP1[1] > PairValP2[1])
return PLAYER1;
if(PairValP1[1] < PairValP2[1])
return PLAYER2;
if(PairValP1[0] > PairValP2[0])
return PLAYER1;
if(PairValP1[0] < PairValP2[0])
return PLAYER2;
if(HighValP1 > HighValP2)
return PLAYER1;
if(HighValP1 < HighValP2)
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveOnePairTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
CardValue PairValP1 = TWO;
CardValue PairValP2 = TWO;
CardValue HighValP1[3] = {TWO, TWO, TWO};
CardValue HighValP2[3] = {TWO, TWO, TWO};
if(c1[0].v == c1[1].v && c1[2].v != c1[1].v && c1[3].v != c1[1].v && c1[4].v != c1[1].v){
PairValP1 = c1[0].v;
HighValP1[0] = c1[4].v;
HighValP1[1] = c1[3].v;
HighValP1[2] = c1[2].v;
} else if(c1[1].v == c1[2].v && c1[3].v != c1[2].v && c1[4].v != c1[2].v && c1[0].v != c1[2].v){
PairValP1 = c1[1].v;
HighValP1[0] = c1[4].v;
HighValP1[1] = c1[3].v;
HighValP1[2] = c1[0].v;
} else if(c1[2].v == c1[3].v && c1[4].v != c1[3].v && c1[0].v != c1[3].v && c1[1].v != c1[3].v){
PairValP1 = c1[2].v;
HighValP1[0] = c1[4].v;
HighValP1[1] = c1[1].v;
HighValP1[2] = c1[0].v;
} else if(c1[3].v == c1[4].v && c1[0].v != c1[4].v && c1[1].v != c1[4].v && c1[2].v != c1[4].v){
PairValP1 = c1[3].v;
HighValP1[0] = c1[2].v;
HighValP1[1] = c1[1].v;
HighValP1[2] = c1[0].v;
}
if(c2[0].v == c2[1].v && c2[2].v != c2[1].v && c2[3].v != c2[1].v && c2[4].v != c2[1].v){
PairValP2 = c2[0].v;
HighValP2[0] = c2[4].v;
HighValP2[1] = c2[3].v;
HighValP2[2] = c2[2].v;
} else if(c2[1].v == c2[2].v && c2[3].v != c2[2].v && c2[4].v != c2[2].v && c2[0].v != c2[2].v){
PairValP2 = c2[1].v;
HighValP2[0] = c2[4].v;
HighValP2[1] = c2[3].v;
HighValP2[2] = c2[0].v;
} else if(c2[2].v == c2[3].v && c2[4].v != c2[3].v && c2[0].v != c2[3].v && c2[1].v != c2[3].v){
PairValP2 = c2[2].v;
HighValP2[0] = c2[4].v;
HighValP2[1] = c2[1].v;
HighValP2[2] = c2[0].v;
} else if(c2[3].v == c2[4].v && c2[0].v != c2[4].v && c2[1].v != c2[4].v && c2[2].v != c2[4].v){
PairValP2 = c2[3].v;
HighValP2[0] = c2[2].v;
HighValP2[1] = c2[1].v;
HighValP2[2] = c2[0].v;
}
if(PairValP1 > PairValP2)
return PLAYER1;
if(PairValP1 < PairValP2)
return PLAYER2;
if(HighValP1[0] > HighValP2[0])
return PLAYER1;
if(HighValP1[0] < HighValP2[0])
return PLAYER2;
if(HighValP1[1] > HighValP2[1])
return PLAYER1;
if(HighValP1[1] < HighValP2[1])
return PLAYER2;
if(HighValP1[2] > HighValP2[2])
return PLAYER1;
if(HighValP1[2] < HighValP2[2])
return PLAYER2;
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int SolveHighCardTie(HandStruct *hs1, HandStruct *hs2)
{
CardStruct *c1 = &hs1->Cards[0];
CardStruct *c2 = &hs2->Cards[0];
for(int i = NumCardsPerHand-1; i >= 0; i--){
if(c1[i].v > c2[i].v){
return PLAYER1;
} else if(c1[i].v < c2[i].v){
return PLAYER2;
}
}
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int AnalyseHands(int row)
{
int r1 = AnalyseHand(PLAYER1, row);
int r2 = AnalyseHand(PLAYER2, row);
if(r1 > r2)
return PLAYER1;
if(r1 < r2)
return PLAYER2;
// Tie...
HandStruct hs1 = PlayersCards[PLAYER1][row];
HandStruct hs2 = PlayersCards[PLAYER2][row];
SortCards(&hs1);
SortCards(&hs2);
if(r1 == STRAIGHT_FLUSH)
return SolveStraightFlushTie(&hs1, &hs2);
if(r1 == FOUR_OF_A_KIND)
return SolveFourOfaKindTie(&hs1, &hs2);
if(r1 == FULL_HOUSE)
return SolveFullHouseTie(&hs1, &hs2);
if(r1 == FLUSH)
return SolveFlushTie(&hs1, &hs2);
if(r1 == STRAIGHT)
return SolveStraightTie(&hs1, &hs2);
if(r1 == THREE_OF_A_KIND)
return SolveThreeOfaKindTie(&hs1, &hs2);
if(r1 == TWO_PAIRS)
return SolveTwoPairsTie(&hs1, &hs2);
if(r1 == ONE_PAIR)
return SolveOnePairTie(&hs1, &hs2);
if(r1 == HIGH_CARD)
return SolveHighCardTie(&hs1, &hs2);
return TIE;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/*void PrintResult(int res)
{
switch(res)
{
case ROYAL_FLUSH: printf("Royal Flush\n"); break;
case STRAIGHT_FLUSH: printf("Straight Flush\n"); break;
case FOUR_OF_A_KIND: printf("Four of a kind\n"); break;
case FULL_HOUSE: printf("Full House\n"); break;
case FLUSH: printf("Flush\n"); break;
case STRAIGHT: printf("Straight\n"); break;
case THREE_OF_A_KIND: printf("Three of a kind\n"); break;
case TWO_PAIRS: printf("Two Pairs\n"); break;
case ONE_PAIR: printf("One Pair\n"); break;
case HIGH_CARD: printf("High Card\n"); break;
}
}*/
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
int NumRows = LoadFromFile("poker.txt");
int Tie = 0;
int P1Wins = 0;
int P2Wins = 0;
for(int row = 0; row < NumRows; row++){
int res = AnalyseHands(row);
if(res == PLAYER1){
printf("Player 1 Win\n");
P1Wins++;
} else if(res == PLAYER2){
printf("Player 2 Win\n");
P2Wins++;
} else {
printf("Tie\n");
Tie++;
}
}
printf("\nWin: %d, Lose: %d, Tie: %d\n\n", P1Wins, P2Wins, Tie);
return 0;
}
SolveOnePairTie() is the worst of all...
Still, to my surprise, it worked the first shoot!