4 bags, 9 balls, odd count in each bag

#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <map>
#include <list>
#include <algorithm>
#include <sstream>
#include <time.h>
#include <memory>
#include <set>
#include <cstring>

#include <unordered_map>
#include <string>
#include <type_traits>

//#include <boost/thread.hpp>
#include <vector>
#include <iostream>

using namespace std;

#include <stdio.h>
#include <stdlib.h>
#include <iostream>

int countOdd(int n1, int n2, int n3, int n4)
{
    int nCount = 0;
    if (n1 & 1) nCount++;
    if (n2 & 1) nCount++;
    if (n3 & 1) nCount++;
    if (n4 & 1) nCount++;
    return nCount;
}

void print(int count1)
{
    char buff[2];
    cout << "(" << (count1 == 0 ? "" : itoa(count1, buff, 10));
}

void print_deep(int count1, int count2, int count3, int count4)
{
    print(count1);
    print(count2);
    print(count3);
    print(count4);
    cout << "))))" << endl;
}

void print_deep(int count1, int count2, int count3)
{
    print(count1);
    print(count2);
    print(count3);
    cout << "))";
}

void print_deep(int count1, int count2)
{
    print(count1);
    print(count2);
    cout << "))";
}

void print_deep(int count1)
{
    print(count1);
    cout << ")";
}

void print (int count1, const string & str, int count2)
{
    //cout << "(" << (count1 == 0 ? "" : itoa(count1)) << str << "(" << (count2 == 0 ? "" : itoa(count2));
}

int main()
{
    for (int cBag1 = 0; cBag1 <= 9; cBag1++)
    {
        for (int cBag2 = 0; cBag2 <= 9 - cBag1; cBag2++)
        {
            for (int cBag3 = 0; cBag3 <= 9 - cBag1 - cBag2; cBag3++)
            {
                int cBag4 = 9 - cBag3 - cBag2 - cBag1;
                int cOdd = countOdd(cBag1, cBag2, cBag3, cBag4);

                if (cOdd == 3)
                {
                    // Even bag contains 1 or 3 odd bags; if 1, that one MAY contain the other 2 odd bags, or one of the other 2 remaining odd bags may contain the even bag AND other odd bag
                    int even = !(cBag1 & 1) ? cBag1 : (!(cBag2 & 1) ? cBag2 : (!(cBag3 & 1) ? cBag3 : cBag4));
                    vector<int> odd;
                    if (cBag1 & 1) odd.push_back(cBag1);
                    if (cBag2 & 1) odd.push_back(cBag2);
                    if (cBag3 & 1) odd.push_back(cBag3);
                    if (cBag4 & 1) odd.push_back(cBag4);

                    print(even);
                    print_deep(odd[0]);
                    print_deep(odd[1]);
                    print_deep(odd[2]);
                    cout << ")" << endl;

                    print_deep(even, odd[0]);
                    print_deep(odd[1]);
                    print_deep(odd[2]);
                    cout << endl;
                    print_deep(even, odd[1]);
                    print_deep(odd[0]);
                    print_deep(odd[2]);
                    cout << endl;
                    print_deep(even, odd[2]);
                    print_deep(odd[1]);
                    print_deep(odd[0]);
                    cout << endl;

                    print(even);
                    print(odd[0]);
                    print_deep(odd[1]);
                    print_deep(odd[2]);
                    cout << "))" << endl;
                    print(even);
                    print(odd[1]);
                    print_deep(odd[0]);
                    print_deep(odd[2]);
                    cout << "))" << endl;
                    print(even);
                    print(odd[2]);
                    print_deep(odd[1]);
                    print_deep(odd[0]);
                    cout << "))" << endl;

                    print(odd[0]);
                    print_deep(odd[1]);
                    print_deep(even, odd[2]);
                    cout << ")" << endl;
                    print(odd[0]);
                    print_deep(odd[2]);
                    print_deep(even, odd[1]);
                    cout << ")" << endl;
                    print(odd[1]);
                    print_deep(odd[0]);
                    print_deep(even, odd[2]);
                    cout << ")" << endl;
                    print(odd[1]);
                    print_deep(odd[2]);
                    print_deep(even, odd[0]);
                    cout << ")" << endl;
                }
                else if(cOdd == 2)
                {
                    // each even bag contains 1 of the odd bags, OR one even bag contains the other even bag, which itself contains an odd bag, OR one even bag contains an odd AND even bag,
                    // with the contained even bag itself containing the other odd bag
                    vector<int> even;
                    vector<int> odd;
                    (cBag1 & 1) ? odd.push_back(cBag1) : even.push_back(cBag1);
                    (cBag1 & 1) ? odd.push_back(cBag2) : even.push_back(cBag2);
                    (cBag1 & 1) ? odd.push_back(cBag3) : even.push_back(cBag3);
                    (cBag1 & 1) ? odd.push_back(cBag4) : even.push_back(cBag4);

                    print_deep(even[0], odd[0]);
                    print_deep(even[1], odd[1]);
                    cout << endl;
                    print_deep(even[0], odd[1]);
                    print_deep(even[1], odd[0]);
                    cout << endl;

                    print_deep(even[0], even[1], odd[0]);
                    print_deep(odd[1]);
                    cout << endl;
                    print_deep(even[0], even[1], odd[1]);
                    print_deep(odd[0]);
                    cout << endl;
                    print_deep(even[1], even[0], odd[0]);
                    print_deep(odd[1]);
                    cout << endl;
                    print_deep(even[1], even[0], odd[1]);
                    print_deep(odd[0]);
                    cout << endl;

                    print(even[0]);
                    print_deep(odd[0]);
                    print_deep(even[1], odd[1]);
                    cout << ")" << endl;
                    print(even[0]);
                    print_deep(odd[1]);
                    print_deep(even[1], odd[0]);
                    cout << ")" << endl;
                    print(even[1]);
                    print_deep(odd[0]);
                    print_deep(even[0], odd[1]);
                    cout << ")" << endl;
                    print(even[1]);
                    print_deep(odd[1]);
                    print_deep(even[0], odd[0]);
                    cout << ")" << endl;


                }
                else // cOdd = 1
                {
                    // the odd bag is contained in an even bag, which is contained in an even bag, which is itself in an even bag, so
                    // ((((9)))), (2(2(4(1)))), (4((2(3)))), etc
                    int odd = cBag1 & 1 ? cBag1 : (cBag2 & 1 ? cBag2 : (cBag3 & 1 ? cBag3 : cBag4));
                    vector<int> even;
                    if (!(cBag1 & 1)) even.push_back(cBag1);
                    if (!(cBag2 & 1)) even.push_back(cBag2);
                    if (!(cBag3 & 1)) even.push_back(cBag3);
                    if (!(cBag4 & 1)) even.push_back(cBag4);

                    print_deep(even[0], even[1], even[2], odd);
                    print_deep(even[0], even[2], even[1], odd);
                    print_deep(even[1], even[0], even[2], odd);
                    print_deep(even[1], even[2], even[0], odd);
                    print_deep(even[2], even[0], even[1], odd);
                    print_deep(even[2], even[1], even[0], odd);
                }
            }
        }
    }
}