请回答下面10 个问题：
1、第一个答案是b 的问题是哪一个？
（a）2；（b） 3；（c）4；（d）5；（e）6
2、唯一的连续两个具有相同答案的问题是：
（a）2，3；（b）3，4；（c）4，5；（d）5，6；（e）6，7；
3、本问题答案和哪一个问题的答案相同？
（a）1；（b）2；（c）4；（d）7；（e）6
4、答案是a 的问题的个数是：
（a）0；（b）1；（c）2；（d）3；（e）4
5、本问题答案和哪一个问题的答案相同？
（a）10；（b）9；（c）8；（d）7；（e）6
6、答案是a 的问题的个数和答案是什么的问题的个数相同？
（a）b；（b）c；（c）d；（d）e；（e）以上都不是
7、按照字母顺序，本问题的答案和下一个问题的答案相差几个字母？
（a）4；（b）3；（c）2；（d）1；（e）0。（注：a 和b 相差一个字母）
8、答案是元音字母的问题的个数是：
（a）2；（b）3；（c）4；（d）5；（e）6。（注：a 和e 是元音字母）
9、答案是辅音字母的问题的个数是：
（a）一个质数；（b）一个阶乘数；（c）一个平方数；（d）一个立方数，（e）5 的倍数
10、本问题的答案是：
（a）a；（b）b；（c）c；（d）d；（e）e

#include <iostream>
using namespace std;

//-----------------------------------------------------
// 辅助函数

// 获取答案为A的个数
int getACount(char* answer)
{
    int count = 0;

    for(int i=0; i<10; ++i)
    {
        if('a' == answer[i])
        {
            ++count;
        }
    }

    return count;
}

// 获取答案为B的个数
int getBCount(char* answer)
{
    int count = 0;

    for(int i=0; i<10; ++i)
    {
        if('b' == answer[i])
        {
            ++count;
        }
    }

    return count;
}

// 获取答案为C的个数
int getCCount(char* answer)
{
    int count = 0;

    for(int i=0; i<10; ++i)
    {
        if('c' == answer[i])
        {
            ++count;
        }
    }

    return count;
}

// 获取答案为D的个数
int getDCount(char* answer)
{
    int count = 0;

    for(int i=0; i<10; ++i)
    {
        if('d' == answer[i])
        {
            ++count;
        }
    }

    return count;
}

// 获取答案为E的个数
int getECount(char* answer)
{
    int count = 0;

    for(int i=0; i<10; ++i)
    {
        if('e' == answer[i])
        {
            ++count;
        }
    }

    return count;
}

// 获取答案为元音的总数
int getYYCount(char* answer)
{
    return getACount(answer)+getECount(answer);
}

// 获取答案为辅音的总数
int getFYCount(char* answer)
{
    return getBCount(answer)+getCCount(answer)+getDCount(answer);
}

//-----------------------------------------------------
//判断函数

// 1、第一个答案是b 的问题是哪一个？
//（a）2；（b） 3；（c）4；（d）5；（e）6
bool check1(char* answer)
{
    int bPos = 0;
    for(int i=0; i<10; ++i)
    {
        if('b' == answer[i])
        {
            bPos = i+1;
            break;
        }
    }

    switch(answer[0])
    {
    case 'a':
        {
            return (2 == bPos);
        }
        break;

    case 'b':
        {
            return (3 == bPos);
        }
        break;

    case 'c':
        {
            return (4 == bPos);
        }
        break;

    case 'd':
        {
            return (5 == bPos);
        }
        break;

    case 'e':
        {
            return (6 == bPos);
        }
        break;
    }

    return false;
}

