6
$\begingroup$

Complete the grid shown below with the digits 1 to 6 to make the sum correct.

Perform each mathematical operation in the order shown, from left to right, e.g. 1 + 2 x 3 is treated as (1 + 2) x 3 = 9.

Note: there is no ÷ 1, and at no point is a decimal or fraction used.

$$[\;\;\;\;] + [\;\;\;\;] - [\;\;\;\;] * [\;\;\;\;] \div [\;\;\;\;] * [\;\;\;\;] = 50$$

The $[\;\;\;\;]$ are empty spaces and must be filled with numbers.

$\endgroup$
8
$\begingroup$

I was just a little slower than Bailey, but to add further detail:

You start by working out that the last number can only be:

5,2 or 1: 5 is more likely as it involves a smaller answer to using the other numbers

This makes:

[ ] + [ ] - [ ] x [ ] ÷ [ ] = 10

You now want a small number to divide by, that isn't 1 - so this should either be 2 or 3 making

[ ] + [ ] - [ ] x [ ] = 20

Or

[ ] + [ ] - [ ] x [ ] = 30

With the 4 numbers and 3 sums remaining, it is impossible to make the former and are forced down the latter route to create:

4 + 2 - 1 x 6 / 3 x 5 = 50

$\endgroup$
  • 1
    $\begingroup$ I went through the exact same thought process as this - I just so happened to try ÷3 first, which gave me a correct answer and therefore no reason to try ÷2. $\endgroup$ – Bailey M Jun 8 '15 at 16:03
8
$\begingroup$

I "cheated" and wrote a Python script that used the Johnson-Trotter algorithm to permute the order of the numbers that are plugged into the equation. My script spits out 6 possible solutions:

3 + 6 - 4 x 5 ÷ 1 x 2
6 + 3 - 4 x 5 ÷ 1 x 2
6 + 3 - 4 x 2 ÷ 1 x 5
3 + 6 - 4 x 2 ÷ 1 x 5
4 + 2 - 1 x 6 ÷ 3 x 5
2 + 4 - 1 x 6 ÷ 3 x 5

Though, given the extra conditions of the puzzle (no ÷1 and never dealing with decimals/fractions), you're left with 2 solutions because addition is commutative.

4 + 2 - 1 x 6 ÷ 3 x 5
2 + 4 - 1 x 6 ÷ 3 x 5

I'm sure the pen-and-paper method accomplished above is probably more satisfying to perform, though!


Python Source

Play with the code here.

This is just a Johnson-Trotter permutation class I wrote. It uses a step function to go to the next permutation. I thought about making an iterator version, but was too lazy =/. It may be a little lengthy, but it can be used to permute any list of objects. I'm sure it could be improved and condensed; I just threw this together for this puzzle =P

jtpermute.py

