12
$\begingroup$

In the spirit of the classic four fours, I wonder what's the optimal set of four numbers?

Your goal is to make the most consecutive integers using four digits of your choice. Pick four: $0,1,2,3,4,5,6,7,8,9$ ( You can pick multiple instances of the same digit )

When constructing an integer:

  • all of your four candidates must be used exactly once (order/placing of digits is irrelevant)
  • You may use basic arithmetic operations $+,-,\times,\div$ and parentheses $()$
  • You may use $a^b$ and $\sqrt[a]{b}$ but at the expense of 2 numbers as you can see
  • You may not form new numbers, i.e. $ab$ is not allowed

If we were to use four $4$s, the best we could do would be up to $9$:

 0  =  4 ÷ 4 × 4 − 4
 1  =  4 ÷ 4 + 4 − 4
 2  =  4 −(4 + 4)÷ 4  
 3  = (4 × 4 − 4)÷ 4
 4  =  4 + 4 ×(4 − 4)
 5  = (4 × 4 + 4)÷ 4
 6  = (4 + 4)÷ 4 + 4
 7  =  4 + 4 − 4 ÷ 4
 8  =  4 ÷ 4 × 4 + 4
 9  =  4 ÷ 4 + 4 + 4
*10  =  4 ÷√4 + 4 ×√4 
*10  =  (44 − 4) ÷ 4

Number 10 can't be done and is an example of failing, since it would require either:

  • expenseless roots; $\sqrt{4}$ isn't allowed. ( $\sqrt[2]{4}$ is, which requires you to use $4$ and $2$ )

  • number formation which isn't allowed either.

Zero does not necessarily need to be included, you can start at either $0$ or $1$.

For the purposes of freedom of puzzling, if you think you can top your solution for a chosen set of digits, by starting at any other positive integer, you can add that to your answer below your initial solution. (I suspect this is unlikely)

If you want, you can extend your consecutive list to negative integers but this is strictly optional and not necessary in any way, other than for the purposes of fulfillment and mathematical euphoria.

Example

There is an example on Puzzling.SE using digits $2,2,4,5$:

https://puzzling.stackexchange.com/a/23078/32666

But this can be expanded since the given example uses only basic arithmetic operations, not including potentiation and roots. I also suspect It could be done better using another set.

I tried this by hand and I'm stuck at number $29$ using this example set, and at number $34$ using $9,8,3,2$.

|improve this question
$\endgroup$
  • $\begingroup$ Are we allowed to change the order of the digits, e.g. 2 ÷ 3 × 4 − 7 vs. (7 + 2)÷ 3 + 4? And are we allowed to put two digits together to make a two-digit number? (44 is in your example but not allowed by the rules as written - I would vote not to allow it.) Does the list really have to start at 0 or 1 only, or could it start at any other number? (That would make it a slightly more interesting challenge IMHO.) $\endgroup$ – Nathaniel Apr 22 '17 at 10:27
  • 1
    $\begingroup$ @Oray I don't see why it would be against the rules, so why not. $\endgroup$ – Vepir Apr 22 '17 at 11:23
  • 1
    $\begingroup$ Does allowing "$-$" minus at the beginning also mean that any number may be negated? As in $1+1+(-1)+(-1) = 0$ . Either way, it probably should be mentioned in the puzzle statement rather than in comments. Also, either way, it effectively makes more than 4 numbers available for use. $\endgroup$ – humn Apr 22 '17 at 21:31
  • 1
    $\begingroup$ @humn I believe we can avoid "negation"? In your example, you don't need a plus in front of a minus, and that's subtraction then. Also, instead of negating the first number, just move it to the right. Negation of exponents is also unnecessary since it results in exponentiation+division. Can you give me an example where negation can't be avoided if my intuition is wrong? (Other than if we want to form more negative numbers) $\endgroup$ – Vepir Apr 23 '17 at 8:45
  • 1
    $\begingroup$ Good points about rearranging negation, @Vepir. The only contrary examples I can think are quite unlikely to be helpful, such as $3^{-2}+\frac89 = 1$. $\endgroup$ – humn Apr 23 '17 at 9:10
12
$\begingroup$

Here is my result for $1,4,6,7$ from $1$ to $53$.

$1^{4-6-7}=1$

$1^4-6+7=2$

$(1-4)/(6-7)=3$

$1+4+6-7=4$

$1-4/(6-7)=5$

$1+4-6+7=6$

$(1^{4})^{6}*7=7$

$1^{4-6}+7=8$

$-1*(4-6-7)=9$

$1-4+6+7=10$

$1^6*(4+7)=11$

$1^6+4+7=12$

$1^4*(6+7)=13$

$1^4+6+7=14$

$(1-6)*(4-7)=15$

$-1+4+6+7=16$

$1*(4+6)+7=17$

$1+4+6+7=18$

$1-6*(4-7)=19$

$-4*(1^7-6)=20$

$-1+4*7-6=21$

$1*(4*7-6)=22$

$1+4*7-6=23$

$1^7*4*6=24$

$1^7+4*6=25$

$4*(1+7)-6=26$

$-4*(1-6)+7=27$

$1^6*4*7=28$

$1^6+4*7=29$

$-1+4*6+7=30$

$1*(4*6+7)=31$

$1+4*6+7=32$

$-1+4*7+6=33$

$1*(4*7+6)=34$

$1+4*7+6=35$

$(7-1)^{6-4}=36$

$-1-4+6*7=37$

$-1*(4-6*7)=38$

$1-4+6*7=39$

$4-6*(1-7)=40$

$6+7*(4+1)=41$

$1^4*6*7=42$

$1^4+6*7=43$