// 2、唯一的连续两个具有相同答案的问题是：
//（a）2，3；（0b）3，4；（c）4，5；（d）5，6；（e）6，7；
bool check2(char* answer)
{
    // 判断唯一
    bool bFind = false; // 标记是否找到连续相同的了
    for(int i=0; i<9; ++i)
    {
        if(answer[i] == answer[i+1])
        {
            if(bFind)
            {
                return false;
            }
            else
            {
                bFind = true;
            }
        }
    }

    // 判断相同
    switch(answer[1])
    {
    case 'a':
        {
            return (answer[1] == answer[2]);
        }
        break;

    case 'b':
        {
            return (answer[2] == answer[3]);
        }
        break;

    case 'c':
        {
            return (answer[3] == answer[4]);
        }
        break;

    case 'd':
        {
            return (answer[4] == answer[5]);
        }
        break;
    case 'e':
        {
            return (answer[5] == answer[6]);
        }
        break;
    }

    return false;
}

// 3、本问题答案和哪一个问题的答案相同？
//（a）1；（b）2；（c）4；（d）7；（e）6
bool check3(char* answer)
{
    switch(answer[2])
    {
    case 'a':
        {
            return (answer[2] == answer[0]);
        }
        break;

    case 'b':
        {
            return (answer[2] == answer[1]);
        }
        break;

    case 'c':
        {
            return (answer[2] == answer[3]);
        }
        break;

    case 'd':
        {
            return (answer[2] == answer[6]);
        }
        break;
    case 'e':
        {
            return (answer[2] == answer[5]);
        }
        break;
    }

    return false;
}

// 4、答案是a 的问题的个数是：
//（a）0；（b）1；（c）2；（d）3；（e）4
bool check4(char* answer)
{
    int numA = getACount(answer);

    switch(answer[3])
    {
    case 'a':
        {
            return (0 == numA);
        }
        break;

    case 'b':
        {
            return (1 == numA);
        }
        break;

    case 'c':
        {
            return (2 == numA);
        }
        break;

    case 'd':
        {
            return (3 == numA);
        }
        break;
    case 'e':
        {
            return (4 == numA);
        }
        break;
    }

    return false;
}

// 5、本问题答案和哪一个问题的答案相同？
//（a）10；（b）9；（c）8；（d）7；（e）6
bool check5(char* answer)
{
    switch(answer[4])
    {
    case 'a':
        {
            return (answer[4] == answer[9]);
        }
        break;

    case 'b':
        {
            return (answer[4] == answer[8]);
        }
        break;

    case 'c':
        {
            return (answer[4] == answer[7]);
        }
        break;

    case 'd':
        {
            return (answer[4] == answer[6]);
        }
        break;
    case 'e':
        {
            return (answer[4] == answer[5]);
        }
        break;
    }

    return false;
}

// 6、答案是a 的问题的个数和答案是什么的问题的个数相同？
//（a）b；（b）c；（c）d；（d）e；（e）以上都不是
bool check6(char* answer)
{
    switch(answer[5])
    {
    case 'a':
        {
            return (getACount(answer) == getBCount(answer));
        }
        break;

    case 'b':
        {
            return (getACount(answer) == getCCount(answer));
        }
        break;

    case 'c':
        {
            return (getACount(answer) == getDCount(answer));
        }
        break;

    case 'd':
        {
            return (getACount(answer) == getECount(answer));
        }
        break;
    case 'e':
        {
            return !((getACount(answer) == getBCount(answer)) || (getACount(answer) == getCCount(answer)) ||
                (getACount(answer) == getDCount(answer)) || (getACount(answer) == getECount(answer)));
        }
        break;
    }

    return false;
}

// 7、按照字母顺序，本问题的答案和下一个问题的答案相差几个字母？
//（a）4；（b）3；（c）2；（d）1；（e）0。（注：a 和b 相差一个字母）
bool check7(char* answer)
{
    switch(answer[6])
    {
    case 'a':
        {
            return (4==(answer[6]-answer[7]) || -4==(answer[6]-answer[7]));
        }
        break;

    case 'b':
        {
            return (3==(answer[6]-answer[7]) || -3==(answer[6]-answer[7]));
        }
        break;

    case 'c':
        {
            return (2==(answer[6]-answer[7]) || -2==(answer[6]-answer[7]));
        }
        break;

    case 'd':
        {
            return (1==(answer[6]-answer[7]) || -1==(answer[6]-answer[7]));
        }
        break;
    case 'e':
        {
            {
                return (0==(answer[6]-answer[7]));
            }
        }
        break;
    }

    return false;
}

