MaplePrimes - answers and comments on Question, How to produce 100 with Maple?

Probably not what you're looking for, but

Samir Khan — Thu, 03 Jan 2013 17:46:31 Z

Probably not what you're looking for, but sounds like this: http://www.maplesoft.com/applications/view.aspx?SID=4901

Dudney's Digital Century Puzzle

Joe Riel — Fri, 04 Jan 2013 10:09:40 Z

This is known as Dudney's Digital Century puzzle. Coincidentally, I included a simplified version of it as an example in the Iterator package I added to the Maple Application Center a few weeks ago. Actually, that isn't quite accurate; the example is in an update to the package that I haven't yet uploaded. I've been adding various features to it over the holidays. Here is how I solved the simplified version (restricting the operators to just addition and multiplication, with no parentheses).

with(Iterator):

# Assign a procedure that converts a boolean Vector to the relevant
# string.

VecToStr := proc(V)
local i;
    cat("",seq('(i,`if`(V[i]=0,"+","*"))',i=1..8),"9=100")
end proc:

# Construct an iterator that steps through all 8-bit boolean Vectors,
# keeps those for which the equation is true, and returns the
# transformed string.
iter := BinaryGrayCode(8
                       , 'accept' = (V -> evalb(parse(VecToStr(V))))
                       , 'transformer' = VecToStr
                      ):
# Use the iterator to generate all the solutions.
seq(s, s=iter);
   "1*2*3*4+5+6+7*8+9=100", "1*2*3+4+5+6+7+8*9=100", "1+2+3+4+5+6+7+8*9=100"

Here's a quick extension to handle all four arithmetic operations, but without parentheses.

VecToStr := proc(V)
local i,ops;
    cat("",seq('(i,"+*/-"[V[i]+1])',i=1..8),"9=100")
end proc:

iter := MixedRadixTuples([4$8]
                         , 'accept' = (V -> evalb(parse(VecToStr(V))))
                         , 'transformer' = VecToStr
                        ):
seq(s, s=iter);
"1+2+3+4+5+6+7+8*9=100", "1+2+3-4*5+6*7+8*9=100", "1+2*3+4*5-6+7+8*9=100",
    "1+2*3*4*5/6+7+8*9=100", "1+2-3*4+5*6+7+8*9=100", "1+2-3*4-5+6*7+8*9=100",
    "1*2*3+4+5+6+7+8*9=100", "1*2*3*4+5+6+7*8+9=100", "1*2*3*4+5+6-7+8*9=100",
    "1*2*3-4*5+6*7+8*9=100", "1-2+3*4*5+6*7+8-9=100", "1-2+3*4*5-6+7*8-9=100",
    "1-2*3+4*5+6+7+8*9=100", "1-2*3-4+5*6+7+8*9=100", "1-2*3-4-5+6*7+8*9=100"

Handling Parentheses

Joe Riel — Sat, 12 Jan 2013 12:30:48 Z

You can use the Iterator package to solve this puzzle with nested parentheses. To step through all possible groupings, use the BinaryTrees iterator. The following appliable module does that. Understanding precisely how it does it might take a bit of study. This isn't ideal; one really should prune the trees to prevent, for example, both the following branches (1 + 2) + 3 and 1 + (2 + 3) from appearing. Doing so isn't hard but I'll leave that as an exercise. Looping through all possibilities takes a while; here I illustrate the operation using n=6, which limits the tree to six internal nodes (7 leaves), so the digits are from 1 to 7 rather than 1 to 9.

DigitalPuzzle := module()
export ModuleApply;
local Expr, Format;

    # Given the L and R Arrays from the BinaryTree iterator,
    # construct an expression corresponding to the tree,
    # where o[v[i]] is the arithmetic operator of the i-th
    # internal node (the v-Array is used to change the operators
    # for a give tree).
    Expr := proc(L,R)
    local leaf,prefix;
    global o,v;
        leaf := 0;
        prefix := proc(i)
            if i=0 then leaf := leaf+1;
            else 'o'['v'[i]](prefix(L[i]),prefix(R[i]));
            end if;
        end proc;
        prefix(1);
    end proc:

    # Given the L and R arrays of the current tree, and an array, v,
    # that maps the internal nodes to the arithmetic operators (stored
    # in o), return a string corresponding to the desired equality.
    # This is only used for formatting a correct result; speed is
    # not a significant issue.
    Format := proc(L,R,v,o,targ)
    local leaf,infix;
        leaf := 0;
        infix := proc(i)
            if i=0 then leaf := leaf+1;
            else sprintf("(%A %A %A)", infix(L[i]), o[v[i]], infix(R[i]));
            end if;
        end proc;
        sprintf("%s = %a", infix(1), targ);
    end proc:

    ModuleApply := proc(n::posint, targ:=100)
    local A,Accept,cnt,ops,Op,BT,LR,s;
    uses Iterator;

        # Array of arithmetic operators
        ops := Array(0..3,[`+`,`*`,`-`,`/`]);

        # Template for the accept predicate.  The try/catch is
        # needed to handle division by zero.
        Accept := proc(v,o:=ops)
            try
                evalb(_ex=targ);
            catch:
                false;
            end try;
        end proc;

        A := ()->NULL; # dummy procedure that is replaced

        # Construct an iterator that generates all possible values of
        # arithmetic operators (as an Array with values from 0 to 3
        # corresponding to the four operations), but accepts (outputs)
        # only those that meet the criteria.
        Op := MixedRadixTuples([4$n], 'accept'=A);

        # Construct an iterator that generates all binary trees
        # with n-internal nodes (and n+1 leaves).
        BT := BinaryTrees(n);

        cnt := 0; # success counter

        # Loop through all binary trees
        for LR in BT do
            # Reassign A, which is the accept predicate in
            # the Op[erator] iterator, specializing it to the
            # selected tree.
            A := subs(_ex=Expr(LR),op(Accept));

            # Loop through all possibilities of assigning
            # the arithmentic operators to the internal nodes of the
            # tree, keeping only those that evaluate to the target.
            for s in Op do
                cnt := cnt+1;
                printf("%s\n", Format(LR,s,ops,targ));
            end do;
            reset(Op);
        end do;
        cnt;
    end proc:
