能让人疯掉的10道题

这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和B相差一个字母）：
A.4个　B.3个　C.2个　D.1个　E.0个

8、答案是元音字母的问题的个数是（注：A和E是元音字母）：
A.2个　B.3个　C.4个　D.5个　E.6个

9、答案是辅音字母的问题的个数是：
A.一个质数　B.一个阶乘数　C.一个平方数　D.一个立方数　E.5的倍数

10、本问题的答案是：
A.A　B.B　C.C　D.D　E.E

这10道题的答案为：　　　　　　　　　　　。

　
以下是用python代码写的算法：

# -*- coding:utf-8 -*-

import itertools

A = 'A'
B = 'B'
C = 'C'
D = 'D'
E = 'E'

def Q1():
    options = {
        A : answer[2],
        B : answer[3],
        C : answer[4],
        D : answer[5],
        E : answer[6],
    }
    option = options[answer[1]]
    return option == B

def Q2():
    options = {
        A : (answer[2], answer[3]),
        B : (answer[3], answer[4]),
        C : (answer[4], answer[5]),
        D : (answer[5], answer[6]),
        E : (answer[6], answer[7]),
    }
    option = options[answer[2]]
    count = sum([(x[0] == x[1]) for x in options.values()])
    return (option[0] == option[1]) and (count == 1)

def Q3():
    options = {
        A : answer[1],
        B : answer[2],
        C : answer[4],
        D : answer[7],
        E : answer[6],
    }
    option = options[answer[3]]
    return option == answer[3]

def Q4():
    options = {
        A : 0,
        B : 1,
        C : 2,
        D : 3,
        E : 4,
    }
    option = options[answer[4]]
    return option == answer.count(A)

def Q5():
    options = {
        A : answer[10],
        B : answer[9],
        C : answer[8],
        D : answer[7],
        E : answer[6],
    }
    option = options[answer[5]]
    return option == answer[5]

def Q6():
    options = {
        A : B,
        B : C,
        C : D,
        D : E,
        E : None,
    }
    option = options[answer[6]]
    if option == None:
        counts = [answer.count(x) for x in [B, C, D, E]]
        return answer.count(A) not in counts
    return answer.count(A) == answer.count(option)

def Q7():
    options = {
        A : 4,
        B : 3,
        C : 2,
        D : 1,
        E : 0,
    }
    option = options[answer[7]]
    return option == abs(ord(answer[7]) - ord(answer[8]))

def Q8():
    options = {
        A : 2,
        B : 3,
        C : 4,
        D : 5,
        E : 6,
    }
    option = options[answer[8]]
    count = answer.count(A) + answer.count(E)
    return option == count

def Q9():
    options = {
        A : (2, 3, 5, 7),
        B : (1, 2, 6),
        C : (0, 1, 4, 9),
        D : (0, 1, 8),
        E : (0, 5),
    }
    option = options[answer[9]]
    count = 10 - answer.count(A) - answer.count(E)
    return count in option

def Q10():
    options = {
        A : A,
        B : B,
        C : C,
        D : D,
        E : E,
    }
    option = options[answer[10]]
    return option == answer[10]

#获取10道题答案的全排列
answers = itertools.product([A, B, C, D, E], repeat=10)
for answer in answers:
    #为了让代码更容易看懂，加了个下标占位符
    answer = [''] + list(answer)
    if Q1() and Q2() and Q3() and Q4() and Q5() and \
       Q6() and Q7() and Q8() and Q9() and Q10():
            print(''.join(answer))
            break

执行结果为：CDEBEEDCBA