$-4+6*(1+7)=44$

$-1+4+6*7=45$

$1*(4+6*7)=46$

$1+4+6*7=47$

$-1+7^{6-4}=48$

$1*7^{6-4}=49$

$1+7^{6-4}=50$

$-1+4*(6+7)=51$

$1*4*(6+7)=52$

$1+4*(6+7)=53$

|improve this answer
$\endgroup$
  • $\begingroup$ Do you think this might be the optimal set? $\endgroup$ – Vepir Apr 22 '17 at 15:22
  • $\begingroup$ @Vepir I believe this is optimal if I do not mess up with my programming. I checked every possibility. $\endgroup$ – Oray Apr 22 '17 at 15:23
  • $\begingroup$ I'll most likely accept it at the end of the day. What did you used to program it? Would you mind sharing your code on something like pastebin? $\endgroup$ – Vepir Apr 22 '17 at 15:28
  • $\begingroup$ @Vepir it is c#, code is kinda messy since I edited over something else to do it. I will clean and paste it here later. Probably there will be no better answer if I did not miss something serious in my code :) $\endgroup$ – Oray Apr 22 '17 at 15:35
  • 1
    $\begingroup$ I accepted your answer since it seems it's unlikely that we get a better result. I would still like to check out your code? :) $\endgroup$ – Vepir Apr 23 '17 at 18:15
4
$\begingroup$

Here's a list of all numbers from 1 to 43 using 2, 3, 6 and 7. ^ is the power operator.

(6-((3+7)/2))
(6*(3/(2+7)))
(2/((7-3)/6))
((6*3)-(2*7))
((7-(3-6))/2)
(((7-6)*2)*3)
(7*((3*2)/6))
(2^(3*(7-6)))
((3^(7-6))^2)
((3^2)+(7-6))
(((7+3)/2)+6)
(((7+6)+2)-3)
(((6/2)+7)+3)
(7+(6-(2-3)))
(((6*2)-7)*3)
(7-(3-(6*2)))
((6-3)+(7*2))
((3+(2+6))+7)
(((3*2)+6)+7)
(2*((7-3)+6))
(6-((2-7)*3))
(7+((2*6)+3))
((6+3)+(2*7))
((6/(2/7))+3)
((7*3)+(6-2))
(6+((3+7)*2))
((2+7)*(6-3))
((2/(3/7))*6)
(6+((3*7)+2))
(2*((7*3)-6))
(7+((6+2)*3))
(3-(7-(6^2)))
(3*((7-2)+6))
(((6/2)^3)+7)
(((6-3)+2)*7)
(6*(2-(3-7)))
((6*(3+2))+7)
((7-(2/3))*6)
((3+(7/2))*6)
((6^2)-(3-7))
((7*6)-(3-2))
(((3-2)*6)*7)
(3-(2-(6*7)))

As you can guess, I wrote a program to find this. It's not so hard to make one, but I'm disclosing it anyway. It puts the output into spoiler code blocks automatically ;)

The program below doesn't use the root operator because most of the time it's useless. If you want to include it, add 'r' to the operators array, but beware of overflow errors.

I stole the RPN parser from here.

import random

operators = ['-', '+', '*', '/', '^']

def parse(rpn):

    stack = []

    for val in rpn:
        if val in operators:
            if len(stack) < 2:
                return -1
            op1 = stack.pop()
            op2 = stack.pop()
            if val=='-': result = op2 - op1
            if val=='+': result = op2 + op1
            if val=='*': result = op2 * op1
            if val=='/':
                if op1 != 0:
                    result = op2 / op1
                else:
                    return -1
            if val=='^':
                if op2 > 0 and op1 < 6:
                    result = op2 ** op1
                else:
                    return -1
            if val=='r':
                if op2 > 0 and op1 != 0:
                    result = op2 ** (1/op1)
                else:
                    return -1

            stack.append(result)
        else:
            stack.append(float(val))

    if len(stack)!= 1:
        return -1
    return stack.pop()


def randrpn(digits):
    rpn = digits[:]
    rpn.append(random.choice(operators))
    rpn.append(random.choice(operators))
    rpn.append(random.choice(operators))
    random.shuffle(rpn)
    return rpn


def randdigits():
    d = []
    d.append(random.choice(range(10)))
    d.append(random.choice(range(10)))
    d.append(random.choice(range(10)))
    d.append(random.choice(range(10)))
    return d

def rpn_to_infix(rpn):
    stack = []
    infix = ""
    for nxt in rpn:
        if nxt in operators:
            op1 = stack.pop()
            op2 = stack.pop()
            expr = '(' + op2 + nxt + op1 + ')'
            stack.append(expr)
        else:
            stack.append(str(nxt))
    return '>! `' + stack.pop() + '`<br>'

d = randdigits()
results = []
formulas = []
for i in range(300000):
    r = randrpn(d)
    res = parse(r)
    if (res >= 0 and res.is_integer() and not res in results):
        results.append(res)
        formulas.append(rpn_to_infix(r))

for i in range(1, 1000):
    if float(i) in results:
        print formulas[results.index(float(i))]
    else:
        break
|improve this answer
$\endgroup$
  • $\begingroup$ I suppose you could write a script to translate it into standard notation for readability. I would appreciate it, since I'm doing my own set of digits by hand atm. $\endgroup$ – Vepir Apr 22 '17 at 12:34
  • $\begingroup$ @Vepir Infix converter done. $\endgroup$ – BaSzAt Apr 22 '17 at 13:16
  • $\begingroup$ Why picking randomly in randdigits when there are only 10^4 = 10000 possibilities to brute force it? $\endgroup$ – Cœur Sep 30 '18 at 18:37

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.