алгоритм

#include<iostream>
#include<ctime>
#include<vector>
#include<string>
 
class Card
{
public:
    enum suit/*масть*/ {hearts/*черви*/, diamonds/*бубны*/, clubs/*трефы*/, spades/*пики*/ };
    enum value { ace, six, seven, eight, nine, ten, jack, queen,  king };
protected:
    suit suitOfCard;
    value valueOfCard;
public:
    Card(value valueOfNewCard, suit suitOfNewCard):
      valueOfCard(valueOfNewCard),
      suitOfCard(suitOfNewCard)
      {   }
    Card()
    {
        //srand(time(0));
 
        switch(rand() % 9)
        {
        case 0:
            valueOfCard = ace;
            break;
        case 1:
            valueOfCard = six;
            break;
        case 2:
            valueOfCard = seven;
            break;
        case 3:
            valueOfCard = eight;
            break;
        case 4:
            valueOfCard = nine;
            break;
        case 5:
            valueOfCard = ten;
            break;
        case 6:
            valueOfCard = jack;
            break;
        case 7:
            valueOfCard = queen;
            break;
        case 8:
            valueOfCard = king;
        }
 
        switch(rand() % 4)
        {
        case 0:
            suitOfCard = hearts;
            break;
        case 1:
            suitOfCard = diamonds;
            break;
        case 2:
            suitOfCard = clubs;
            break;
        case 3:
            suitOfCard = spades;
        }
    }
    ~Card() {   }
 
    inline void operator= (Card& op)        { valueOfCard = op.valueOfCard; suitOfCard = op.suitOfCard; }
    inline bool operator==(const Card& op)  { return valueOfCard == op.valueOfCard && suitOfCard == op.suitOfCard; }
    inline suit cardSuit()                  { return suitOfCard; }
    inline value cardValue()                { return valueOfCard; }
    std::string toString()
    {
        std::string ret;
 
        switch (suitOfCard)
        {
        case Card::hearts:
            ret = static_cast<char>(3);
            break;
        case Card::diamonds:
            ret = static_cast<char>(4);
            break;
        case Card::clubs:
            ret = static_cast<char>(5);
            break;
        case Card::spades:
            ret = static_cast<char>(6);
        }
        
        switch(valueOfCard)
        {
        case Card::ace:
            ret += 'A';
            break;
        case Card::six:
            ret += '6';
            break;
        case Card::seven:
            ret += '7';
            break;
        case Card::eight:
            ret += '8';
            break;
        case Card::nine:
            ret += '9';
            break;
        case Card::ten:
            ret += "10";
            break;
        case Card::jack:
            ret += 'J';
            break;
        case Card::queen:
            ret += 'Q';
            break;
        case Card::king:
            ret += 'K';
        }
        return ret;
    }
};
 
bool isOneColor(std::vector<Card>::iterator i)
{
    Card::suit l = i[1].cardSuit(),
               r = i[2].cardSuit();
    return  ( l == Card::spades || l == Card::clubs ) && ( r == Card::spades || r == Card::clubs )
            ||
            ( l == Card::diamonds || l == Card::hearts ) && ( r == Card::diamonds || r == Card::hearts );
}
void strangeOperation(std::vector<Card>& cardBatch)
{
    std::vector<Card>::iterator i = cardBatch.begin() + 3,
                                lim = cardBatch.end();
    int deletedCount = 0, 
        ternarySign = 0;
    while( i + deletedCount < lim)
    {
        if((!ternarySign) && i + deletedCount < lim - 2)
        {
            if( isOneColor(i + deletedCount) )
                ++(++deletedCount);
            ternarySign = 3;
        }
        *i = i[deletedCount];
        --ternarySign;
        ++i;
    }
 
    cardBatch.resize(cardBatch.size() - deletedCount);
}
 
void printCards(std::vector<Card> cardBatch)
{
    for(unsigned i = 0; i < cardBatch.size(); ++i)
        std::cout << cardBatch[i].toString() << '\t';
}
 
void main()
{
    setlocale( LC_ALL, "Russian" );
 
    srand(static_cast<int>(time(0)));
 
    std::vector<Card> cardBatch(36);
    
    std::cout << "Колода случайных карт:\n";
    printCards(cardBatch);
 
    std::cout << '\n';
    
    for(int i = 0; i < 3; ++i)
        strangeOperation(cardBatch);
 
    std::cout << "Колода после удаления карт:\n";
    printCards(cardBatch);
    std::cout << '\n';
}