Set URIONLINE JUDGE

#include <iostream>
#include <string> //getline
#include <cstring> //memset
#include <fstream>

using std::cin;
using std::cout;
using std::string;


enum figure_
{
    square,
    circle,
    triangle
};

enum quantity_
{
    one =1,
    two =2,
    three =3
};

constexpr int figureMax = triangle+1;
constexpr int quantityMax = three+1;

long int CardDeck[figureMax][quantityMax];

int finds = 0;


struct card
{
    short qnty;
    figure_ figure;
    card(short n, figure_ f) : qnty(n), figure(f) {}
};

card GetCard(std::string cardRead);

inline void DecreaseFromDeck(figure_ figure, quantity_ qnty)
{
    if(CardDeck[figure][qnty] == 0)
    {
        std::cout << "WTFFFFFFFFFFFFFFFFFF\n\n\n\n\n\n";
    }
    CardDeck[figure][qnty]--;
}

void AddCardToDeck(figure_ figure, quantity_ qnty)
{
    CardDeck[figure][qnty]++;
}

bool isPossibleMatch(figure_ figure, quantity_ qnty);

void FinishHim()
{
    for(int fig=0; fig<figureMax; fig++)
    {
        for(int numof=static_cast<int>(one); numof<quantityMax; numof++)
        {
            if(CardDeck[fig][numof] == 0) //do not lookup 0 card OH-hohoho
                continue;

            while(isPossibleMatch(static_cast<figure_>(fig), static_cast<quantity_>(numof)))
            {
                DecreaseFromDeck(static_cast<figure_>(fig), static_cast<quantity_>(numof));
                finds++;

                if(CardDeck[fig][numof] == 0)
                    break;
            }
        }
    }
}

void WipeOUT()
{
    finds = 0;
    memset(CardDeck, 0, sizeof(CardDeck));
}

int main()
{
    //

/*
    std::ifstream file("C:\\Users\\10274637626\\Documents\\ff.txt");
    std::string str;
    while(std::getline(file, str))
    {
        if(str.size() < 2)
        {
            FinishHim();
            std::cout << finds << std::endl;
            WipeOUT();

        }else{
            card c = GetCard(str);
          AddCardToDeck( c.figure, static_cast<quantity_>(c.qnty) );
        }
    }
*/


    int i{0};
    int numofcards{0};
    string cardRead;

    cin >> numofcards;


    while(numofcards != 0)
    {
        std::cin.ignore();

        for(i=0; i<numofcards; i++)
        {
            std::getline(std::cin, cardRead);
            card c = GetCard(cardRead);
            AddCardToDeck( c.figure, static_cast<quantity_>(c.qnty) );
        }

        FinishHim();

        cout << finds << std::endl;

        WipeOUT();

        cin >> numofcards;
    }

    return 0;
}

card GetCard(std::string cardRead)
{
    if(cardRead.compare("um quadrado") == 0) return card(1, square);
    else if(cardRead.compare("dois quadrados") == 0) return card(2, square);
    else if(cardRead.compare("tres quadrados") == 0) return card(3, square);
    else if(cardRead.compare("um triangulo") == 0) return card(1, triangle);
    else if(cardRead.compare("dois triangulos") == 0) return card(2, triangle);
    else if(cardRead.compare("tres triangulos") == 0) return card(3, triangle);
    else if(cardRead.compare("um circulo") == 0) return card(1, circle);
    else if(cardRead.compare("dois circulos") == 0) return card(2, circle);
    else if(cardRead.compare("tres circulos") == 0) return card(3, circle);

    int *p = 0;
    *p++;


    return card(0, (figure_)0);
}

bool isPossibleMatch(figure_ figure, quantity_ qnty)
{
    if(figure == square)
    {
        if(qnty == one)
        {

            if(CardDeck[circle][two] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(circle, two);
                DecreaseFromDeck(triangle, three);
                return true;
            }
            if(CardDeck[triangle][two] && CardDeck[circle][three])
            {
                DecreaseFromDeck(triangle, two);
                DecreaseFromDeck(circle, three);
                return true;
            }
            if(CardDeck[square][two] && CardDeck[square][three])
            {
                DecreaseFromDeck(square, two);
                DecreaseFromDeck(square, three);
                return true;
            }
        } else
        if(qnty == two)
        {

            if(CardDeck[circle][one] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(triangle, three);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[circle][three])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(circle, three);
                return true;
            }
            if(CardDeck[square][one] && CardDeck[square][three])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(square, three);
                return true;
            }
        }else
        if(qnty == three)
        {

            if(CardDeck[circle][one] && CardDeck[triangle][two])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(triangle, two);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[circle][two])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(circle, two);
                return true;
            }
            if(CardDeck[square][one] && CardDeck[square][two])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(square, two);
                return true;
            }
        }
    }else
    if(figure == circle)
    {
        if(qnty == one)
        {

            if(CardDeck[square][two] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(square, two);
                DecreaseFromDeck(triangle, three);
                return true;
            }
            if(CardDeck[triangle][two] && CardDeck[square][three])
            {
                DecreaseFromDeck(triangle, two);
                DecreaseFromDeck(square, three);
                return true;
            }
            if(CardDeck[circle][two] && CardDeck[circle][three])
            {
                DecreaseFromDeck(circle, two);
                DecreaseFromDeck(circle, three);
                return true;
            }
        } else
        if(qnty == two)
        {

            if(CardDeck[square][one] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(triangle, three);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[square][three])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(square, three);
                return true;
            }
            if(CardDeck[circle][one] && CardDeck[circle][three])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(circle, three);
                return true;
            }
        }else
        if(qnty == three)
        {

            if(CardDeck[square][one] && CardDeck[triangle][two])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(triangle, two);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[square][two])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(square, two);
                return true;
            }
            if(CardDeck[circle][one] && CardDeck[circle][two])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(circle, two);
                return true;
            }
        }
    }else
    if(figure == triangle)
    {
        if(qnty == one)
        {

            if(CardDeck[square][two] && CardDeck[circle][three])
            {
                DecreaseFromDeck(square, two);
                DecreaseFromDeck(circle, three);
                return true;
            }
            if(CardDeck[circle][two] && CardDeck[square][three])
            {
                DecreaseFromDeck(circle, two);
                DecreaseFromDeck(square, three);
                return true;
            }
            if(CardDeck[triangle][two] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(triangle, two);
                DecreaseFromDeck(triangle, three);
                return true;
            }
        } else
        if(qnty == two)
        {

            if(CardDeck[square][one] && CardDeck[circle][three])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(circle, three);
                return true;
            }
            if(CardDeck[circle][one] && CardDeck[square][three])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(square, three);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[triangle][three])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(triangle, three);
                return true;
            }
        }else
        if(qnty == three)
        {

            if(CardDeck[square][one] && CardDeck[circle][two])
            {
                DecreaseFromDeck(square, one);
                DecreaseFromDeck(circle, two);
                return true;
            }
            if(CardDeck[circle][one] && CardDeck[square][two])
            {
                DecreaseFromDeck(circle, one);
                DecreaseFromDeck(square, two);
                return true;
            }
            if(CardDeck[triangle][one] && CardDeck[triangle][two])
            {
                DecreaseFromDeck(triangle, one);
                DecreaseFromDeck(triangle, two);
                return true;
            }
        }
    }


    if(CardDeck[figure][qnty] > 2)
    {
        DecreaseFromDeck(figure, qnty);
        DecreaseFromDeck(figure, qnty);
        return true;
    }

    return false;
}