// 8、答案是元音字母的问题的个数是：
//（a）2；（b）3；（c）4；（d）5；（e）6。（注：a 和e 是元音字母）
bool check8(char* answer)
{
    switch(answer[7])
    {
    case 'a':
        {
            return (2 == getYYCount(answer));
        }
        break;

    case 'b':
        {
            return (3 == getYYCount(answer));
        }
        break;

    case 'c':
        {
            return (4 == getYYCount(answer));
        }
        break;

    case 'd':
        {
            return (5 == getYYCount(answer));
        }
        break;
    case 'e':
        {
            return (6 == getYYCount(answer));
        }
        break;
    }

    return false;
}

// 9、答案是辅音字母的问题的个数是：
//（a）一个质数；（b）一个阶乘数；（c）一个平方数；（d）一个立方数，（e）5 的倍数
bool check9(char* answer)
{
    int fyNum = getFYCount(answer);

    switch(answer[8])
    {
    case 'a':
        {
            return (2==fyNum || 3==fyNum || 5==fyNum || 7==fyNum);
        }
        break;

    case 'b':
        {
            return (1==fyNum || 2==fyNum || 6==fyNum);
        }
        break;

    case 'c':
        {
            return (1==fyNum || 4==fyNum || 9==fyNum);
        }
        break;

    case 'd':
        {
            return (1==fyNum || 8==fyNum);
        }
        break;
    case 'e':
        {
            return (5==fyNum || 10==fyNum);
        }
        break;
    }

    return false;
}

// 10、本问题的答案是：
//（a）a；（b）b；（c）c；（d）d；（e）e
bool check10(char* answer)
{
    switch(answer[9])
    {
    case 'a':
        {
            return ('a' == answer[9]);
        }
        break;

    case 'b':
        {
            return ('b' == answer[9]);
        }
        break;

    case 'c':
        {
            return ('c' == answer[9]);
        }
        break;

    case 'd':
        {
            return ('d' == answer[9]);
        }
        break;

    case 'e':
        {
            return ('e' == answer[9]);
        }
        break;
    }

    return false;
}

void check(char* a)
{
    if(check1(a))
    {
        if(check2(a))
        {
            if(check3(a))
            {
                if(check4(a))
                {
                    if(check5(a))
                    {
                        if(check6(a))
                        {
                            if(check7(a))
                            {
                                if(check8(a))
                                {
                                    if(check9(a))
                                    {
                                        if(check10(a))
                                        {
                                            cout << "got answer!" << endl;
                                            for(int i=0; i<10; ++i)
                                            {
                                                cout <<i+1 << " : " << a[i] << endl;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

int main()
{
    char answer[10] = {'a'};

    for(char a1='a'; a1<='e'; ++a1)
    {
        answer[0] = a1;
        for(char a2='a'; a2<='e'; ++a2)
        {
            answer[1] = a2;
            for(char a3='a'; a3<='e'; ++a3)
            {
                answer[2] = a3;
                for(char a4='a'; a4<='e'; ++a4)
                {
                    answer[3] = a4;
                    for(char a5='a'; a5<='e'; ++a5)
                    {
                        answer[4] = a5;
                        for(char a6='a'; a6<='e'; ++a6)
                        {
                            answer[5] = a6;
                            for(char a7='a'; a7<='e'; ++a7)
                            {
                                answer[6] = a7;
                                for(char a8='a'; a8<='e'; ++a8)
                                {
                                    answer[7] = a8;
                                    for(char a9='a'; a9<='e'; ++a9)
                                    {
                                        answer[8] = a9;
                                        for(char a10='a'; a10<='e'; ++a10)
                                        {
                                            answer[9] = a10;

                                            check(answer);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

        }
    }
}