end module:

CodeTools:-Usage(DigitalPuzzle(6));
(1 + (((((2 + 3) * 4) * 5) + 6) - 7)) = 100
((1 + ((((2 + 3) * 4) * 5) + 6)) - 7) = 100
(((1 + (((2 + 3) * 4) * 5)) + 6) - 7) = 100
(((1 - 2) + 3) + (((4 * 5) - 6) * 7)) = 100
(1 - ((2 * 3) - (((4 + 5) + 6) * 7))) = 100
(1 - ((2 - 3) - (((4 * 5) - 6) * 7))) = 100
((1 - (2 * 3)) + (((4 + 5) + 6) * 7)) = 100
((1 - (2 - 3)) + (((4 * 5) - 6) * 7)) = 100
((1 - 2) + (3 + (((4 * 5) - 6) * 7))) = 100
((1 * 2) * (3 + (((4 + 5) * 6) - 7))) = 100
(1 * (2 * (3 + (((4 + 5) * 6) - 7)))) = 100
(1 - (2 - (3 + (((4 * 5) - 6) * 7)))) = 100
((1 * 2) * ((3 + ((4 + 5) * 6)) - 7)) = 100
(1 * (2 * ((3 + ((4 + 5) * 6)) - 7))) = 100
((1 + ((2 * 3) * 4)) * ((5 + 6) - 7)) = 100
((1 + (2 * (3 * 4))) * ((5 + 6) - 7)) = 100
(1 - ((2 * 3) - ((4 + (5 + 6)) * 7))) = 100
((1 - (2 * 3)) + ((4 + (5 + 6)) * 7)) = 100
(1 + ((((2 + 3) * (4 * 5)) + 6) - 7)) = 100
((1 + (((2 + 3) * (4 * 5)) + 6)) - 7) = 100
(1 + ((((2 + 3) * 4) * 5) + (6 - 7))) = 100
((1 + (((2 + 3) * 4) * 5)) + (6 - 7)) = 100
(((1 + ((2 + 3) * (4 * 5))) + 6) - 7) = 100
((1 - (2 * 3)) * ((4 * 5) * (6 - 7))) = 100
((1 - (2 * 3)) * ((4 * 5) / (6 - 7))) = 100
((((1 - (2 * 3)) * 4) * 5) * (6 - 7)) = 100
((((1 - (2 * 3)) * 4) * 5) / (6 - 7)) = 100
(1 + (((2 + 3) * (4 * 5)) + (6 - 7))) = 100
((1 + ((2 + 3) * (4 * 5))) + (6 - 7)) = 100
((1 + ((2 * 3) * 4)) * (5 + (6 - 7))) = 100
(((1 - (2 * 3)) * (4 * 5)) * (6 - 7)) = 100
(((1 - (2 * 3)) * (4 * 5)) / (6 - 7)) = 100
(((1 - (2 * 3)) * 4) * (5 * (6 - 7))) = 100
(((1 - (2 * 3)) * 4) * (5 / (6 - 7))) = 100
((1 + (2 * (3 * 4))) * (5 + (6 - 7))) = 100
((1 - (2 * 3)) * (4 * (5 * (6 - 7)))) = 100
((1 - (2 * 3)) * (4 * (5 / (6 - 7)))) = 100
memory used=370.72MiB, alloc change=24.00MiB, cpu time=6.43s, real time=6.60s
                                                                    37

Partial solution

Markiyan Hirnyk — Thu, 03 Jan 2013 18:19:06 Z

Yes, this is a solution in the case 123456 if rearrangements of the digits are allowed.

PS. Could you explain how to read your code?

Vote up

Markiyan Hirnyk — Fri, 04 Jan 2013 16:03:39 Z

Many thanks from me to you for your interest to the question and your constructive answer. The question is a hit: I saw it asked in a few places. The motivation to ask that in MaplePrimes was my longing to improve my programming skills. This aim is partially achieved. I still don't understand the difficulties with parentheses, substraction, and division (The Samir Khan's code admits the ones.). A good code is a commented code. As a George Soros Associate Professor I can firmly state that comments are useful for both readers and writers (When explaining something, your mind becomes better organized.).

The output of your suggested code

Markiyan Hirnyk — Fri, 04 Jan 2013 21:11:22 Z

Error, invalid input: too many and/or wrong type of arguments passed to MixedRadixTuples:-MixedRadixTuples; first unused argument is accept = (proc (V) options operator, arrow; evalb(parse(VecToStr(V))) end proc)
See executed_code.mw