I have tried to solve this but I can't. Does somebody know the answer?

Ref: Puzzle World, Ed. Nob Yoshigahara and Richard Bozulich, Ishi Press, Summer 1992, Pilot Edition.

  • $\begingroup$ So, we have to fill in the "x"? $\endgroup$ – Sid Aug 21 '16 at 14:27
  • $\begingroup$ Does each letter (including x) represent a different digit? $\endgroup$ – Shuri2060 Aug 21 '16 at 14:44
  • $\begingroup$ x can be same or diffeent digit and this is a question of puzzle and world $\endgroup$ – smtith park Aug 21 '16 at 14:59
  • 1
    $\begingroup$ I'm afraid there is no solution in which P, U, Z, L, E, W, O, R, and D are all different digits, and leading zeroes are not allowed. I cannot prove it, but I wrote a program to brute force it (it was quite tricky to do it effectively). No solution found with these criteria. $\endgroup$ – elias Aug 21 '16 at 20:46
  • $\begingroup$ @QuestionAsker If all the x digits in the multiplicand are equal then all the intermediate sum values would all be equal (post-left-shift) too, so all of W,O,R,L,D would all be equal to x too, but P,U,Z,L,E,W,O,R,D are surely meant to be unique digits (otherwise we could just say 0 * 0 = 0); so it must be that any x is free to be any digit (elias suggests it may only be possible if some leading digits are also 0) $\endgroup$ – Jonathan Allan Aug 22 '16 at 0:46

Since this does not have the tag I have used a computer to

find the single solution
- with P,U,Z,L,E,W,O,R,D being unique digits in $[0,9]$, and
- all instances of x free to be any digit.

That solution is P,U,Z,L,E,W,O,R,D = 6,9,5,0,3,7,8,2,1.

Numerically on the left, and with the character X for 4 on the right:

       695503               PUZZLE
      6684445              PPOXXXZ
      3477515              EXWWZDZ
     2782012              RWORLDR
    2782012              RWORLDR
   2782012              RWORLDR
  5564024              ZZPXLRX
 4173018              XDWELDO
4173018              XDWELDO
4649051550835        XPXULZDZZLOEZ

I did it in a relatively similar way to a manual approach

I haven't made all the inferences I would make manually, but I have reduced the space in steps that would probably be used as part of a manual approach (one would prune more of the space than we need to with a computer, since they calculate so fast):

If one labels the multiplicand xxxxxxx as x6,x5,x4,x3,x2,x1,x0 then the innermost generator (the third function) looks for values of P,U,Z,Z,L,E (with unique digits P,U,Z,L,E) and x3 (in $[0,9]$) that produce a valid x,W,O,R,L,D,x intermediate sum (with unique digits P,U,Z,L,E,W,O,R,D) - there are $242$ such choices.

The generator that wraps around that (the second function) then runs through these choices and looks for values of x5,x4,x2,x1 that produce intermediate sums with the matching W,O,L,D - this yields $2,315$ choices.

The generator that wraps around that (the first function) then runs through these choices and looks for values of x6,x0 that produce a final result matching x,P,x,U,x,Z,x,Z,x,L,x,E,x - this yields a single result (the two multiplicands as stings).

The Python code:

from itertools import combinations, permutations

def iterSolutions():
    for puzzle, puzzleInt, x1, x2, x3, x4, x5 in iterValid_Puzzle_PuzzleInt_X1_X2_X3_X4_X5():
        p, u, z, z, l, e = puzzle
        pX = (10 * x1 + 100 * x2 + 1000 * x3 + 10000 * x4 + 100000 * x5)
        for x6 in range(10):
            pR = puzzleInt * (1000000 * x6 + pX)
            for x0 in range(10):
                r = str(puzzleInt * x0 + pR)
                newP = len(r) > 11 and r[-12] or '0'
                if newP == p:
                    newU = len(r) > 9 and r[-10] or '0'
                    if newU == u:
                        newZ = len(r) > 7 and r[-8] or '0'
                        if newZ == z:
                            newZ = len(r) > 5 and r[-6] or '0'
                            if newZ == z:
                                newL = len(r) > 3 and r[-4] or '0'
                                if newL == l:
                                    newE = len(r) > 1 and r[-2] or '0'
                                    if newE == e:
                                        yield puzzle, ''.join(str(v) for v in (x6, x5, x4, x3, x2, x1, x0))

def iterValid_Puzzle_PuzzleInt_X1_X2_X3_X4_X5():
    for puzzle, puzzleInt, x3, w, o, d in iterValid_Puzzle_PuzzleInt_X3_W_O_D():
        for x1 in range(10):
            s1 = str(puzzleInt * x1)
            wNew = len(s1) > 5 and s1[-6] or '0'
            if wNew == w:
                for x2 in range(10):
                    s2 = str(puzzleInt * x2)
                    oNew = len(s2) > 4 and s2[-5] or '0'
                    if oNew == o:
                        l = puzzle[4]
                        for x4 in range(10):
                            s4 = str(puzzleInt * x4)
                            lNew = len(s4) > 2 and s4[-3] or '0'
                            if lNew == l:
                                for x5 in range(10):
                                    s5 = str(puzzleInt * x5)
                                    dNew = len(s5) > 1 and s5[-2] or '0'
                                    if dNew == d:
                                        yield puzzle, puzzleInt, x1, x2, x3, x4, x5

def iterValid_Puzzle_PuzzleInt_X3_W_O_D():
    for puzzleSelection in combinations('9876543210', 5):
        for p,u,z,l,e in permutations(puzzleSelection):
            puzzle = ''.join((p,u,z,z,l,e))
            puzzleSet = set(puzzle)
            puzzleInt = int(puzzle)
            for x3 in range(10):
                s3 = str(puzzleInt * x3)
                if len(s3) == 5:
                    w = '0'
                elif len(s3) < 5:
                    w = s3[-6]
                d,l,r,o = s3[-2:-6:-1]
                if l != puzzle[4]:
                if len(puzzleSet | set((w,o,r,d))) == 9:
                    yield puzzle, puzzleInt, x3, w, o, d

Running that code (sub-second):

>>> for solution in iterSolutions():
...     solution
('695503', '6684445')
Which is saying the only solution is 695503 * 6684445, the multiplication I showed above.

  • $\begingroup$ Great answer! I used a very similar - almost identical approach, but it looks like I've made a bug. Now I have to debug my spaghetti-code... $\endgroup$ – elias Aug 22 '16 at 6:17

Your Answer