class JohnsonTrotterPermute(object):
    objlist = []   # contains the objects given to the class
    nodelist = []  # contains the JTNode objects that wrap around each given object
    numnodes = 0   # the current number of nodes added (for numbering)
    steps = 1      # the number of iterations generated (number of steps)

    def __init__(self, objlist):
        self.objlist = objlist
        for obj in self.objlist:
            self.nodelist.append(JTNode(self.numnodes, obj))
            self.numnodes += 1

    # returns True if there exists at least one mobile JTNode
    def has_mobile(self):
        for i in range(len(self.nodelist)):
            if self.check_mobility(i):
                return True
        return False

    # returns True if the JTNode at the given index is mobile
    def check_mobility(self, index):
        if index < 0 or index >= len(self.nodelist):
            return False
        if self.nodelist[index].direction == -1: # pointing left
            if index == 0: # on the left edge of list
                return False
            if self.nodelist[index].num > self.nodelist[index - 1].num:
                return True
        if self.nodelist[index].direction == 1:  # pointing right
            if index == len(self.nodelist) - 1:  # on the right edge of list
                return False
            if self.nodelist[index].num > self.nodelist[index + 1].num:
                return True
        return False

    # iterates through the nodes and flips the direction of any node
    # whose .num is larger than the given number
    def flip_larger_than_num(self, num):
        for node in self.nodelist:
            if (node.num > num):
                node.flip()

    # returns the index of the JTNode that has the largest .num value
    # and is mobile
    def get_largest_mobile_index(self):
        index = -1
        largest = -1
        for i in range(len(self.nodelist)):
            if self.nodelist[i].num > largest and self.check_mobility(i):
                largest = self.nodelist[i].num
                index = i
        return index

    # swaps the node at the given index with the node that it's pointing
    # at. Returns True if the swap is successful, False if the swap fails
    # (e.g. the node is pointing left, but it's the left-most node)
    def move_node(self, index):
        node = self.nodelist[index]
        tempnode = None
        if node.direction == -1: # pointed left
            if index == 0: # on left edge of list
                return False
            tempnode = self.nodelist[index]
            self.nodelist[index] = self.nodelist[index - 1]
            self.nodelist[index - 1] = tempnode
            self.flip_larger_than_num(tempnode.num)
        if node.direction == 1: # pointed right
            if index == len(self.nodelist) - 1: # on right edge of list
                return False
            tempnode = self.nodelist[index]
            self.nodelist[index] = self.nodelist[index + 1]
            self.nodelist[index + 1] = tempnode
            self.flip_larger_than_num(tempnode.num)
        return True

    # steps the list order to its next iteration
    def step(self):
        if self.has_mobile():
            largest_mobile = self.get_largest_mobile_index()
            self.move_node(largest_mobile)
            self.steps += 1
            return True
        return False

    # returns the list of items that the user initially provided in the
    # order of the current iteration
    def get_items(self):
        returnlist = []
        for node in self.nodelist:
            returnlist.append(node.obj)
        return returnlist



# a wrapper class for the list items the user will provide
class JTNode(object):
    obj = None      # the actual user-provided list item
    num = -1        # the number of the node
    direction = -1  # pointing direction (-1 -> left, 1 -> right)

    def __init__(self, num, obj):
        self.obj = obj
        self.num = num

    # flip the direction the node is pointing
    def flip(self):
        self.direction *= -1

puzzle.py

from jtpermute import *

# computes the puzzle equation on the given list of integers
def do_maths(intlist):
    if len(intlist) < 6:
        return 0
    num = intlist[0]
    num += intlist[1]
    num -= intlist[2]
    num *= intlist[3]
    num /= intlist[4]
    num *= intlist[5]
    return num

# prints the puzzle's function with the numbers plugged in
def print_maths(intlist):
    if len(intlist) < 6:
        return 0
    # a string builder of sorts
    strlist = []
    strlist.append(str(intlist[0]))
    strlist.append(" + ")
    strlist.append(str(intlist[1]))
    strlist.append(" - ")
    strlist.append(str(intlist[2]))
    strlist.append(" * ")
    strlist.append(str(intlist[3]))
    strlist.append(" / ")
    strlist.append(str(intlist[4]))
    strlist.append(" * ")
    strlist.append(str(intlist[5]))
    strlist.append(" = ")
    strlist.append(str(do_maths(intlist)))
    print "".join(strlist)

jtp = JohnsonTrotterPermute([1, 2, 3, 4, 5, 6])
# the equivalent of a do-while loop in Python. I wanted to put the
# step function in the loop conditional, but it had to be evaluated
# before the first .step call. When the step function returns False,
# it has reached the end of the permutations
while True:
    if do_maths(jtp.get_items()) == 50:
        print_maths(jtp.get_items())
    if jtp.step() == False:
        break
print "Number of permutations: %d" % jtp.steps

Output of puzzle.py

3 + 6 - 4 * 5 / 1 * 2 = 50
6 + 3 - 4 * 5 / 1 * 2 = 50
6 + 3 - 4 * 2 / 1 * 5 = 50
3 + 6 - 4 * 2 / 1 * 5 = 50
4 + 2 - 1 * 6 / 3 * 5 = 50
2 + 4 - 1 * 6 / 3 * 5 = 50
Number of permutations: 720

$\endgroup$
  • 2
    $\begingroup$ Could you please show your Python script? $\endgroup$ – Kritixi Lithos Jun 9 '15 at 4:46
5
$\begingroup$

[4] + [2] - [1] x [6] ÷ [3] x [5] = 50

Or, a cleaner version:

((4 + 2) - 1) x ((6 / 3) x 5) = 50

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.