题面

1. 这道题的答案是():  A:A B:B C:C D:D
2. 第五题的答案是():  A:C B:D C:A D:B
3. 与其他三个答案不同的是():
  A: 第3题  B: 第6题  C: 第2题  D: 第4题
4. 以下选项两题答案相同的是():
  A: 第1,5题  B: 第2,7题  C: 第1,9题  D: 第6,10题
5. 以下哪个答案与本题相同():
  A: 第8题  B: 第4题  C: 第9题  D: 第7题
6. 以下哪两个答案与8题相同():
  A: 第2,4题  B: 第1,6题  C: 第3,10题  D: 第5,9题
7. 在此十题答案中被选中字母次数最少的是():
  A: C  B: B  C: A  D: D
8. 以下哪个答案与1题的答案在字母表中不相邻():
  A: 第7题  B: 第5题  C: 第2题  D: 第10题
9. 已知 “第1题与第6题的答案相同” 与 “第X题与第5题的答案相同” 的真假性相反，那么X为():
  A: 6  B: 10  C: 2  D: 9
10. 在此十题答案中字母ABCD出现最多次数与最少者差():
  A: 3  B: 2  C: 4  D: 1

以下为JavaScript代码翻译

const valid = (a) => {
    const eq = (m, n, x, y) => a[m] === a[n] && (!x || a[n] === a[x]) && (!y || a[x] === a[y])
    const map = a.reduce((m, item) => {
        m[item] = (m[item] || 0) + 1
        return m
    }, {})
    const [min, middle1, middle2, max] = [1,2,3,4].sort((m, n) => map[m] - map[n])

    return true &&
    // 2 第二题和第五题答案存在映射关系
    [undefined, 3, 4, 1, 2][a[2]] === a[5] &&
    // 3 只有一个跟其它不一样，可以解释为有两种值，（其实更严谨的做法需要再加上其中一种值的次数是奇数）
    new Set([a[3], a[6], a[2], a[4]]).size === 2 &&
    // 4 只有一组相同
    [eq(1, 5), eq(2, 7), eq(1, 9), eq(6, 10)].filter(n => !n).length === 1  &&
    // 5 只有一个相同 同 4
    [8, 4, 9, 7].filter(n => a[n] === a[5]).length === 1 &&
    // 6 还是一样的套路 同 4，5
    [eq(8, 2, 4), eq(8, 1, 6), eq(8, 3, 10), eq(8, 5, 9)].filter(n => n).length === 1 &&
    // 7 最小次数已经算出，映射关系
    [undefined, 3, 2, 1, 4][a[7]] === min &&
    // 8 相邻就是差值不大于1
    [7, 5, 2, 10].filter(n => Math.abs(a[1] - a[n]) > 1).length === 1 &&
    // 9 两个条件结果取反， 也就是eq(1,6) != eq(x,5)
    [6, 10, 2, 9].filter(x => eq(1, 6) != eq(x, 5)).length === 1 &&
    // 10 同 7
    [undefined, 3, 2, 4, 1][a[10]] === map[max] - map[min] && 
    true
}


for (let i = 1; i < Math.pow(4, 10); i++) {
    let arr = Array(10).fill(0).map((n, index) => {
        if (index) {
            return Math.floor(i / Math.pow(4, index)) % 4 + 1
        } else {
            return i % 4 + 1
        }
    })
    if (valid([undefined].concat(arr))) {
        console.log(arr.map(i => 'ABCD'[i - 1]))
    }
}

Result: [ 'C', 'A', 'B', 'A', 'C', 'B', 'D', 'A', 'C', 'B' ]