Beispiel #1
0
def nary_ad_grid(kenken_grid):
    size = kenken_grid[0][0]
    row = []
    col = []
    csp = cspbase.CSP('binary_ne_grid')
    domain = list(range(1, size + 1))
    tuples = itertools.permutations(domain)

    for x in range(1, size + 1):
        row.append([])
        col.append([])
        for y in range(1, size + 1):
            var = cspbase.Variable(str(x) + str(y), domain)
            row[x - 1].append(var)
            csp.add_var(row)
            col[y - 1].append(cspbase.Variable(str(x) + str(y), domain))

    for x in range(0, n):
        r_con = cspbase.Constraint("row " + str(x + 1), row[x])
        c_con = cspbase.Constraint("col " + str(x + 1), col[x])
        r_con.add_satisfying_tuples(tuples)
        c_con.add_satisfying_tuples(tuples)
        csp.add_constraint(r_con)
        csp.add_constraint(c_con)

    return csp, variables
Beispiel #2
0
def binary_ne_grid(kenken_grid):
    size = kenken_grid[0][0]
    variables = []
    csp = cspbase.CSP('binary_ne_grid')
    domain = list(range(1, size + 1))
    tuples = []

    for x in range(1, size + 1):
        variables.append([])
        for y in range(1, size + 1):
            if not x == y:
                tuples.append((x, y))
            var = cspbase.Variable(str(x) + str(y), domain)
            variables[x - 1].append(var)
            csp.add_var(var)

    for x in range(0, size):
        for y in range(1, size):
            for z in range(0, y):
                name = str(x + 1) + str(z + 1) + str(y + 1)
                row = cspbase.Constraint("row " + name,
                                         [variables[x][z], variables[x][y]])
                col = cspbase.Constraint("col " + name,
                                         [variables[z][x], variables[y][x]])
                row.add_satisfying_tuples(tuples)
                col.add_satisfying_tuples(tuples)
                csp.add_constraint(row)
                csp.add_constraint(col)
    return csp, variables
Beispiel #3
0
def nary_ad_grid(kenken_grid):
    #initialize
    naryCSP = cspbase.CSP("nary Grid", [])
    gridSize = kenken_grid[0][0]
    domain = []

    #compute domain values
    for i in range(gridSize):
        domain.append(i + 1)

    #comptue satisfying tuples
    satisfyingTuples = [
        permutation
        for permutation in itertools.permutations(range(1, gridSize + 1))
    ]

    #create an array of variables
    varArray = []

    #create variables
    for i in range(gridSize):
        #for each row
        varArray.append([])
        for j in range(gridSize):
            #create new variable - each coordinate
            newVar = cspbase.Variable("%d%d" % (i + 1, j + 1), domain)
            #add a row element
            varArray[i].append(newVar)
            #add the variable to CSP
            naryCSP.add_var(newVar)

    #create row and column constraints
    #initialize
    rowConstraintDict = {}
    colConstraintDict = {}
    for i in range(gridSize):
        rowConstraintDict[i] = []
        colConstraintDict[i] = []

    #compute scope
    for i in range(gridSize):
        for j in range(gridSize):
            rowConstraintDict[i].append(varArray[i][j])
            colConstraintDict[i].append(varArray[j][i])

    #create constraints
    for i in range(gridSize):
        rowConstraint = cspbase.Constraint("row %d" % i, rowConstraintDict[i])
        colConstraint = cspbase.Constraint("col %d" % i, colConstraintDict[i])
        #add satisfying tuples
        rowConstraint.add_satisfying_tuples(satisfyingTuples)
        colConstraint.add_satisfying_tuples(satisfyingTuples)
        #add to CSP
        naryCSP.add_constraint(rowConstraint)
        naryCSP.add_constraint(colConstraint)

    return naryCSP, varArray
Beispiel #4
0
def binary_ne_grid(kenken_grid):

    #initialize
    binaryCSP = cspbase.CSP("Binary NE Grid", [])
    gridSize = kenken_grid[0][0]
    domain = []
    satisfyingTuples = []
    varArray = []

    #compute domain values
    for i in range(gridSize):
        domain.append(i + 1)

    #comptue satisfying tuples
    for i in range(gridSize):
        for j in range(gridSize):
            if i + 1 != j + 1:
                satisfyingTuples.append((i + 1, j + 1))

    #create variables
    for i in range(gridSize):
        #for each row
        varArray.append([])
        for j in range(gridSize):
            #create new variable - each coordinate
            newVar = cspbase.Variable("%d%d" % (i + 1, j + 1), domain)
            #add a row element
            varArray[i].append(newVar)
            #add the variable to CSP
            binaryCSP.add_var(newVar)

    checked = []
    for i in range(gridSize):

        for j in range(gridSize):
            for k in range(gridSize):
                if j != k:
                    #to prevent double counting
                    #2^a * 3^b * 5^c - results a unique number using two numbers: a, b, and c
                    if (2**j) * (3**k) * (5**i) not in checked:
                        #row
                        #create a constraint
                        newConstraint = cspbase.Constraint(
                            "%d%d not equal %d%d" %
                            (i + 1, j + 1, i + 1, k + 1),
                            [varArray[i][j], varArray[i][k]])
                        #add satisfying tuples
                        newConstraint.add_satisfying_tuples(satisfyingTuples)
                        #add constraint to csp
                        binaryCSP.add_constraint(newConstraint)

                        #column
                        #create a constraint
                        newConstraint = cspbase.Constraint(
                            "%d%d not equal %d%d" %
                            (j + 1, i + 1, k + 1, i + 1),
                            [varArray[j][i], varArray[k][i]])
                        #add satisfying tuples
                        newConstraint.add_satisfying_tuples(satisfyingTuples)
                        #add constraint to csp
                        binaryCSP.add_constraint(newConstraint)
                        #mark as checked - add one for when j and k are switched to prevent double counting
                        checked.append((2**j) * (3**k) * (5**i))
                        checked.append((2**k) * (3**j) * (5**i))

    return binaryCSP, varArray
