2018-detective.py

#!/usr/bin/env python3
from constraint import *
from collections import Counter
problem = Problem()

opts = ['A', 'B', 'C', 'D']
for i in range(1, 10 + 1):
    problem.addVariable(str(i), ['A', 'B', 'C', 'D'])

q2m = {
    'A': 'C',
    'B': 'D',
    'C': 'A',
    'D': 'B'
}

def q2(*args):
    return args[1] == q2m[args[4]]

def q3(*args):
    q3m = [
        args[2],
        args[5],
        args[3],
        args[1]
    ]
    c = Counter(q3m)
    diffVal = min(c, key=lambda k: c[k])
    ans = None
    for i in range(len(q3m)):
        if q3m[i] == diffVal:
            ans = opts[i]
            break
    return args[2] == ans

def q4(*args):
    q4m = [
        args[0] == args[4],
        args[1] == args[6],
        args[0] == args[8],
        args[5] == args[9]
    ]
    ans = None
    for i, b in enumerate(q4m):
        if b:
            ans = opts[i]
            break
    return args[3] == ans


def q5(*args):
    q5m = [
        args[7],
        args[3],
        args[8],
        args[6]
    ]
    ans = None
    for i, v in enumerate(q5m):
        if v == args[4]:
            ans = opts[i]
            break
    return args[4] == ans


def q6(*args):
    q6m = [
        (args[1], args[3]),
        (args[0], args[5]),
        (args[2], args[9]),
        (args[4], args[8]),
    ]
    ans = None
    for i, t in enumerate(q6m):
        if t[0] == args[7] and t[1] == args[7]:
            ans = opts[i]
            break
    return args[5] == ans

q7m = ['C', 'B', 'A', 'D']
def q7(*args):
    c = Counter(args)
    minVal = min(c, key=lambda k: c[k])
    ans = None
    for i, o in enumerate(q7m):
        if o == minVal:
            ans = opts[i]
            break
    return args[6] == ans

not_neighbors = {
    'A': ('A', 'C', 'D'),
    'B': ('B', 'D'),
    'C': ('A', 'C'),
    'D': ('A', 'B', 'D'),
}
def q8(*args):
    q8m = [
        args[6],
        args[4],
        args[1],
        args[9]
    ]
    nn = not_neighbors[args[0]]
    ans = None
    for i, o in enumerate(q8m):
        if o in nn:
            ans = opts[i]
            break
    return args[7] == ans

def q9(*args):
    q9m = [
        args[5],
        args[9],
        args[1],
        args[8]
    ]
    ans = None
    for i, o in enumerate(q9m):
        if (args[0] == args[5]) ^ (o == args[4]):
            ans = opts[i]
            break
    return args[8] == ans

q10m = [3, 2, 4, 1]
def q10(*args):
    c = Counter(args)
    max_v = max(c.values())
    min_v = min(c.values())
    diff = max_v - min_v
    ans = None
    for i, o in enumerate(q10m):
        if diff == o:
            ans = opts[i]
            break
    return args[9] == ans

problem.addConstraint(q2)
problem.addConstraint(q3)
problem.addConstraint(q4)
problem.addConstraint(q5)
problem.addConstraint(q6)
problem.addConstraint(q7)
problem.addConstraint(q8)
problem.addConstraint(q9)
problem.addConstraint(q10)

print(problem.getSolutions())