Beispiel #5
0
def kenken_csp_model(kenken_grid):
    #initialize
    kenCSP = cspbase.CSP("kenken Grid", [])
    gridSize = kenken_grid[0][0]
    domain = []
    satisfyingTuples = []
    varArray = []

    #compute domain values
    for i in range(gridSize):
        domain.append(i + 1)

    #comptue satisfying tuples
    for i in range(gridSize):
        for j in range(gridSize):
            if i + 1 != j + 1:
                satisfyingTuples.append((i + 1, j + 1))

    #create variables
    for i in range(gridSize):
        #for each row
        varArray.append([])
        for j in range(gridSize):
            #create new variable - each coordinate
            newVar = cspbase.Variable("%d%d" % (i + 1, j + 1), domain)
            #add a row element
            varArray[i].append(newVar)
            #add the variable to CSP
            kenCSP.add_var(newVar)

    checked = []
    for i in range(gridSize):

        for j in range(gridSize):
            for k in range(gridSize):
                if j != k:
                    #to prevent double counting
                    #2^a * 3^b * 5^c - results a unique number using two numbers: a, b, and c
                    if (2**j) * (3**k) * (5**i) not in checked:
                        #row
                        #create a constraint
                        newConstraint = cspbase.Constraint(
                            "%d%d not equal %d%d" %
                            (i + 1, j + 1, i + 1, k + 1),
                            [varArray[i][j], varArray[i][k]])
                        #add satisfying tuples
                        newConstraint.add_satisfying_tuples(satisfyingTuples)
                        #add constraint to csp
                        kenCSP.add_constraint(newConstraint)

                        #column
                        #create a constraint
                        newConstraint = cspbase.Constraint(
                            "%d%d not equal %d%d" %
                            (j + 1, i + 1, k + 1, i + 1),
                            [varArray[j][i], varArray[k][i]])
                        #add satisfying tuples
                        newConstraint.add_satisfying_tuples(satisfyingTuples)
                        #add constraint to csp
                        kenCSP.add_constraint(newConstraint)
                        #mark as checked - add one for when j and k are switched to prevent double counting
                        checked.append((2**j) * (3**k) * (5**i))
                        checked.append((2**k) * (3**j) * (5**i))

    #cage constraints
    cageConstraints = kenken_grid[1:]
    #cage constaints dictionary
    cageConstraintsDict = {}

    for i in range(len(cageConstraints)):
        #if cage size is 1
        if len(cageConstraints[i]) == 2:
            varArray[int(str(cageConstraints[i][0])[0]) -
                     1][int(str(cageConstraints[i][0])[1]) - 1].assign(
                         cageConstraints[i][1])
        else:
            target = cageConstraints[i][-2]
            operation = cageConstraints[i][-1]
            cageSize = len(cageConstraints[i]) - 2

            satisfyingTuplesCage = []
            cageDomain = []

            for k in range(cageSize):
                cageDomain.append(domain)

            if cageSize not in cageConstraintsDict:
                #all possible values of cage values
                for possibles in itertools.product(*cageDomain):
                    satisfyingTuplesCage.append(possibles)
                cageConstraintsDict[cageSize] = satisfyingTuplesCage
            else:
                satisfyingTuplesCage = cageConstraintsDict[cageSize]

            #find all possible values for cage variables
            kenkenTuples = []
            #add
            if operation == 0:
                for item in satisfyingTuplesCage:
                    sumItem = 0
                    for j in range(len(item)):
                        sumItem += int(item[j])
                    if sumItem == target:
                        kenkenTuples.append(item)
            #subtract
            elif operation == 1:
                for item in satisfyingTuplesCage:
                    #prevent double checking
                    if item not in kenkenTuples:
                        subItem = int(item[0])
                        for j in range(1, len(item)):
                            subItem -= int(item[j])
                        if subItem == target:
                            #need consider all permutations
                            subAll = [
                                permutation
                                for permutation in itertools.permutations(
                                    item, len(item))
                            ]
                            while len(subAll) > 0:
                                kenkenTuples.append(subAll.pop(0))
            #multiply
            elif operation == 3:
                for item in satisfyingTuplesCage:
                    multItem = int(item[0])
                    for j in range(1, len(item)):
                        multItem *= int(item[j])
                    if multItem == target:
                        kenkenTuples.append(item)
            #divide
            else:
                for item in satisfyingTuplesCage:
                    #prevent double checking
                    if item not in kenkenTuples:
                        perms = itertools.permutations(item)
                        for p in perms:
                            product = 1
                            for i in p[1:]:
                                product = i * product
                            if p[0] / product == target:
                                divAll = [permutation for permutation in perms]
                                while len(divAll) > 0:
                                    kenkenTuples.append(divAll.pop(0))

            if len(kenkenTuples) == 0:
                print("NO SOLUTION FOUND!!!")

            scope = []
            for item in cageConstraints[i][:-2]:
                scope.append(varArray[int(str(item)[0]) -
                                      1][int(str(item)[1]) - 1])

            #add new cage constraint
            newConstraint = cspbase.Constraint("Cage %d" % (i), scope)
            newConstraint.add_satisfying_tuples(kenkenTuples)
            kenCSP.add_constraint(newConstraint)

    return kenCSP, varArray