From 4a94ef6a428fd53ed8a61d6f7ccc8d2e97594e2c Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Tue, 2 Jan 2018 00:10:39 -0800 Subject: [PATCH] Countdown.ipynb updated with Littman Countdown --- ipynb/Countdown.ipynb | 2537 +++++++++++++++++++++-------------------- 1 file changed, 1273 insertions(+), 1264 deletions(-) diff --git a/ipynb/Countdown.ipynb b/ipynb/Countdown.ipynb index a756429..bfb69cf 100644 --- a/ipynb/Countdown.ipynb +++ b/ipynb/Countdown.ipynb @@ -351,7 +351,7 @@ " ...}\n", "\n", "\n", - "I can implement `EXPS` as a defaultdict of dicts, and define `expressions(numbers)` to fill in `EXPS` entries for `numbers` and all sub-sequences of `numbers`. Within `fill_tables`, note that `Lnums` and `Rnums` are sequences of numbers, such as `(10, 9, 8)` and `(7, 6)`. `L` and `R` are values, such as `27` and `1`. And `Lexp` and `Rexp` are strings, such as `\"((10+9)+8)\"` and `\"(7-6)\"`. Rather than catching division-by-zero errors, we just avoid the division when the denominator is 0." + "I can implement `EXPS` as a defaultdict of dicts, and define `expressions(numbers)` to fill in `EXPS` entries for `numbers` and all sub-sequences of `numbers`. Within `expressions`, note that `Lnums` and `Rnums` are sequences of numbers, such as `(10, 9, 8)` and `(7, 6)`. `L` and `R` are numeric values, such as `27` and `1`. And `Lexp` and `Rexp` are strings, such as `\"((10+9)+8)\"` and `\"(7-6)\"`. Rather than catching division-by-zero errors, we just avoid the division when the denominator is 0." ] }, { @@ -381,11 +381,11 @@ " for (Lnums, Rnums) in splits(numbers):\n", " for (L, R) in itertools.product(expressions(Lnums), expressions(Rnums)):\n", " Lexp, Rexp = '(' + EXPS[Lnums][L], EXPS[Rnums][R] + ')'\n", - " if R != 0: \n", - " expr(numbers, L / R, Lexp + '/' + Rexp)\n", " expr(numbers, L * R, Lexp + '*' + Rexp)\n", " expr(numbers, L - R, Lexp + '-' + Rexp)\n", " expr(numbers, L + R, Lexp + '+' + Rexp)\n", + " if R != 0: \n", + " expr(numbers, L / R, Lexp + '/' + Rexp)\n", " return EXPS[numbers]\n", "\n", "def expr(numbers, value, exp): \n", @@ -432,7 +432,7 @@ " 8.88888888888889: '((10/9)*8)',\n", " 9: '((10-9)+8)',\n", " 9.11111111111111: '((10/9)+8)',\n", - " 10.0: '(10*(9-8))',\n", + " 10: '(10/(9-8))',\n", " 11: '((10+9)-8)',\n", " 11.125: '(10+(9/8))',\n", " 11.25: '((10*9)/8)',\n", @@ -509,8 +509,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 30.1 s, sys: 767 ms, total: 30.9 s\n", - "Wall time: 31 s\n" + "CPU times: user 29.5 s, sys: 698 ms, total: 30.2 s\n", + "Wall time: 30.2 s\n" ] }, { @@ -540,7 +540,7 @@ "source": [ "We have an answer! And in a lot less than 8 hours, thanks to dynamic programming! \n", "\n", - "Removing unnecessry brackets, this equation is equivalent to:" + "Removing unnecessary brackets, this equation is equivalent to:" ] }, { @@ -569,6 +569,47 @@ "(10 + 9 * 8 * 7 - 6 - 5) * 4 + 3 + 2 - 1" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are solutions for nearby years:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2010: '((((10*((9+((8+7)*6))+(5/4)))+3)*2)-1)',\n", + " 2011: '((((((10+9)*8)+7)*(6+(5*(4/3))))-2)-1)',\n", + " 2012: '((((((10+9)*8)+7)*(6+(5*(4/3))))-2)/1)',\n", + " 2013: '((((((10+9)*8)+7)*(6+(5*(4/3))))-2)+1)',\n", + " 2014: '((((10-(9*8))*(7-(6*((5+4)+3))))/2)-1)',\n", + " 2015: '((((((((10*9)+8)-7)*(6+5))+4)+3)*2)-1)',\n", + " 2016: '(((((((10+((9*8)*7))-6)-5)*4)+3)+2)-1)',\n", + " 2017: '(((((((10+((9*8)*7))-6)-5)*4)+3)+2)/1)',\n", + " 2018: '(((((((10+((9*8)*7))-6)-5)*4)+3)+2)+1)',\n", + " 2019: '((((10+9)+((8+7)*(6+((5*4)*3))))*2)+1)',\n", + " 2020: '((((10+((((9*8)*7)/(6-5))*4))-3)-2)-1)',\n", + " 2021: '((((10+((((9*8)*7)/(6-5))*4))-3)-2)/1)',\n", + " 2022: '((((10+((((9*8)*7)/(6-5))*4))-3)-2)+1)',\n", + " 2023: '(((((10+(((9*(8+7))*6)*5))/4)-3)*2)-1)',\n", + " 2024: '(((((10+(((9*(8+7))*6)*5))/4)-3)*2)/1)'}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{y: expressions(c10)[y] for y in range(2010, 2025)}" + ] + }, { "cell_type": "markdown", "metadata": { @@ -587,7 +628,7 @@ "\n", "As it stands, my program can't answer that question, because I only keep one expression for each value. \n", "\n", - "Also, I'm not sure what it means to be a distinct solution. For example, are `((10+9)+8)` and `(10+(9+8))` different, or are they same, because they both are equivalent to `(10+9+8)`? Similarly, are `((3-2)-1)` and `(3-(2+1)` different, or the same because they both are equivalent to `(3 + -2 + -1)`? I think the notion of \"distinct solution\" is just inherently ambiguous, and each of these questions could reasonably be answered either way. My choice is to count each of these as distinct: every expression has exactly ten numbers, nine operators, and nine pairs of brackets, and if an expression differs in any character, it is different. But I won't argue with anyone who has a different definition of \"distinct solution.\"\n", + "Also, I'm not sure what it means to be a distinct solution. For example, are `((10+9)+8)` and `(10+(9+8))` different, or are they same, because they both are equivalent to `(10+9+8)`? Similarly, are `((3-2)-1)` and `(3-(2+1)` different, or the same because they both are equivalent to `(3 + -2 + -1)`? I think the notion of \"distinct solution\" is just inherently ambiguous, and each of these questions could reasonably be answered either way. My choice is to count each of these as distinct: every expression has exactly ten numbers, nine operators, and nine pairs of brackets, and if an expression differs in any character, it is different. But I won't argue with anyone who prefers a different definition of \"distinct solution.\"\n", "\n", "So how can I count expressions? One approach would be to go back to enumerating every equation (all 4862 × 49 = 1.2 bilion of them) and checking which ones equal 2016. That would take about 40 hours with my Python program, but I could get it under 40 minutes in a more efficient language.\n", "\n", @@ -598,12 +639,12 @@ "because there are 2 ways to make 27 with the numbers `(10, 9, 8)`, namely, `((10+9)+8)` and `(10+(9+8))`.\n", "How do we compute the counts? By looking at every split and operator choice that can make the value, and summing up (over all of these) the product of the counts for the two sides. For example, there are 2 ways to make 27 with `(10 ... 8)`, and it turns out there are 3526 ways to make 1 with `(7 ... 1)`. So there are 2 × 3526 = 7052 ways to make 28 with this split by adding 27 and 1. \n", "\n", - "I'll make `expr` handle `COUNTS` as well as `EXPS`. And I'll define `clear` to clear out the cache of `COUNTS` and `EXPS`, so that we can fill the tables with our new, improved entries." + "I'll make `expr` maintain `COUNTS` as well as `EXPS`. And I'll define `clear` to clear out the cache of `COUNTS` and `EXPS`, so that we can fill the tables with our new, improved entries." ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "button": false, "collapsed": true, @@ -627,11 +668,11 @@ " for (L, R) in itertools.product(expressions(Lnums), expressions(Rnums)):\n", " Lexp, Rexp = '(' + EXPS[Lnums][L], EXPS[Rnums][R] + ')'\n", " count = COUNTS[Lnums][L] * COUNTS[Rnums][R]\n", - " if R != 0: \n", - " expr(numbers, L / R, Lexp + '/' + Rexp, count)\n", " expr(numbers, L * R, Lexp + '*' + Rexp, count)\n", " expr(numbers, L - R, Lexp + '-' + Rexp, count)\n", " expr(numbers, L + R, Lexp + '+' + Rexp, count)\n", + " if R != 0: \n", + " expr(numbers, L / R, Lexp + '/' + Rexp, count)\n", " return EXPS[numbers]\n", "\n", "def expr(numbers, val, exp, count):\n", @@ -644,7 +685,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": { "button": false, "new_sheet": false, @@ -668,7 +709,7 @@ " 8.88888888888889: '((10/9)*8)',\n", " 9: '((10-9)+8)',\n", " 9.11111111111111: '((10/9)+8)',\n", - " 10.0: '(10*(9-8))',\n", + " 10: '(10/(9-8))',\n", " 11: '((10+9)-8)',\n", " 11.125: '(10+(9/8))',\n", " 11.25: '((10*9)/8)',\n", @@ -680,7 +721,7 @@ " 720: '((10*9)*8)'}" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -692,7 +733,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": { "button": false, "new_sheet": false, @@ -716,7 +757,7 @@ " 8.88888888888889: 2,\n", " 9: 2,\n", " 9.11111111111111: 1,\n", - " 10.0: 2,\n", + " 10: 2,\n", " 11: 2,\n", " 11.125: 1,\n", " 11.25: 2,\n", @@ -728,7 +769,7 @@ " 720: 2})" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -739,7 +780,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": { "button": false, "new_sheet": false, @@ -754,7 +795,7 @@ "2" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -778,7 +819,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": { "button": false, "new_sheet": false, @@ -791,7 +832,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 4s, sys: 1.15 s, total: 1min 6s\n", + "CPU times: user 1min 4s, sys: 1.15 s, total: 1min 5s\n", "Wall time: 1min 6s\n" ] }, @@ -801,7 +842,7 @@ "'(((((((10+((9*8)*7))-6)-5)*4)+3)+2)-1)'" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -829,7 +870,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": { "button": false, "new_sheet": false, @@ -844,7 +885,7 @@ "30066" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -867,33 +908,11 @@ "\n", "**But I don't believe it.**\n", "\n", - "Why not? Because floating point division can have round-off errors. For example:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "button": false, - "new_sheet": false, - "run_control": { - "read_only": false - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2015.9999999999998" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "2015 + 1/3 + 1/3 + 1/3" + "Why not? Because floating point division can have round-off errors. \n", + "\n", + "# Dealing with Round-off Errors\n", + "\n", + "Consider this:" ] }, { @@ -910,7 +929,7 @@ { "data": { "text/plain": [ - "False" + "2015.9999999999998" ] }, "execution_count": 19, @@ -918,6 +937,32 @@ "output_type": "execute_result" } ], + "source": [ + "2015 + 1/3 + 1/3 + 1/3" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "button": false, + "new_sheet": false, + "run_control": { + "read_only": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "False" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "2015 + 1/3 + 1/3 + 1/3 == 2016" ] @@ -932,14 +977,12 @@ } }, "source": [ - "# Dealing with Round-off Errors\n", - "\n", - "So there might be perfectly good solutions that are hiding in the `EXPS` table under `2015.9999999999998` (or some similar number) when they should be exactly `2016`. Let's find all the values that are very near to `2016`:" + "This means there might be perfectly good expressions that are counted under `2015.9999999999998` (or some similar number) when they should be counted for `2016`. Let's find all the values that are very near to `2016`:" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": { "button": false, "new_sheet": false, @@ -956,7 +999,7 @@ " 2015.9999999999993,\n", " 2015.9999999999995,\n", " 2015.9999999999998,\n", - " 2016.0,\n", + " 2016,\n", " 2016.0000000000002,\n", " 2016.0000000000005,\n", " 2016.0000000000018,\n", @@ -964,14 +1007,16 @@ " 2016.0000000000023}" ] }, - "execution_count": 20, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "{val for val in expressions(c10)\n", - " if abs(val - 2016) < 0.000001}" + "epsilon = 10 ** -8\n", + "\n", + "{y for y in expressions(c10)\n", + " if abs(y - 2016) < epsilon}" ] }, { @@ -986,55 +1031,38 @@ "source": [ "I suspect that all of these actually should be exactly 2016. \n", "\n", - "To find out for sure, let's re-do all the calculations using exact rational arithmetic, as provided by the `fractions.Fraction` data type. From experience I know that this will be an order of magnitude slower, so we're looking at 10 minutes or more of computation.\n", - "\n", - "I'll replace the computation `L / R` with `divide(L, R)`, which calls `Fraction`. To mitigate the expense of this computation, I make two optimizations. First, `divide` replaces a whole fraction, such as `Fraction(6, 2)`, with an `int`, such as `3`. Second, I modify `expr` to *not* fill in `EXPS[c10]`, except for `EXPS[c10][2016]`. The rationale is that we don't need the other entries, and by not storing them, we save a lot of memory, and thus save garbage collection time." + "To be absolutely sure, I could re-do the calculations using exact rational arithmetic, as provided by the `fractions.Fraction` data type. From experience I know that would be an order of magnitude slower, so instead I'll just add up all the counts in the `COUNTS` table that are within epsilon of 2016:" ] }, { "cell_type": "code", - "execution_count": 21, - "metadata": { - "button": false, - "collapsed": true, - "new_sheet": false, - "run_control": { - "read_only": false + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2015.999999999997: 15,\n", + " 2015.999999999999: 10,\n", + " 2015.9999999999993: 14,\n", + " 2015.9999999999995: 1930,\n", + " 2015.9999999999998: 5868,\n", + " 2016: 30066,\n", + " 2016.0000000000002: 5792,\n", + " 2016.0000000000005: 510,\n", + " 2016.0000000000018: 264,\n", + " 2016.000000000002: 18,\n", + " 2016.0000000000023: 12}" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" } - }, - "outputs": [], + ], "source": [ - "from fractions import Fraction\n", - "\n", - "def expressions(numbers):\n", - " \"Fill EXPS table for numbers, and all sub-sequences of numbers. Return EXPS[numbers]\"\n", - " if numbers in EXPS: # Already did the work\n", - " pass\n", - " elif len(numbers) == 1: # Only one way to make an expression out of a single number\n", - " expr(numbers, numbers[0], str(numbers[0]), 1)\n", - " else: # Split in all ways; fill tables for left and right; combine tables in all ways\n", - " for (Lnums, Rnums) in splits(numbers):\n", - " for (L, R) in itertools.product(expressions(Lnums), expressions(Rnums)):\n", - " Lexp, Rexp = '(' + EXPS[Lnums][L], EXPS[Rnums][R] + ')'\n", - " count = COUNTS[Lnums][L] * COUNTS[Rnums][R]\n", - " if R != 0: \n", - " expr(numbers, divide(L, R), Lexp + '/' + Rexp, count)\n", - " expr(numbers, L * R, Lexp + '*' + Rexp, count)\n", - " expr(numbers, L - R, Lexp + '-' + Rexp, count)\n", - " expr(numbers, L + R, Lexp + '+' + Rexp, count)\n", - " return EXPS[numbers]\n", - "\n", - "def divide(L, R):\n", - " \"Exact rational division of L/R.\"\n", - " f = Fraction(L, R)\n", - " return (f.numerator if f.denominator == 1 else f)\n", - "\n", - "def expr(numbers, value, exp, count):\n", - " \"Fill EXPS[numbers][val] with exp, and increment COUNTS.\"\n", - " if numbers is c10 and value != 2016: \n", - " return\n", - " EXPS[numbers][value] = exp\n", - " COUNTS[numbers][value] += count" + "{y: COUNTS[c10][y] for y in expressions(c10)\n", + " if abs(y - 2016) < epsilon}" ] }, { @@ -1052,40 +1080,22 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": { - "button": false, - "new_sheet": false, - "run_control": { - "read_only": false - } - }, + "execution_count": 23, + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 12min 43s, sys: 1.82 s, total: 12min 45s\n", - "Wall time: 12min 46s\n" - ] - }, { "data": { "text/plain": [ "44499" ] }, - "execution_count": 22, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "clear()\n", - "\n", - "%time expressions(c10)[2016]\n", - "\n", - "COUNTS[c10][2016]" + "sum(_.values())" ] }, { @@ -1098,7 +1108,18 @@ } }, "source": [ - "That did indeed take about ten times longer, but we now have an answer that I have more confidence in (but I wouldn't accept it as definitive until it was independently verified and had an extensive test suite). And of course, if you have a different definition of \"distinct solution,\" you will get a different answer." + "I have more confidence in this answer, 44,499, than in 30,066, but I wouldn't accept it as definitive until it was independently verified and passed an extensive test suite. And of course, if you have a different definition of \"distinct solution,\" you will get a different answer." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "clear()" ] }, { @@ -1111,15 +1132,15 @@ } }, "source": [ - "# Dealing with the Exponentiation Operator\n", + "# Exponentiation, and Four 4s\n", "\n", "Now let's turn to another of Alex's puzzles: making 2016 and other target values from a string of four or five `4`s, with exponentiation allowed. Exponentiation is tricky for five reasons:\n", "\n", - "- **Division by zero**: `(0 ** -1)` is the same as `(1 / 0)`, and gives a `ZeroDivisionError`.\n", - "- **Irrationals**: `(3 ** (1 / 2))` is an irrational number; so we can't do exact rational arithmetic.\n", - "- **Imaginaries**: `(-1 ** (1 / 2))` is an imaginary number, but Python gives a `ValueError`.\n", - "- **Overflow**: `(10. ** (9. ** 8.))`, as a `float`, gives a `OverflowError`.\n", - "- **Finite memory**: [`(10 ** (9 ** (8 * 7)))`](http://www.wolframalpha.com/input/?i=10+%5E+9+%5E+56), as an `int`, gives an `OutOfMemoryError` (even if your memory uses every atom on Earth).\n", + "- **Division by zero**: `(0 ^ -1)` is the same as `(1 / 0)`, and gives a `ZeroDivisionError`.\n", + "- **Irrationals**: `(3 ^ (1 / 2))` is an irrational number; so we can't do exact rational arithmetic.\n", + "- **Imaginaries**: `(-1 ^ (1 / 2))` is an imaginary number, but Python gives a `ValueError`.\n", + "- **Overflow**: `(10. ^ (9. ^ 8.))`, as a `float`, gives a `OverflowError`.\n", + "- **Finite memory**: [`(10 ^ (9 ^ (8 * 7)))`](http://www.wolframalpha.com/input/?i=10+%5E+9+%5E+56), as an `int`, gives an `OutOfMemoryError` (even if your memory uses every atom on Earth).\n", "\n", "How do we deal with this? We can't do exact rational arithmetic. We could try to do exact *algebra*, perhaps using [SymPy](http://www.sympy.org/en/index.html), but that seems difficult\n", "and computationally expensive, so instead I will abandon the goal of exact computation, and do everything in the domain of floats (reluctantly accepting that there will be some round-off errors). We'll coerce numbers to floats when we first put them in the table, and all subsequent operations will be with floats. I define a new function, `expr2`, to call `expr`, catching arithmetic errors. Since we are making some rather arbitrary decisions about what expressions are allowed (e.g. imaginary numbers are not), I'll give up on trying to maintain `COUNTS`." @@ -1127,7 +1148,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 62, "metadata": { "button": false, "collapsed": true, @@ -1150,7 +1171,7 @@ " for (Lnums, Rnums) in splits(numbers):\n", " for (L, R) in itertools.product(expressions(Lnums), expressions(Rnums)):\n", " Lexp, Rexp = '(' + EXPS[Lnums][L], EXPS[Rnums][R] + ')'\n", - " expr2(numbers, L, pow, R, Lexp + '**' + Rexp)\n", + " expr2(numbers, L, pow, R, Lexp + '^' + Rexp)\n", " expr2(numbers, L, truediv, R, Lexp + '/' + Rexp)\n", " expr2(numbers, L, mul, R, Lexp + '*' + Rexp)\n", " expr2(numbers, L, add, R, Lexp + '+' + Rexp)\n", @@ -1182,7 +1203,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 64, "metadata": { "button": false, "new_sheet": false, @@ -1194,10 +1215,10 @@ { "data": { "text/plain": [ - "'(((4**4)-4)*(4+4))'" + "'(((4^4)-4)*(4+4))'" ] }, - "execution_count": 24, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } @@ -1223,7 +1244,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "button": false, "collapsed": true, @@ -1259,7 +1280,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 65, "metadata": { "button": false, "new_sheet": false, @@ -1283,7 +1304,7 @@ " 9: '(((4/4)+4)+4)'}" ] }, - "execution_count": 26, + "execution_count": 65, "metadata": {}, "output_type": "execute_result" } @@ -1309,7 +1330,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 67, "metadata": { "button": false, "new_sheet": false, @@ -1326,7 +1347,7 @@ " 2: '((((5+5)/5)-5)+5)',\n", " 3: '((((5*5)-5)-5)/5)',\n", " 4: '((((5-5)-5)/5)+5)',\n", - " 5: '((5/((5**5)**5))+5)',\n", + " 5: '((5/((5^5)^5))+5)',\n", " 6: '((((5/5)+5)*5)/5)',\n", " 7: '(((5/5)+(5/5))+5)',\n", " 8: '((((5+5)+5)/5)+5)',\n", @@ -1336,15 +1357,17 @@ " 12: '((((5+5)/5)+5)+5)'}" ] }, - "execution_count": 27, + "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ff = (5, 5, 5, 5, 5)\n", + "clear()\n", "\n", - "makeable(ff)" + "five5s = (5, 5, 5, 5, 5)\n", + "\n", + "makeable(five5s)" ] }, { @@ -1361,14 +1384,14 @@ "\n", "# More Operations\n", "\n", - "With some research, I [see](http://www.infobarrel.com/Five_Fives_Problem_Recreational_Mathematics) that others who got up to 55 with five 5s used these three concepts:\n", + "With some research, I [see](http://www.infobarrel.com/Five_Fives_Problem_Recreational_Mathematics) that others who got up to 55 with five 5s used some or all of these three concepts:\n", "\n", "- **digit concatenation**: `55`\n", "- **decimal point**: `.5`\n", - "- **unary operations**: `-5`, `5!` and √ `5`\n", + "- **unary operations**: `-5`, `5!`, and √ `5`\n", "\n", "\n", - "We'll refactor `expressions` to call these three new subfunctions:\n", + "We'll refactor `expressions` to call the following three new subfunctions:\n", "\n", "- `digit_expressions`: For every subsequence of numbers, we'll smush the digits together, and then make a table entry for those resulting digits as an integer, and with a decimal point in each possible position.\n", "- `binary_expressions`: The code that previously was the main body of `expressions`.\n", @@ -1379,7 +1402,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 68, "metadata": { "button": false, "new_sheet": false, @@ -1400,34 +1423,27 @@ " return EXPS[numbers]\n", "\n", "def digit_expressions(numbers):\n", - " \"Fill tables with expressions made from the digits of numbers, and a decimal point.\"\n", + " \"Fill EXPS with digits, with opyional minus sign and decimal point.\"\n", + " # digit_expressions(1, 2) => 12, .12, 1.2\n", " exp = ''.join(str(n) for n in numbers)\n", - " leading_zero = exp.startswith('0')\n", - " if valid_digits(exp):\n", - " expr(numbers, float(exp), exp)\n", - " expr(numbers, -float(exp), '-' + exp)\n", - " for d in range(len(exp)):\n", - " decimal = exp[:d] + '.' + exp[d:]\n", - " if valid_digits(exp[:d]):\n", + " for d in range(len(exp) + 1):\n", + " decimal = (exp[:d] + '.' + exp[d:]).rstrip('.')\n", + " if d < 2 or not decimal.startswith('0'): # '01' is illegal; '0', '0.1' ok\n", " expr(numbers, float(decimal), decimal)\n", " expr(numbers, -float(decimal), '-' + decimal)\n", - " \n", - "def valid_digits(digits):\n", - " \"Allow '0', but not '012'.\"\n", - " return digits == '0' or digits == '' or digits[0] != '0'\n", " \n", "def binary_expressions(numbers):\n", - " \"Fill tables with all expressions formed by splitting numbers and combining with an op.\"\n", + " \"Fill EXPS with all expressions formed by splitting numbers and combining with an op.\"\n", " for (Lnums, Rnums) in splits(numbers):\n", " for (L, R) in itertools.product(expressions(Lnums), expressions(Rnums)):\n", " Lexp, Rexp = '(' + EXPS[Lnums][L], EXPS[Rnums][R] + ')'\n", - " if 1 <= R <= 10 and (L > 0 or int(R) == R):\n", - " expr2(numbers, L, pow, R, Lexp + '**' + Rexp)\n", " expr2(numbers, L, truediv, R, Lexp + '/' + Rexp)\n", " expr2(numbers, L, mul, R, Lexp + '*' + Rexp)\n", " expr2(numbers, L, add, R, Lexp + '+' + Rexp)\n", " expr2(numbers, L, sub, R, Lexp + '-' + Rexp)\n", - " \n", + " if 1 <= R <= 10 and (L > 0 or int(R) == R):\n", + " expr2(numbers, L, pow, R, Lexp + '^' + Rexp)\n", + " \n", "def unary_expressions(numbers):\n", " \"Fill tables for -v, √v and v!\"\n", " for v in tuple(EXPS[numbers]):\n", @@ -1435,7 +1451,7 @@ " expr(numbers, -v, '-(' + exp + ')')\n", " if v > 0: \n", " expr(numbers, sqrt(v), '√' + exp)\n", - " if 2 <= v <= 6 and v == int(v):\n", + " if 3 <= v <= 6 and v == int(v):\n", " expr(numbers, factorial(v), exp + '!')" ] }, @@ -1449,15 +1465,14 @@ } }, "source": [ - "Now that we have more variety in the types of expressions formed, I want to choose a \"good\" expression to represent each value. I'll modify `expr` so that when there are multiple expressions for a value, it chooses the one with the least \"weight,\" where I define `weight` as the length of the string, plus a penalty of 2 for every square root sign (just because square root feels \"heavier\" than the other operations) and of 1 for every decimal point." + "Now that we have more variety in the types of expressions formed, I want to choose a \"good\" expression to represent each value. I'll modify `expr` so that when there are multiple expressions for a value, it chooses the one with the least \"weight,\" where I define the `weight` of a string as the sum of the weights of the characters, where the square root sign is the heaviest, and other characters are as listed." ] }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 69, "metadata": { "button": false, - "collapsed": true, "new_sheet": false, "run_control": { "read_only": false @@ -1467,10 +1482,13 @@ "source": [ "def expr(numbers, value, exp): \n", " \"Fill EXPS[numbers][val] with exp, unless we already have a lighter exp.\"\n", - " if value not in EXPS[numbers] or weight(exp) < weight(EXPS[numbers][value]):\n", + " if value not in EXPS[numbers] or weight(exp) <= weight(EXPS[numbers][value]):\n", " EXPS[numbers][value] = exp\n", " \n", - "def weight(exp): return len(exp) + 2 * exp.count('√') + exp.count('.') " + "WEIGHTS = {'√':3, '.':2, '^':1.3, '/':1.2, '-':1.1}\n", + " \n", + "def weight(exp, weights=WEIGHTS): \n", + " return sum(weights.get(c, 1) for c in exp)" ] }, { @@ -1488,7 +1506,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 70, "metadata": { "button": false, "new_sheet": false, @@ -1501,173 +1519,173 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 1min 56s, sys: 2.4 s, total: 1min 59s\n", - "Wall time: 1min 59s\n" + "CPU times: user 6min 4s, sys: 2.81 s, total: 6min 7s\n", + "Wall time: 6min 7s\n" ] }, { "data": { "text/plain": [ - "{0: '(5*(55-55))',\n", - " 1: '((55/55)**5)',\n", - " 2: '(55/(.5*55))',\n", - " 3: '(5-(5!/(5+55)))',\n", + "{0: '((55-55)*5)',\n", + " 1: '((55/55)^5)',\n", + " 2: '(55/(55*.5))',\n", + " 3: '√(5!-(555/5))',\n", " 4: '(5-(55/55))',\n", - " 5: '(5+(55-55))',\n", - " 6: '(5+(55/55))',\n", - " 7: '(((5+55)/5)-5)',\n", + " 5: '((55-55)+5)',\n", + " 6: '((55/55)+5)',\n", + " 7: '(((55+5)/5)-5)',\n", " 8: '(((5!-55)/5)-5)',\n", " 9: '(5!-(555/5))',\n", " 10: '(5!-(55+55))',\n", - " 11: '(5+((55/5)-5))',\n", - " 12: '(5!/(55/5.5))',\n", - " 13: '((5+(5+55))/5)',\n", + " 11: '((.55*5!)-55)',\n", + " 12: '((5.5/55)*5!)',\n", + " 13: '(((55+5)+5)/5)',\n", " 14: '((5*5)-(55/5))',\n", - " 15: '(5+(55/5.5))',\n", - " 16: '(((5*5)+55)/5)',\n", - " 17: '(5+((5+55)/5))',\n", - " 18: '(5+((5!-55)/5))',\n", - " 19: '((5*5)-(5+(5/5)))',\n", - " 20: '(55/(5*.55))',\n", - " 21: '(5+(5+(55/5)))',\n", + " 15: '((55/5.5)+5)',\n", + " 16: '((55+(5*5))/5)',\n", + " 17: '(((55+5)/5)+5)',\n", + " 18: '(((5!-55)/5)+5)',\n", + " 19: '((5*5)-((5/5)+5))',\n", + " 20: '(55/(.55*5))',\n", + " 21: '(((55/5)+5)+5)',\n", " 22: '((55+55)/5)',\n", - " 23: '((5+(55/.5))/5)',\n", + " 23: '(((55/.5)+5)/5)',\n", " 24: '(5-(55/55))!',\n", - " 25: '(55-(5+(5*5)))',\n", - " 26: '(55-(5+(5!/5)))',\n", - " 27: '(.5*(55-(5/5)))',\n", - " 28: '(.5*((5/5)+55))',\n", - " 29: '(5+((5*5)-(5/5)))',\n", - " 30: '(5*((55/5)-5))',\n", - " 31: '(55-(5-(5/5))!)',\n", - " 32: '(55-((5!-5)/5))',\n", - " 33: '(.55*(5+55))',\n", - " 34: '((5!+(55-5))/5)',\n", - " 35: '(5+(55-(5*5)))',\n", - " 36: '((5*5)+(55/5))',\n", - " 37: '((5!+(5!-55))/5)',\n", - " 38: '(5+(.5*(5!*.55)))',\n", - " 39: '(5+(5+(5+(5!/5))))',\n", - " 40: '(55-(5+(5+5)))',\n", - " 41: '(5!-((5!/5)+55))',\n", - " 42: '((5!*.55)-(5!/5))',\n", + " 25: '(55-((5*5)+5))',\n", + " 26: '(55-((5!/5)+5))',\n", + " 27: '((55/(5*.5))+5)',\n", + " 28: '((55+(5/5))*.5)',\n", + " 29: '(((5*5)-(5/5))+5)',\n", + " 30: '(((55/5)-5)*5)',\n", + " 31: '(((55*5)-5!)/5)',\n", + " 32: '(((5-5!)/5)+55)',\n", + " 33: '((55+5)*.55)',\n", + " 34: '(((55+5!)-5)/5)',\n", + " 35: '((55-(5*5))+5)',\n", + " 36: '((55/5)+(5*5))',\n", + " 37: '(((5!-55)+5!)/5)',\n", + " 38: '(((.55*.5)*5!)+5)',\n", + " 39: '((((5!/5)+5)+5)+5)',\n", + " 40: '(55-((5+5)+5))',\n", + " 41: '(5!-(55+(5!/5)))',\n", + " 42: '((.55*5!)-(5!/5))',\n", " 43: '(55-(5!/(5+5)))',\n", " 44: '(55-(55/5))',\n", - " 45: '((5*5!)-555)',\n", - " 46: '((5!+(55/.5))/5)',\n", - " 47: '((5!/5)+((5!-5)/5))',\n", - " 48: '(5!/(5*(5.5-5)))',\n", - " 49: '(55-(5+(5/5)))',\n", + " 45: '((5!*5)-555)',\n", + " 46: '(((55/.5)+5!)/5)',\n", + " 47: '(((5!-5)/5)+(5!/5))',\n", + " 48: '(5!/((5.5-5)*5))',\n", + " 49: '(55-((5/5)+5))',\n", " 50: '(55.5-5.5)',\n", - " 51: '((5/5)+(55-5))',\n", - " 52: '(55-(.5+(.5*5)))',\n", + " 51: '((55+(5/5))-5)',\n", + " 52: '(((5.5+5)*5)-.5)',\n", " 53: '(55-((5+5)/5))',\n", - " 54: '(((5*55)-5)/5)',\n", - " 55: '(.5*(55+55))',\n", - " 56: '((5+(5*55))/5)',\n", - " 57: '(55+((5+5)/5))',\n", - " 58: '((.5*5)+55.5)',\n", - " 59: '(5+(55-(5/5)))',\n", - " 60: '(5+(5+(55-5)))',\n", - " 61: '(5.5+55.5)',\n", + " 54: '(((55*5)-5)/5)',\n", + " 55: '((55+55)*.5)',\n", + " 56: '(((55*5)+5)/5)',\n", + " 57: '(((5+5)/5)+55)',\n", + " 58: '(55.5+(5*.5))',\n", + " 59: '((55-(5/5))+5)',\n", + " 60: '(√(55*55)+5)',\n", + " 61: '(55.5+5.5)',\n", " 62: '((55-(5!/5))/.5)',\n", - " 63: '(5.5+(.5*(5!-5)))',\n", - " 64: '(5!-((5/5)+55))',\n", - " 65: '(5*((5!-55)/5))',\n", - " 66: '(55+(55/5))',\n", - " 67: '(55+(5!/(5+5)))',\n", - " 68: '(5.5+(.5*(5+5!)))',\n", - " 69: '(5!-((.5+(5*5))/.5))',\n", - " 70: '(5+(5+(5+55)))',\n", - " 71: '((.5*5!)+(55/5))',\n", - " 72: '((5+(5/5))!/(5+5))',\n", - " 73: '((5*5)+((5!+5!)/5))',\n", - " 74: '((5!/5)+(55-5))',\n", - " 75: '((5*5)+(55-5))',\n", - " 76: '(5+(5+(5!*.55)))',\n", - " 77: '(5+(5!-((5!+5!)/5)))',\n", - " 78: '(55+((5!-5)/5))',\n", - " 79: '(55+(5-(5/5))!)',\n", - " 80: '(5*(5+(55/5)))',\n", - " 81: '((√.5+(5!/√(5-.5)))/√.5)',\n", - " 82: '(5!-(((5!/5)-5)/.5))',\n", - " 83: '((.5*5!)+((5!-5)/5))',\n", - " 84: '(5+((5!/5)+55))',\n", - " 85: '(5+((5*5)+55))',\n", + " 63: '(((5!-5)*.5)+5.5)',\n", + " 64: '(5!-(55+(5/5)))',\n", + " 65: '((5-(55+5))+5!)',\n", + " 66: '((55/5)+55)',\n", + " 67: '((5!/(5+5))+55)',\n", + " 68: '(((5!+5)*.5)+5.5)',\n", + " 69: '((5!-5)*((.5/5)+.5))',\n", + " 70: '(((55+5)+5)+5)',\n", + " 71: '((55/5)+(5!*.5))',\n", + " 72: '(((5/5)+5)!/(5+5))',\n", + " 73: '(((5!+5!)/5)+(5*5))',\n", + " 74: '((55+(5!/5))-5)',\n", + " 75: '((55+(5*5))-5)',\n", + " 76: '(((.55*5!)+5)+5)',\n", + " 77: '((((5!+5!)+5!)/5)+5)',\n", + " 78: '(((5!-5)/5)+55)',\n", + " 79: '(((55*5)+5!)/5)',\n", + " 80: '(((55/5)+5)*5)',\n", + " 81: '(((5!/√(5-.5))+√.5)/√.5)',\n", + " 82: '(((5-(5!/5))/.5)+5!)',\n", + " 83: '(((5!-5)/5)+(5!*.5))',\n", + " 84: '((55+(5!/5))+5)',\n", + " 85: '((55+(5*5))+5)',\n", " 86: '((55/.5)-(5!/5))',\n", " 87: '((555-5!)/5)',\n", - " 88: '(.5+(.5*(5!+55)))',\n", - " 89: '(5!-(55-(5!/5)))',\n", - " 90: '(5!-(55-(5*5)))',\n", - " 91: '((5*5)+(5!*.55))',\n", - " 92: '(5!-(.5+(.5*55)))',\n", - " 93: '(.5+(5!-(.5*55)))',\n", - " 94: '(5!-((5*5)+(5/5)))',\n", + " 88: '((.55/(.5^5))*5)',\n", + " 89: '(((5!/5)-55)+5!)',\n", + " 90: '(((5*5)-55)+5!)',\n", + " 91: '((.55*5!)+(5*5))',\n", + " 92: '(5!-((55*.5)+.5))',\n", + " 93: '((.5-(55*.5))+5!)',\n", + " 94: '(5!-((5/5)+(5*5)))',\n", " 95: '(((55-5)/.5)-5)',\n", - " 96: '(5!-((5*5)-(5/5)))',\n", - " 97: '(5!-((5!/5)-(5/5)))',\n", - " 98: '(5!-(55/(.5*5)))',\n", + " 96: '(((5/5)+5!)-(5*5))',\n", + " 97: '((((5!*5)+5)-5!)/5)',\n", + " 98: '(5!-(55/(5*.5)))',\n", " 99: '((55-5.5)/.5)',\n", " 100: '((55/.5)-(5+5))',\n", " 101: '((55.5-5)/.5)',\n", - " 102: '(5+(5!-((5!-5)/5)))',\n", - " 103: '(55+((5!+5!)/5))',\n", - " 104: '(5!-(5+(55/5)))',\n", - " 105: '(55+(55-5))',\n", + " 102: '((((5-5!)/5)+5)+5!)',\n", + " 103: '(((5!+5!)/5)+55)',\n", + " 104: '(5!-((55/5)+5))',\n", + " 105: '((55+55)-5)',\n", " 106: '((555/5)-5)',\n", - " 107: '(5!-((5!-55)/5))',\n", - " 108: '(5!-((5+55)/5))',\n", - " 109: '(((5*5!)-55)/5)',\n", + " 107: '(((55-5!)/5)+5!)',\n", + " 108: '(5!-((55+5)/5))',\n", + " 109: '(((5!*5)-55)/5)',\n", " 110: '((555-5)/5)',\n", " 111: '(555/√(5*5))',\n", - " 112: '((5+555)/5)',\n", - " 113: '(5!-(5+((5+5)/5)))',\n", - " 114: '(5+(5!-(55/5)))',\n", - " 115: '(5+(55+55))',\n", - " 116: '(5+(555/5))',\n", - " 117: '(5!-(5-((5+5)/5)))',\n", - " 118: '(5!-(5!/(5+55)))',\n", + " 112: '((555+5)/5)',\n", + " 113: '(5!-(((5+5)/5)+5))',\n", + " 114: '((5-(55/5))+5!)',\n", + " 115: '((55+55)+5)',\n", + " 116: '((555/5)+5)',\n", + " 117: '((((5+5)/5)-5)+5!)',\n", + " 118: '(5!-(5!/(55+5)))',\n", " 119: '(5!-(55/55))',\n", - " 120: '(5!+(55-55))',\n", - " 121: '(5!+(55/55))',\n", - " 122: '(5!+(5!/(5+55)))',\n", - " 123: '(5+(5!-((5+5)/5)))',\n", - " 124: '((5*(5*5))-(5/5))',\n", - " 125: '(.5*(5*(55-5)))',\n", - " 126: '(5!+((55/5)-5))',\n", - " 127: '((5!*(5.5/5))-5)',\n", - " 128: '(5!+(5!/(5+(5+5))))',\n", + " 120: '((55-55)+5)!',\n", + " 121: '((55/55)+5!)',\n", + " 122: '((5!/(55+5))+5!)',\n", + " 123: '((((5+5)+5)/5)+5!)',\n", + " 124: '(((5*5)*5)-(5/5))',\n", + " 125: '(((55-5)*5)*.5)',\n", + " 126: '(((55/5)+5!)-5)',\n", + " 127: '(((5.5/5)*5!)-5)',\n", + " 128: '(((5*.5)+5.5)+5!)',\n", " 129: '((5!-55.5)/.5)',\n", - " 130: '(5!+(55/5.5))',\n", - " 131: '((55+(5*5!))/5)',\n", - " 132: '(5!+((5+55)/5))',\n", - " 133: '(5!+((5!-55)/5))',\n", - " 134: '((5!/5)+(55/.5))',\n", - " 135: '((5!+555)/5)',\n", - " 136: '(5+(5!+(55/5)))',\n", - " 137: '(5+(5!*(5.5/5)))',\n", - " 138: '(.5+(.5*(5*55)))',\n", - " 139: '(((5+(5/5))!/5)-5)',\n", - " 140: '(.5*(5+(5*55)))',\n", - " 141: '(5!+((5+5.5)/.5))',\n", - " 142: '(5!+(55/(.5*5)))',\n", - " 143: '(((5+(5/5))!-5)/5)',\n", + " 130: '((55/5.5)+5!)',\n", + " 131: '(((5!*5)+55)/5)',\n", + " 132: '(((55+5)/5)+5!)',\n", + " 133: '(((5!-55)/5)+5!)',\n", + " 134: '((55/.5)+(5!/5))',\n", + " 135: '((555+5!)/5)',\n", + " 136: '(((55/5)+5!)+5)',\n", + " 137: '(((5.5/5)*5!)+5)',\n", + " 138: '(((55*5)*.5)+.5)',\n", + " 139: '((((5/5)+5)!/5)-5)',\n", + " 140: '(((55*5)+5)*.5)',\n", + " 141: '(((5.5+5)/.5)+5!)',\n", + " 142: '((55/(5*.5))+5!)',\n", + " 143: '((((5/5)+5)!-5)/5)',\n", " 144: '(((55/5)-5)!/5)',\n", - " 145: '(5!+(.5*(55-5)))',\n", - " 146: '(5!+((5*5)+(5/5)))',\n", - " 147: '(5!+((.5*55)-.5))',\n", - " 148: '(.5+(5!+(.5*55)))',\n", - " 149: '(5+((5+(5/5))!/5))',\n", - " 150: '(5*(55-(5*5)))',\n", - " 151: '(5!+(55-(5!/5)))',\n", - " 152: '(5!+(((5+5)/5)**5))',\n", - " 153: '(5!+(.5*(5!*.55)))',\n", - " 154: '(5+(5+(5!+(5!/5))))',\n", - " 155: '(5*(55-(5!/5)))',\n", - " 156: '((5!+(5!*5.5))/5)'}" + " 145: '((((5*5)+5)*5)-5)',\n", + " 146: '(((5/5)+(5*5))+5!)',\n", + " 147: '(((55*.5)+5!)-.5)',\n", + " 148: '(((55*.5)+5!)+.5)',\n", + " 149: '(((5*5)*5)+(5!/5))',\n", + " 150: '((55-(5*5))*5)',\n", + " 151: '((55-(5!/5))+5!)',\n", + " 152: '((((5+5)/5)^5)+5!)',\n", + " 153: '(((.55*.5)*5!)+5!)',\n", + " 154: '((((5!/5)+5!)+5)+5)',\n", + " 155: '((55-(5!/5))*5)',\n", + " 156: '(((5.5*5!)+5!)/5)'}" ] }, - "execution_count": 69, + "execution_count": 70, "metadata": {}, "output_type": "execute_result" } @@ -1675,7 +1693,7 @@ "source": [ "clear()\n", "\n", - "%time makeable(ff)" + "%time makeable(five5s)" ] }, { @@ -1688,9 +1706,9 @@ } }, "source": [ - "Wow! We almost tripled the 55 goal! \n", + "Wow! We almost tripled the 55 goal! (Although the increased number of expressions means it took 6 minutes.)\n", "\n", - "I have to say, I would never have come up with the solution for 81 on my own. It works because (√(5 - .5) \\* √.5) = √(4.5 \\* 0.5) = (√2.25) = 1.5." + "I have to say, I would never have come up with the solution for 81 on my own. It works because (√(5 - .5) \\* √.5) = √(4.5 \\* 0.5) = √(9/4) = 3/2." ] }, { @@ -1720,13 +1738,12 @@ "But still not allowing three consecutive applications, such as\n", "\n", "- ⌈√5⌉! = 6\n", - "\n", - "To compensate for these new expressions, I'll be pickier about when I allow the square root function to apply." + "\n" ] }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 72, "metadata": { "button": false, "collapsed": true, @@ -1744,14 +1761,15 @@ "def unary_expressions(numbers):\n", " \"Fill tables for -v, √v and v!, ⌊x⌋, and ⌈x⌉\"\n", " for i in range(2):\n", - " for v in list(EXPS[numbers]):\n", + " for v in tuple(EXPS[numbers]):\n", " exp = EXPS[numbers][v]\n", " expr(numbers, -v, '-(' + exp + ')')\n", " if 0 < v <= 100 and 4*v == round(4*v):\n", + " # Be stingier in allowing √ operator\n", " expr(numbers, sqrt(v), '√' + exp)\n", - " if 2 <= v <= 6 and v == round(v):\n", + " if 3 <= v <= 6 and v == int(v):\n", " expr(numbers, factorial(v), exp + '!')\n", - " if floor_ceil_allowed and v != round(v):\n", + " if floor_ceil_allowed and v != int(v):\n", " uexp = unbracket(exp)\n", " expr(numbers, floor(v), '⌊' + uexp + '⌋')\n", " expr(numbers, ceil(v), '⌈' + uexp + '⌉')\n", @@ -1774,12 +1792,12 @@ } }, "source": [ - "Let's try:" + "Let's try (warning—it will take 20 or 30 minutes to run):" ] }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 73, "metadata": { "button": false, "new_sheet": false, @@ -1792,1017 +1810,1017 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6min 54s, sys: 2.69 s, total: 6min 57s\n", - "Wall time: 6min 58s\n" + "CPU times: user 24min 17s, sys: 3.22 s, total: 24min 21s\n", + "Wall time: 24min 23s\n" ] }, { "data": { "text/plain": [ - "{0: '⌊5/5555⌋',\n", - " 1: '⌈5/5555⌉',\n", - " 2: '⌊5*.5555⌋',\n", - " 3: '⌈5*.5555⌉',\n", + "{0: '⌊55/555⌋',\n", + " 1: '⌈55/555⌉',\n", + " 2: '⌊.5555*5⌋',\n", + " 3: '⌈.5555*5⌉',\n", " 4: '⌊5-.5555⌋',\n", " 5: '⌊5.5555⌋',\n", " 6: '⌈5.5555⌉',\n", - " 7: '⌈.5+5.555⌉',\n", - " 8: '(5+⌈5*.555⌉)',\n", - " 9: '⌊5/.5555⌋',\n", + " 7: '⌈5.55+.55⌉',\n", + " 8: '⌈5.555+√5⌉',\n", + " 9: '⌊55/5.55⌋',\n", " 10: '⌊555/55⌋',\n", " 11: '⌈555/55⌉',\n", " 12: '⌈55.55/5⌉',\n", - " 13: '⌊55/⌊5-.55⌋⌋',\n", - " 14: '(5+⌊5/.555⌋)',\n", - " 15: '(5+(55/5.5))',\n", - " 16: '(5+⌊55.5/5⌋)',\n", - " 17: '(5+⌈55.5/5⌉)',\n", + " 13: '⌊(.555*5)*5⌋',\n", + " 14: '⌈(.555*5)*5⌉',\n", + " 15: '⌊(5.55+5)+5⌋',\n", + " 16: '⌈(5.55+5)+5⌉',\n", + " 17: '⌈(55.5/5)+5⌉',\n", " 18: '⌊55/⌈5!/55⌉⌋',\n", " 19: '⌈55/⌈5!/55⌉⌉',\n", - " 20: '(5*⌊555/5!⌋)',\n", + " 20: '(⌊555/5!⌋*5)',\n", " 21: '⌊5!/5.555⌋',\n", - " 22: '((55+55)/5)',\n", + " 22: '⌈5!/5.555⌉',\n", " 23: '⌈555/(5*5)⌉',\n", " 24: '⌊5-.5555⌋!',\n", - " 25: '(5*⌈555/5!⌉)',\n", - " 26: '⌈55*(55/5!)⌉',\n", - " 27: '⌊5*5.555⌋',\n", - " 28: '⌈5*5.555⌉',\n", - " 29: '(5+⌊555/5!⌋!)',\n", - " 30: '⌊55*.555⌋',\n", - " 31: '⌈55*.555⌉',\n", - " 32: '(5+⌊5*5.55⌋)',\n", - " 33: '(5+⌈5*5.55⌉)',\n", - " 34: '(55-⌊5!/5.5⌋)',\n", - " 35: '(5+⌊.55*55⌋)',\n", - " 36: '(5+⌈.55*55⌉)',\n", - " 37: '⌊5*(55/√55)⌋',\n", - " 38: '⌈5*(55/√55)⌉',\n", - " 39: '(55-⌊5!/√55⌋)',\n", - " 40: '(5*⌈55/√55⌉)',\n", - " 41: '⌊√55*5.55⌋',\n", - " 42: '⌈√55*5.55⌉',\n", - " 43: '(55-⌊5+√55⌋)',\n", + " 25: '(⌊5.555⌋*5)',\n", + " 26: '⌈(55*55)/5!⌉',\n", + " 27: '⌊5.555*5⌋',\n", + " 28: '⌈5.555*5⌉',\n", + " 29: '(⌊555/5!⌋!+5)',\n", + " 30: '⌊.555*55⌋',\n", + " 31: '⌈.555*55⌉',\n", + " 32: '⌊(5.55*5)+5⌋',\n", + " 33: '⌈(5.55*5)+5⌉',\n", + " 34: '⌈5.55*⌈5.5⌉⌉',\n", + " 35: '⌊(55*.55)+5⌋',\n", + " 36: '⌈(55*.55)+5⌉',\n", + " 37: '⌊(55/√55)*5⌋',\n", + " 38: '⌈(55/√55)*5⌉',\n", + " 39: '⌊55.55*√.5⌋',\n", + " 40: '(55-((5+5)+5))',\n", + " 41: '⌊5.55*√55⌋',\n", + " 42: '⌈5.55*√55⌉',\n", + " 43: '⌈55-(√55+5)⌉',\n", " 44: '(55-(55/5))',\n", - " 45: '((5*5!)-555)',\n", + " 45: '((5!*5)-555)',\n", " 46: '⌊5555/5!⌋',\n", " 47: '⌈5555/5!⌉',\n", - " 48: '⌈55-√55.5⌉',\n", + " 48: '⌊55.5-√55⌋',\n", " 49: '⌊55-5.55⌋',\n", - " 50: '⌊55.55-5⌋',\n", + " 50: '⌈55-5.55⌉',\n", " 51: '⌈55.55-5⌉',\n", - " 52: '(55-⌈5!/55⌉)',\n", - " 53: '(55-⌊5!/55⌋)',\n", + " 52: '⌊55-(5!/55)⌋',\n", + " 53: '⌈55-(5!/55)⌉',\n", " 54: '⌊55-.555⌋',\n", " 55: '⌊55.555⌋',\n", " 56: '⌈55.555⌉',\n", - " 57: '(55+⌊5!/55⌋)',\n", - " 58: '(55+⌈5!/55⌉)',\n", - " 59: '(5+⌊55-.55⌋)',\n", - " 60: '⌊5+55.55⌋',\n", - " 61: '⌈5+55.55⌉',\n", - " 62: '⌊√55+55.5⌋',\n", - " 63: '⌈√55+55.5⌉',\n", + " 57: '⌈55.55+.5⌉',\n", + " 58: '⌈(5!/55)+55⌉',\n", + " 59: '⌊(55-.55)+5⌋',\n", + " 60: '⌊55.55+5⌋',\n", + " 61: '⌈55.55+5⌉',\n", + " 62: '⌊√55.5+55⌋',\n", + " 63: '⌈√55.5+55⌉',\n", " 64: '⌊5!-55.55⌋',\n", " 65: '⌈5!-55.55⌉',\n", - " 66: '(55+(55/5))',\n", - " 67: '⌈5!*.5555⌉',\n", - " 68: '(5+⌈55+√55⌉)',\n", + " 66: '⌊.5555*5!⌋',\n", + " 67: '⌈.5555*5!⌉',\n", + " 68: '⌈(√55+55)+5⌉',\n", " 69: '⌊555/⌈√55⌉⌋',\n", " 70: '⌈555/⌈√55⌉⌉',\n", - " 71: '(5+⌊5!*.555⌋)',\n", - " 72: '(5+⌈5!*.555⌉)',\n", - " 73: '(5!-⌊55-√55⌋)',\n", + " 71: '⌊(.555*5!)+5⌋',\n", + " 72: '⌈(.555*5!)+5⌉',\n", + " 73: '⌊(5!/55)^5.5⌋',\n", " 74: '⌊555/√55⌋',\n", " 75: '⌈555/√55⌉',\n", - " 76: '(55+⌊5!/5.5⌋)',\n", - " 77: '(55+⌈5!/5.5⌉)',\n", - " 78: '(55+((5!-5)/5))',\n", + " 76: '⌊555/(5+√5)⌋',\n", + " 77: '⌈555/(5+√5)⌉',\n", + " 78: '⌈√⌊5!/55⌋*55⌉',\n", " 79: '⌊555/⌊√55⌋⌋',\n", - " 80: '⌊(5*5)+55.5⌋',\n", - " 81: '⌈(5*5)+55.5⌉',\n", - " 82: '(55+⌊.5*55⌋)',\n", - " 83: '(55+⌈.5*55⌉)',\n", - " 84: '(5+((5!/5)+55))',\n", - " 85: '(5+((5*5)+55))',\n", - " 86: '(5!-⌈5**(5!/55)⌉)',\n", + " 80: '⌊55.5+(5*5)⌋',\n", + " 81: '⌈55.5+(5*5)⌉',\n", + " 82: '⌊(55*.5)+55⌋',\n", + " 83: '⌈(55*.5)+55⌉',\n", + " 84: '((55+(5!/5))+5)',\n", + " 85: '((55+(5*5))+5)',\n", + " 86: '⌊5!-(5^(5!/55))⌋',\n", " 87: '((555-5!)/5)',\n", - " 88: '⌈5**(5*.555)⌉',\n", - " 89: '(5!-⌈.55*55⌉)',\n", + " 88: '⌈√5^5.555⌉',\n", + " 89: '⌊5!-(55*.55)⌋',\n", " 90: '⌊(55-5)/.55⌋',\n", " 91: '⌈(55-5)/.55⌉',\n", " 92: '⌊555/⌈5.5⌉⌋',\n", " 93: '⌈555/⌈5.5⌉⌉',\n", - " 94: '(⌊55/.55⌋-5)',\n", - " 95: '(⌈55/.55⌉-5)',\n", - " 96: '(5!-⌊555/5!⌋!)',\n", - " 97: '⌈.55*(5!+55)⌉',\n", - " 98: '(5!-⌈5!/5.55⌉)',\n", + " 94: '⌊(55/.55)-5⌋',\n", + " 95: '⌈(55/.55)-5⌉',\n", + " 96: '⌊(55+5!)*.55⌋',\n", + " 97: '⌈(55+5!)*.55⌉',\n", + " 98: '⌊⌊55-.5⌋/.55⌋',\n", " 99: '⌊55/.555⌋',\n", - " 100: '⌊555/5.5⌋',\n", + " 100: '⌈55/.555⌉',\n", " 101: '⌈555/5.5⌉',\n", " 102: '⌈⌈55.5⌉/.55⌉',\n", - " 103: '(55+((5!+5!)/5))',\n", - " 104: '(5+⌊55/.55⌋)',\n", - " 105: '(55+(55-5))',\n", + " 103: '⌈⌈55/.55⌉+√5⌉',\n", + " 104: '⌊(55/.55)+5⌋',\n", + " 105: '((55+55)-5)',\n", " 106: '((555/5)-5)',\n", - " 107: '(55+⌊55-√5⌋)',\n", - " 108: '(5!-⌈55.5/5⌉)',\n", - " 109: '(55+⌊55-.5⌋)',\n", - " 110: '⌊55+55.5⌋',\n", - " 111: '⌈55+55.5⌉',\n", + " 107: '⌊(55+55)-√5⌋',\n", + " 108: '⌈(55+55)-√5⌉',\n", + " 109: '⌊(55+55)-.5⌋',\n", + " 110: '⌊55.5+55⌋',\n", + " 111: '⌈55.5+55⌉',\n", " 112: '⌈555.5/5⌉',\n", - " 113: '(55+⌈√5+55⌉)',\n", + " 113: '⌈(55+55)+√5⌉',\n", " 114: '⌊5!-5.555⌋',\n", - " 115: '(5+(55+55))',\n", - " 116: '(5+(555/5))',\n", - " 117: '(5!-⌈5*.555⌉)',\n", - " 118: '(5!-⌈5.55/5⌉)',\n", + " 115: '((55+55)+5)',\n", + " 116: '((555/5)+5)',\n", + " 117: '⌊5!-(.555*5)⌋',\n", + " 118: '⌈5!-(.555*5)⌉',\n", " 119: '⌊5!-.5555⌋',\n", " 120: '⌊5.5555⌋!',\n", - " 121: '⌈5!+.5555⌉',\n", - " 122: '(5!+⌈5.55/5⌉)',\n", + " 121: '⌈.5555+5!⌉',\n", + " 122: '⌊(.555*5)+5!⌋',\n", " 123: '⌊555/(5-.5)⌋',\n", - " 124: '(5!+⌊555/5!⌋)',\n", - " 125: '⌊5!+5.555⌋',\n", - " 126: '⌈5!+5.555⌉',\n", - " 127: '⌊(5**5.5)/55⌋',\n", - " 128: '⌈(5**5.5)/55⌉',\n", - " 129: '(5!+⌊5/.555⌋)',\n", - " 130: '(5+⌊5!+5.55⌋)',\n", - " 131: '(5+⌈5!+5.55⌉)',\n", - " 132: '(5!+⌈55.5/5⌉)',\n", - " 133: '⌈55*(√55-5)⌉',\n", - " 134: '⌈5!*(5.55/5)⌉',\n", - " 135: '((5!+555)/5)',\n", - " 136: '(5+(5!+(55/5)))',\n", - " 137: '⌊5*(55/⌊.5*5⌋)⌋',\n", - " 138: '⌊5*(5*5.55)⌋',\n", - " 139: '⌈5*(5*5.55)⌉',\n", - " 140: '(5*⌈5*5.55⌉)',\n", - " 141: '(5!+⌊5!/5.55⌋)',\n", - " 142: '(5!+⌈5!/5.55⌉)',\n", - " 143: '(5+⌈.5*(5*55)⌉)',\n", + " 124: '⌊55.55*√5⌋',\n", + " 125: '⌊5.555+5!⌋',\n", + " 126: '⌈5.555+5!⌉',\n", + " 127: '⌊⌈5^5.5⌉/55⌋',\n", + " 128: '⌈⌈5^5.5⌉/55⌉',\n", + " 129: '⌊(5/.555)+5!⌋',\n", + " 130: '⌊(5.55+5)+5!⌋',\n", + " 131: '⌈(5.55+5)+5!⌉',\n", + " 132: '⌊(√55-5)*55⌋',\n", + " 133: '⌈(√55-5)*55⌉',\n", + " 134: '⌈(5.55/5)*5!⌉',\n", + " 135: '((555+5!)/5)',\n", + " 136: '(((55/5)+5!)+5)',\n", + " 137: '⌈⌈55.5+5⌉*√5⌉',\n", + " 138: '⌊(5.55*5)*5⌋',\n", + " 139: '⌈(5.55*5)*5⌉',\n", + " 140: '(⌈5.55*5⌉*5)',\n", + " 141: '⌊⌊55^√5⌋/55⌋',\n", + " 142: '⌈⌊55^√5⌋/55⌉',\n", + " 143: '⌈((55*5)*.5)+5⌉',\n", " 144: '(⌈5.555⌉!/5)',\n", - " 145: '(5+(5*⌈.5*55⌉))',\n", - " 146: '⌊55*(5-√5.5)⌋',\n", - " 147: '(5!+⌊5*5.55⌋)',\n", - " 148: '(5!+⌈5*5.55⌉)',\n", - " 149: '⌈5.5*⌊.5*55⌋⌉',\n", - " 150: '(5*⌊.55*55⌋)',\n", - " 151: '⌊.55*(5*55)⌋',\n", - " 152: '⌈.55*(5*55)⌉',\n", - " 153: '⌈5*(5.5+(5*5))⌉',\n", - " 154: '(5.5*⌈.5*55⌉)',\n", - " 155: '(5*⌈.55*55⌉)',\n", - " 156: '⌊555/(5*√.5)⌋',\n", - " 157: '(⌊.5*555⌋-5!)',\n", - " 158: '(⌈.5*555⌉-5!)',\n", - " 159: '⌊5.5*(5+(5!/5))⌋',\n", - " 160: '(5+((5*55)-5!))',\n", - " 161: '⌊(.5*5)**5.55⌋',\n", - " 162: '⌊5*(5+(.5*55))⌋',\n", - " 163: '(⌊5!/.55⌋-55)',\n", - " 164: '(⌈5!/.55⌉-55)',\n", - " 165: '(55*⌈5!/55⌉)',\n", - " 166: '⌊5.5**⌈5!/55⌉⌋',\n", - " 167: '(5!+⌊55-√55⌋)',\n", - " 168: '(5!+⌈55-√55⌉)',\n", - " 169: '(5!+⌊55-5.5⌋)',\n", - " 170: '(5!+⌊55.5-5⌋)',\n", - " 171: '(5!+⌈55.5-5⌉)',\n", - " 172: '⌈5.555**⌈√5⌉⌉',\n", - " 173: '⌊55*√⌊5+5.5⌋⌋',\n", - " 174: '(5!+⌊55-.55⌋)',\n", - " 175: '⌊5!+55.55⌋',\n", - " 176: '⌈5!+55.55⌉',\n", - " 177: '(55+⌊√5*55⌋)',\n", - " 178: '(55+⌈√5*55⌉)',\n", - " 179: '⌊55*(5.5-√5)⌋',\n", - " 180: '(5+⌊5!+55.5⌋)',\n", - " 181: '(5+⌈5!+55.5⌉)',\n", - " 182: '(⌊5.5*55⌋-5!)',\n", - " 183: '(⌈5.5*55⌉-5!)',\n", - " 184: '(5!+⌊5!-55.5⌋)',\n", - " 185: '(555/⌈.5*5⌉)',\n", - " 186: '(5!+⌊5!*.555⌋)',\n", - " 187: '(5!+⌈5!*.555⌉)',\n", - " 188: '((⌈.5*5⌉**5)-55)',\n", - " 189: '⌊√(5+5)*(5+55)⌋',\n", - " 190: '(5*⌈5*√55.5⌉)',\n", - " 191: '(5+⌈5*(5*√55)⌉)',\n", - " 192: '(⌈5.55⌉/(.5**5))',\n", - " 193: '(⌊5!/.55⌋-(5*5))',\n", + " 145: '((⌊5.55⌋*5)+5!)',\n", + " 146: '⌊(5-√5.5)*55⌋',\n", + " 147: '⌊(5.55*5)+5!⌋',\n", + " 148: '⌈(5.55*5)+5!⌉',\n", + " 149: '⌈⌊55*.5⌋*5.5⌉',\n", + " 150: '(⌊55*.55⌋*5)',\n", + " 151: '⌊(55*.55)*5⌋',\n", + " 152: '⌈(55*.55)*5⌉',\n", + " 153: '⌊(.55+√5)*55⌋',\n", + " 154: '(⌈55*.5⌉*5.5)',\n", + " 155: '(⌈55*.55⌉*5)',\n", + " 156: '⌈(55+55)/√.5⌉',\n", + " 157: '⌊(555*.5)-5!⌋',\n", + " 158: '⌈(555*.5)-5!⌉',\n", + " 159: '⌈(55-5)*√(5+5)⌉',\n", + " 160: '(((55*5)-5!)+5)',\n", + " 161: '⌊(5*.5)^5.55⌋',\n", + " 162: '⌈(5*.5)^5.55⌉',\n", + " 163: '⌊(5!/.55)-55⌋',\n", + " 164: '⌊(.555*5)^5⌋',\n", + " 165: '(⌈5!/55⌉*55)',\n", + " 166: '⌊5.5^⌈5!/55⌉⌋',\n", + " 167: '⌈5.5^⌈5!/55⌉⌉',\n", + " 168: '⌈(55-√55)+5!⌉',\n", + " 169: '⌊(55-5.5)+5!⌋',\n", + " 170: '⌈(55-5.5)+5!⌉',\n", + " 171: '⌈(55.5+5!)-5⌉',\n", + " 172: '⌈5.555^⌈√5⌉⌉',\n", + " 173: '⌊√⌊5.5+5⌋*55⌋',\n", + " 174: '⌊(55-.55)+5!⌋',\n", + " 175: '⌊55.55+5!⌋',\n", + " 176: '⌈55.55+5!⌉',\n", + " 177: '⌊(55*√5)+55⌋',\n", + " 178: '⌈(55*√5)+55⌉',\n", + " 179: '⌈√(5.5+5)*55⌉',\n", + " 180: '⌊(55.5+5)+5!⌋',\n", + " 181: '⌈(55.5+5)+5!⌉',\n", + " 182: '⌊(55*5.5)-5!⌋',\n", + " 183: '⌈(55*5.5)-5!⌉',\n", + " 184: '⌊(5!-55.5)+5!⌋',\n", + " 185: '(555/⌈5*.5⌉)',\n", + " 186: '⌊(.555*5!)+5!⌋',\n", + " 187: '⌈(.555*5!)+5!⌉',\n", + " 188: '((⌈5*.5⌉^5)-55)',\n", + " 189: '⌊(55+5)*√(5+5)⌋',\n", + " 190: '(⌈√55.5*5⌉*5)',\n", + " 191: '⌈√⌊√55+5⌋*55⌉',\n", + " 192: '⌈⌈√55.5^5⌉/5!⌉',\n", + " 193: '⌊5!^(.55+.55)⌋',\n", " 194: '⌊(555-5!)/√5⌋',\n", " 195: '⌈(555-5!)/√5⌉',\n", - " 196: '⌊555/√⌈√5+5⌉⌋',\n", - " 197: '⌊.5*(5!+(5*55))⌋',\n", + " 196: '⌊555/√⌈5+√5⌉⌋',\n", + " 197: '⌊((55*5)+5!)*.5⌋',\n", " 198: '(⌊55/.55⌋/.5)',\n", - " 199: '⌊55/(.5*.55)⌋',\n", + " 199: '⌊55/(.55*.5)⌋',\n", " 200: '⌊555/(5-√5)⌋',\n", " 201: '⌈555/(5-√5)⌉',\n", - " 202: '⌊555/(.5+√5)⌋',\n", - " 203: '⌊5!**(5.55/5)⌋',\n", - " 204: '⌈5!**(5.55/5)⌉',\n", - " 205: '(5*⌈5.5*√55⌉)',\n", - " 206: '⌈⌈5!-√55⌉/.55⌉',\n", + " 202: '⌊555/(√5+.5)⌋',\n", + " 203: '⌊5!^(5.55/5)⌋',\n", + " 204: '⌈5!^(5.55/5)⌉',\n", + " 205: '(⌈√55*5.5⌉*5)',\n", + " 206: '⌈5.55*⌈5^√5⌉⌉',\n", " 207: '⌊(5!-5)/.555⌋',\n", " 208: '⌈(5!-5)/.555⌉',\n", - " 209: '(5.5*⌈5*√55⌉)',\n", - " 210: '((⌈5.5⌉*55)-5!)',\n", - " 211: '(⌊5!/.555⌋-5)',\n", - " 212: '(⌈5!/.555⌉-5)',\n", - " 213: '⌊⌈5!/.55⌉-5.5⌋',\n", - " 214: '⌈⌈5!/.55⌉-5.5⌉',\n", - " 215: '((⌊5-.5⌋*55)-5)',\n", + " 209: '(⌈√55*5⌉*5.5)',\n", + " 210: '((55*⌈5.5⌉)-5!)',\n", + " 211: '⌊(5!/.555)-5⌋',\n", + " 212: '⌈(5!/.555)-5⌉',\n", + " 213: '⌈(5!/.55)-5.5⌉',\n", + " 214: '⌊⌊5!-.5⌋/.555⌋',\n", + " 215: '((55*⌊5-.5⌋)-5)',\n", " 216: '⌊5!/.5555⌋',\n", " 217: '⌈5!/.5555⌉',\n", - " 218: '⌈.5*(555-5!)⌉',\n", - " 219: '(5!+⌊55/.55⌋)',\n", - " 220: '((5*55)-55)',\n", - " 221: '(5+⌊5!/.555⌋)',\n", - " 222: '(555/(.5*5))',\n", - " 223: '⌊5.5+⌊5!/.55⌋⌋',\n", - " 224: '⌊5.5+⌈5!/.55⌉⌋',\n", - " 225: '(5*(55-(5+5)))',\n", - " 226: '⌈(5+5!)/.555⌉',\n", + " 218: '⌈(555-5!)*.5⌉',\n", + " 219: '(⌊55/.55⌋+5!)',\n", + " 220: '((55*5)-55)',\n", + " 221: '⌊(5!/.555)+5⌋',\n", + " 222: '(555/(5*.5))',\n", + " 223: '⌊⌈55*√5⌉/.55⌋',\n", + " 224: '⌈⌈55*√5⌉/.55⌉',\n", + " 225: '((55-(5+5))*5)',\n", + " 226: '⌈(5!+5)/.555⌉',\n", " 227: '⌈555/√⌈5.5⌉⌉',\n", - " 228: '(⌊5!-5.55⌋/.5)',\n", - " 229: '(5!+(5!-(55/5)))',\n", - " 230: '(5!+(55+55))',\n", - " 231: '(5!+(555/5))',\n", - " 232: '(5+⌊(5+5!)/.55⌋)',\n", - " 233: '(5+⌈(5+5!)/.55⌉)',\n", - " 234: '(5!+⌊5!-5.55⌋)',\n", - " 235: '(5*⌊55-√55⌋)',\n", + " 228: '⌊(5.5+5!)/.55⌋',\n", + " 229: '⌊⌈5.5+5!⌉/.55⌋',\n", + " 230: '((55+55)+5!)',\n", + " 231: '((555/5)+5!)',\n", + " 232: '⌈(√55+5!)/.55⌉',\n", + " 233: '⌈⌈√55+5!⌉/.55⌉',\n", + " 234: '⌊(5!-5.55)+5!⌋',\n", + " 235: '(⌊55-√55⌋*5)',\n", " 236: '⌊555/√5.5⌋',\n", " 237: '⌈555/√5.5⌉',\n", - " 238: '⌈5*(55-√55)⌉',\n", - " 239: '(5!+⌊5!-.555⌋)',\n", - " 240: '(5*⌈55-√55⌉)',\n", - " 241: '(5!+⌈5!+.555⌉)',\n", - " 242: '(⌊(5-.5)*55⌋-5)',\n", - " 243: '(⌈5*.555⌉**5)',\n", - " 244: '⌊55*(5-.55)⌋',\n", - " 245: '(5*⌊55-5.5⌋)',\n", - " 246: '⌈(555-5)/√5⌉',\n", - " 247: '⌊5*(55-5.5)⌋',\n", - " 248: '⌈5*(55-5.5)⌉',\n", + " 238: '⌈(55-√55)*5⌉',\n", + " 239: '⌊(5!-.555)+5!⌋',\n", + " 240: '(⌊5.555⌋!+5!)',\n", + " 241: '⌈(.555+5!)+5!⌉',\n", + " 242: '⌈(.555+5!)/.5⌉',\n", + " 243: '(⌈.555*5⌉^5)',\n", + " 244: '⌊(5-.55)*55⌋',\n", + " 245: '⌈(5-.55)*55⌉',\n", + " 246: '⌈(55+55)*√5⌉',\n", + " 247: '⌊(55-5.5)*5⌋',\n", + " 248: '⌈(55-5.5)*5⌉',\n", " 249: '⌈555.5/√5⌉',\n", - " 250: '(5*⌊55.5-5⌋)',\n", - " 251: '⌈(5+555)/√5⌉',\n", - " 252: '⌊5*(55.5-5)⌋',\n", - " 253: '⌈5*(55.5-5)⌉',\n", - " 254: '(5+⌈555/√5⌉)',\n", - " 255: '(5*⌈55.5-5⌉)',\n", - " 256: '(⌊5!*(5!/55)⌋-5)',\n", - " 257: '(⌈5!*(5!/55)⌉-5)',\n", - " 258: '(5!+⌈.5*(5*55)⌉)',\n", - " 259: '⌊5!/(55.5/5!)⌋',\n", - " 260: '⌈5!/(55.5/5!)⌉',\n", - " 261: '⌊555/√(5-.5)⌋',\n", - " 262: '⌊5*(5*(5+5.5))⌋',\n", - " 263: '⌈5*(5*(5+5.5))⌉',\n", - " 264: '(5!/(5/(55/5)))',\n", - " 265: '((5*55)-(5+5))',\n", - " 266: '(5+⌊5!*(5!/55)⌋)',\n", - " 267: '⌊(5*55)-√55⌋',\n", - " 268: '⌈(5*55)-√55⌉',\n", - " 269: '⌊(5*55)-5.5⌋',\n", - " 270: '(5*⌊55-.55⌋)',\n", - " 271: '(⌈.5-5⌉+(5*55))',\n", - " 272: '(⌊.5*555⌋-5)',\n", - " 273: '(⌈.5*555⌉-5)',\n", - " 274: '⌊(5*55)-.55⌋',\n", - " 275: '(5*⌊55.55⌋)',\n", - " 276: '⌈.55+(5*55)⌉',\n", - " 277: '⌊5*55.55⌋',\n", - " 278: '⌈5*55.55⌉',\n", - " 279: '⌈.5+⌈.5*555⌉⌉',\n", - " 280: '(5*⌈55.55⌉)',\n", - " 281: '⌈5.5+(5*55)⌉',\n", - " 282: '(5+⌊.5*555⌋)',\n", - " 283: '(5+⌈.5*555⌉)',\n", - " 284: '⌊5*((5**5)/55)⌋',\n", - " 285: '(5+(5+(5*55)))',\n", - " 286: '(555-⌈√5*5!⌉)',\n", - " 287: '(555-⌊√5*5!⌋)',\n", - " 288: '(⌈55*√55⌉-5!)',\n", - " 289: '⌈5*(√5+55.5)⌉',\n", - " 290: '(5*(⌈.5*5⌉+55))',\n", - " 291: '⌊5.5*⌈55-√5⌉⌋',\n", - " 292: '⌈5.5*⌈55-√5⌉⌉',\n", - " 293: '⌊5!*√⌈5.555⌉⌋',\n", - " 294: '⌈5!*√⌈5.555⌉⌉',\n", - " 295: '((5*(5+55))-5)',\n", - " 296: '(5!+⌈5!+55.5⌉)',\n", - " 297: '(⌊5.5*55⌋-5)',\n", - " 298: '(⌈5.5*55⌉-5)',\n", - " 299: '((5!/5)+(5*55))',\n", - " 300: '(5*⌊5+55.5⌋)',\n", - " 301: '⌊(5!+555)/√5⌋',\n", - " 302: '⌊5*(5+55.5)⌋',\n", - " 303: '⌈5*(5+55.5)⌉',\n", - " 304: '⌈.5+⌈5.5*55⌉⌉',\n", - " 305: '⌊.55*555⌋',\n", - " 306: '⌈.55*555⌉',\n", - " 307: '(5+⌊5.5*55⌋)',\n", - " 308: '(5+⌈5.5*55⌉)',\n", - " 309: '(⌈(5+√.5)*55⌉-5)',\n", - " 310: '(5*⌊55+√55⌋)',\n", - " 311: '⌈5*(5*(5+√55))⌉',\n", - " 312: '⌊5*(55+√55)⌋',\n", - " 313: '⌈5*(55+√55)⌉',\n", - " 314: '⌈5.5*⌊√5+55⌋⌉',\n", + " 250: '(⌈55-5.5⌉*5)',\n", + " 251: '⌈(555+5)/√5⌉',\n", + " 252: '⌊(55.5-5)*5⌋',\n", + " 253: '⌈(55.5-5)*5⌉',\n", + " 254: '⌈(555/√5)+5⌉',\n", + " 255: '(⌈55.5-5⌉*5)',\n", + " 256: '⌊((5!/55)*5!)-5⌋',\n", + " 257: '⌈((5!/55)*5!)-5⌉',\n", + " 258: '⌊⌈55.5/5⌉^√5⌋',\n", + " 259: '⌊(5!/55.5)*5!⌋',\n", + " 260: '⌈(5!/55.5)*5!⌉',\n", + " 261: '⌈(.55*5)^5.5⌉',\n", + " 262: '⌊((5.5+5)*5)*5⌋',\n", + " 263: '⌈((5.5+5)*5)*5⌉',\n", + " 264: '((55/(5*5))*5!)',\n", + " 265: '((55*5)-(5+5))',\n", + " 266: '⌊(55.5-√5)*5⌋',\n", + " 267: '⌊(55*5)-√55⌋',\n", + " 268: '⌈(55*5)-√55⌉',\n", + " 269: '⌊(55*5)-5.5⌋',\n", + " 270: '⌈(55*5)-5.5⌉',\n", + " 271: '⌈((55*5)+.5)-5⌉',\n", + " 272: '⌊(555*.5)-5⌋',\n", + " 273: '⌈(555*.5)-5⌉',\n", + " 274: '⌊(55*5)-.55⌋',\n", + " 275: '(⌊55.55⌋*5)',\n", + " 276: '⌈(55*5)+.55⌉',\n", + " 277: '⌊55.55*5⌋',\n", + " 278: '⌈55.55*5⌉',\n", + " 279: '⌈⌈555*.5⌉+.5⌉',\n", + " 280: '(⌈55.55⌉*5)',\n", + " 281: '⌈(55*5)+5.5⌉',\n", + " 282: '⌊(555*.5)+5⌋',\n", + " 283: '⌈(555*.5)+5⌉',\n", + " 284: '⌊((5^5)*5)/55⌋',\n", + " 285: '(((55*5)+5)+5)',\n", + " 286: '⌊555-(5!*√5)⌋',\n", + " 287: '⌊(√55*55)-5!⌋',\n", + " 288: '⌈(√55*55)-5!⌉',\n", + " 289: '⌊55^√⌊5!/55⌋⌋',\n", + " 290: '⌈55^√⌊5!/55⌋⌉',\n", + " 291: '⌊√⌈55*.5⌉*55⌋',\n", + " 292: '⌈√⌈55*.5⌉*55⌉',\n", + " 293: '⌊√⌈5.555⌉*5!⌋',\n", + " 294: '⌈√⌈5.555⌉*5!⌉',\n", + " 295: '(((55+5)*5)-5)',\n", + " 296: '⌈(55.5+5!)+5!⌉',\n", + " 297: '⌊(55*5.5)-5⌋',\n", + " 298: '⌈(55*5.5)-5⌉',\n", + " 299: '⌊(55-.5)*5.5⌋',\n", + " 300: '(⌊55.5+5⌋*5)',\n", + " 301: '⌊⌊55*5.5⌋-.5⌋',\n", + " 302: '⌊(55.5+5)*5⌋',\n", + " 303: '⌈(55.5+5)*5⌉',\n", + " 304: '⌈⌈55*5.5⌉+.5⌉',\n", + " 305: '⌊5.55*55⌋',\n", + " 306: '⌈5.55*55⌉',\n", + " 307: '⌊(55*5.5)+5⌋',\n", + " 308: '⌈(55*5.5)+5⌉',\n", + " 309: '⌊((5!-55)/5)^√5⌋',\n", + " 310: '(⌊√55+55⌋*5)',\n", + " 311: '⌈5.55*(√5^5)⌉',\n", + " 312: '⌊(√55+55)*5⌋',\n", + " 313: '⌈(√55+55)*5⌉',\n", + " 314: '⌊(55+√5)*5.5⌋',\n", " 315: '(555-(5!+5!))',\n", - " 316: '⌊.55*(5*(5!-5))⌋',\n", - " 317: '⌈.55*(5*(5!-5))⌉',\n", - " 318: '⌊(5!+55)/.55⌋',\n", - " 319: '⌈(5!+55)/.55⌉',\n", - " 320: '(5*⌊5!-55.5⌋)',\n", - " 321: '⌊⌈5.555⌉!/√5⌋',\n", - " 322: '⌊5*(5!-55.5)⌋',\n", - " 323: '⌈5*(5!-55.5)⌉',\n", - " 324: '(⌈5.5⌉*⌊55-.5⌋)',\n", - " 325: '(5*(5+(5+55)))',\n", - " 326: '⌈(5!/55)**√55⌉',\n", - " 327: '(⌈5.5⌉*(55-.5))',\n", - " 328: '⌈.5*((5*5!)+55)⌉',\n", - " 329: '⌊(⌈5.5⌉*55)-.5⌋',\n", - " 330: '(55+(5*55))',\n", - " 331: '⌈.5+(⌈5.5⌉*55)⌉',\n", - " 332: '⌊.55*(5+(5*5!))⌋',\n", - " 333: '(⌈5.5⌉*55.5)',\n", - " 334: '⌈5*(5!*.555)⌉',\n", - " 335: '(5*⌈5!*.555⌉)',\n", - " 336: '(5!+⌊5!/.555⌋)',\n", - " 337: '⌊.5*(5!+555)⌋',\n", - " 338: '⌈.5*(5!+555)⌉',\n", - " 339: '⌈5!*(5-(5!/55))⌉',\n", - " 340: '(5*⌊.55*(5+5!)⌋)',\n", - " 341: '⌊55*(√.5+5.5)⌋',\n", - " 342: '(⌈5.5⌉*⌊√5+55⌋)',\n", - " 343: '⌊5*(.55*(5+5!))⌋',\n", - " 344: '⌈5*(.55*(5+5!))⌉',\n", - " 345: '((5!-5)*⌈5!/55⌉)',\n", - " 346: '⌊√5*((5*55)-5!)⌋',\n", - " 347: '⌊(5**5)/⌊5/.55⌋⌋',\n", - " 348: '⌈(5**5)/⌊5/.55⌋⌉',\n", - " 349: '(⌊(5-.55)**5⌋/5)',\n", - " 350: '(5*(5+(5!-55)))',\n", - " 351: '((5!+55.5)/.5)',\n", - " 352: '(⌈5!+55.5⌉/.5)',\n", - " 353: '⌈55*(√55-⌈.5⌉)⌉',\n", - " 354: '⌊(√5+⌈5/55⌉)**5⌋',\n", - " 355: '((5!*⌈5!/55⌉)-5)',\n", - " 356: '(⌈(5!+5!)*√55⌉/5)',\n", - " 357: '⌊5.5*(5!-55)⌋',\n", - " 358: '⌈5.5*(5!-55)⌉',\n", - " 359: '⌊(5!*⌈5!/55⌉)-.5⌋',\n", - " 360: '(5!*⌈5*.555⌉)',\n", - " 361: '⌊(√5+5)*(55-5)⌋',\n", - " 362: '⌈(√5+5)*(55-5)⌉',\n", - " 363: '(5.5*(5!*.55))',\n", - " 364: '⌈5!*(.55*5.5)⌉',\n", - " 365: '(5+(5!*⌈5!/55⌉))',\n", - " 366: '(5!+(5!+⌈5!+5.5⌉))',\n", - " 367: '(5!+⌊(5-.5)*55⌋)',\n", - " 368: '(5!+⌊555/√5⌋)',\n", - " 369: '(5!+⌈555/√5⌉)',\n", - " 370: '⌊√55*(55-5)⌋',\n", - " 371: '⌈√55*(55-5)⌉',\n", - " 372: '(55+⌈√(5+5)**5⌉)',\n", - " 373: '⌈(5-√⌈5!/55⌉)**5⌉',\n", - " 374: '(5+(⌊(5-.5)**5⌋/5))',\n", - " 375: '((5+5!)*⌈5!/55⌉)',\n", - " 376: '(55+⌊⌈5.5⌉!/√5⌋)',\n", - " 377: '(55+⌈⌈5.5⌉!/√5⌉)',\n", - " 378: '(⌊√55⌋*⌊55-.5⌋)',\n", - " 379: '⌊5!*√(55/5.5)⌋',\n", - " 380: '((⌊√55⌋*55)-5)',\n", - " 381: '⌊55**(√55/5)⌋',\n", - " 382: '⌈55**(√55/5)⌉',\n", - " 383: '(5!+⌊5*(55-√5)⌋)',\n", - " 384: '(5!+⌈5*(55-√5)⌉)',\n", - " 385: '(55*⌊√55.5⌋)',\n", - " 386: '(555-⌊5!/√.5⌋)',\n", - " 387: '(⌊√.5*555⌋-5)',\n", - " 388: '⌊55*√(55-5)⌋',\n", - " 389: '⌈55*√(55-5)⌉',\n", - " 390: '(5!+((5*55)-5))',\n", - " 391: '⌊√5*⌊5!+55.5⌋⌋',\n", - " 392: '⌊√.5*555.5⌋',\n", - " 393: '⌈√.5*555.5⌉',\n", - " 394: '(5!+⌊(5*55)-.5⌋)',\n", - " 395: '(5*((5!/5)+55))',\n", - " 396: '⌊.55*⌈5.55⌉!⌋',\n", - " 397: '(5!+⌊.5*555⌋)',\n", - " 398: '(5!+⌈.5*555⌉)',\n", - " 399: '⌊⌈5.5⌉!*.555⌋',\n", - " 400: '(5*((5*5)+55))',\n", - " 401: '⌊(√5+5)*55.5⌋',\n", - " 402: '(⌊55*√55⌋-5)',\n", - " 403: '(⌈55*√55⌉-5)',\n", - " 404: '⌊55*√⌊55-.5⌋⌋',\n", - " 405: '⌈55*√⌊55-.5⌋⌉',\n", - " 406: '⌊⌊55*√55⌋-.5⌋',\n", - " 407: '⌊⌊√55**5⌋/55⌋',\n", - " 408: '⌈⌊√55**5⌋/55⌉',\n", - " 409: '⌊55*√55.5⌋',\n", - " 410: '⌈55*√55.5⌉',\n", - " 411: '⌊√55*55.5⌋',\n", - " 412: '⌈√55*55.5⌉',\n", - " 413: '(5+⌈55*√55⌉)',\n", - " 414: '((5!*(5-.55))-5!)',\n", - " 415: '⌊√55*⌈55.5⌉⌋',\n", - " 416: '⌈√55*⌈55.5⌉⌉',\n", - " 417: '⌊5*(5**(5*.55))⌋',\n", - " 418: '⌈5*(5**(5*.55))⌉',\n", - " 419: '⌊(5**5)/√55.5⌋',\n", - " 420: '(5!+(5*(5+55)))',\n", - " 421: '⌈⌈5!/55⌉**5.5⌉',\n", - " 422: '(5!+⌊5.5*55⌋)',\n", - " 423: '(5!+⌈5.5*55⌉)',\n", - " 424: '⌊√55*(√5+55)⌋',\n", - " 425: '((5*5!)-(5!+55))',\n", - " 426: '⌊55*√(5+55)⌋',\n", - " 427: '⌈55*√(5+55)⌉',\n", - " 428: '⌈55*(5-(√5-5))⌉',\n", - " 429: '(5.5*⌈55/√.5⌉)',\n", - " 430: '(555-(5+5!))',\n", - " 431: '⌈√55*⌈√5+55⌉⌉',\n", - " 432: '(555-⌈√5+5!⌉)',\n", - " 433: '(555-⌊√5+5!⌋)',\n", - " 434: '(555-⌈.5+5!⌉)',\n", + " 316: '⌊√⌊5.55+5⌋^5⌋',\n", + " 317: '⌈√⌊5.55+5⌋^5⌉',\n", + " 318: '⌊(55+5!)/.55⌋',\n", + " 319: '⌈(55+5!)/.55⌉',\n", + " 320: '(⌊5!-55.5⌋*5)',\n", + " 321: '⌈555/√⌈5*.5⌉⌉',\n", + " 322: '⌊(5!-55.5)*5⌋',\n", + " 323: '⌈(5!-55.5)*5⌉',\n", + " 324: '⌈55.5+(5!*√5)⌉',\n", + " 325: '(((55+5)+5)*5)',\n", + " 326: '⌈(5!/55)^√55⌉',\n", + " 327: '⌊(55+(5!*5))*.5⌋',\n", + " 328: '⌈(55+(5!*5))*.5⌉',\n", + " 329: '⌊(55*⌈5.5⌉)-.5⌋',\n", + " 330: '((55*5)+55)',\n", + " 331: '⌈(55+(5*√5))*5⌉',\n", + " 332: '⌊((5!*5)+5)*.55⌋',\n", + " 333: '⌊(.555*5)*5!⌋',\n", + " 334: '⌈(.555*5)*5!⌉',\n", + " 335: '(⌈.555*5!⌉*5)',\n", + " 336: '⌊(5!/.555)+5!⌋',\n", + " 337: '⌊(555+5!)*.5⌋',\n", + " 338: '⌈(555+5!)*.5⌉',\n", + " 339: '⌈(5-(5!/55))*5!⌉',\n", + " 340: '⌈√⌈√55*5⌉*55⌉',\n", + " 341: '⌊(5.5+√.5)*55⌋',\n", + " 342: '⌈(5.5+√.5)*55⌉',\n", + " 343: '⌊((5^5)*.55)/5⌋',\n", + " 344: '⌈((5^5)*.55)/5⌉',\n", + " 345: '(⌈5!/55⌉*(5!-5))',\n", + " 346: '⌊((55*5)-5!)*√5⌋',\n", + " 347: '⌊(5^5)/⌊5/.55⌋⌋',\n", + " 348: '⌈(5^5)/⌊5/.55⌋⌉',\n", + " 349: '⌊((5-.55)^5)/5⌋',\n", + " 350: '(((5-55)+5!)*5)',\n", + " 351: '⌊555/√(5*.5)⌋',\n", + " 352: '⌈555/√(5*.5)⌉',\n", + " 353: '⌈(√55-⌈.5⌉)*55⌉',\n", + " 354: '⌊(⌈5/55⌉+√5)^5⌋',\n", + " 355: '((⌈5!/55⌉*5!)-5)',\n", + " 356: '⌈(55/5)^√⌈5.5⌉⌉',\n", + " 357: '⌊(5!-55)*5.5⌋',\n", + " 358: '⌈(5!-55)*5.5⌉',\n", + " 359: '⌈⌈5!/55⌉*(5!-.5)⌉',\n", + " 360: '(⌈.555*5⌉*5!)',\n", + " 361: '⌊(55-5)*(5+√5)⌋',\n", + " 362: '⌈(55-5)*(5+√5)⌉',\n", + " 363: '⌊(5.5*.55)*5!⌋',\n", + " 364: '⌈(5.5*.55)*5!⌉',\n", + " 365: '((⌈5!/55⌉*5!)+5)',\n", + " 366: '⌈(⌈√5⌉^5.5)-55⌉',\n", + " 367: '⌊(55*(5-.5))+5!⌋',\n", + " 368: '⌊(555/√5)+5!⌋',\n", + " 369: '⌈(555/√5)+5!⌉',\n", + " 370: '⌊(55-5)*√55⌋',\n", + " 371: '⌈(55-5)*√55⌉',\n", + " 372: '⌈(√(5+5)^5)+55⌉',\n", + " 373: '⌈(5-√⌈5!/55⌉)^5⌉',\n", + " 374: '⌈√⌈5.5^√5⌉*55⌉',\n", + " 375: '(⌈5!/55⌉*(5!+5))',\n", + " 376: '⌊(5.55+5!)*⌈√5⌉⌋',\n", + " 377: '⌈(5.55+5!)*⌈√5⌉⌉',\n", + " 378: '(⌊55-.5⌋*⌊√55⌋)',\n", + " 379: '⌊√⌊5.55+5⌋*5!⌋',\n", + " 380: '⌊(√55-.5)*55⌋',\n", + " 381: '⌊55^(√55/5)⌋',\n", + " 382: '⌈55^(√55/5)⌉',\n", + " 383: '⌊((55-√5)*5)+5!⌋',\n", + " 384: '⌈((55-√5)*5)+5!⌉',\n", + " 385: '(⌊√55.5⌋*55)',\n", + " 386: '⌈⌊55-√5⌋*√55⌉',\n", + " 387: '⌊(555*√.5)-5⌋',\n", + " 388: '⌊√(55-5)*55⌋',\n", + " 389: '⌈√(55-5)*55⌉',\n", + " 390: '(((55*5)+5!)-5)',\n", + " 391: '⌊⌊55.5+5!⌋*√5⌋',\n", + " 392: '⌊555.5*√.5⌋',\n", + " 393: '⌈555.5*√.5⌉',\n", + " 394: '⌈⌈555.5⌉*√.5⌉',\n", + " 395: '((55+(5!/5))*5)',\n", + " 396: '⌊⌈5.55⌉!*.55⌋',\n", + " 397: '⌊(555*.5)+5!⌋',\n", + " 398: '⌈(555*.5)+5!⌉',\n", + " 399: '⌊.555*⌈5.5⌉!⌋',\n", + " 400: '((55+(5*5))*5)',\n", + " 401: '⌊55.5*(5+√5)⌋',\n", + " 402: '⌊(√55*55)-5⌋',\n", + " 403: '⌈(√55*55)-5⌉',\n", + " 404: '⌈(√5.5+5)*55⌉',\n", + " 405: '⌈(55-.5)*√55⌉',\n", + " 406: '⌊√(55-.5)*55⌋',\n", + " 407: '⌊(√55^5)/55⌋',\n", + " 408: '⌈(√55^5)/55⌉',\n", + " 409: '⌊√55.5*55⌋',\n", + " 410: '⌈√55.5*55⌉',\n", + " 411: '⌊55.5*√55⌋',\n", + " 412: '⌈55.5*√55⌉',\n", + " 413: '⌈(√55*55)+5⌉',\n", + " 414: '⌊(5!-(√55*5))*5⌋',\n", + " 415: '⌊⌈55.5⌉*√55⌋',\n", + " 416: '⌈⌈55.5⌉*√55⌉',\n", + " 417: '⌊(5^(.55*5))*5⌋',\n", + " 418: '⌈(5^(.55*5))*5⌉',\n", + " 419: '⌊(5^5)/√55.5⌋',\n", + " 420: '⌊⌈5!/55⌉^5.5⌋',\n", + " 421: '⌈⌈5!/55⌉^5.5⌉',\n", + " 422: '⌊(55*5.5)+5!⌋',\n", + " 423: '⌈(55*5.5)+5!⌉',\n", + " 424: '⌊(55+√5)*√55⌋',\n", + " 425: '⌊(5.5+√5)*55⌋',\n", + " 426: '⌊√(55+5)*55⌋',\n", + " 427: '⌈√(55+5)*55⌉',\n", + " 428: '⌈((5-√5)+5)*55⌉',\n", + " 429: '⌈⌈55*5.5⌉/√.5⌉',\n", + " 430: '(555-(5!+5))',\n", + " 431: '⌈⌈55+√5⌉*√55⌉',\n", + " 432: '⌊555-(5!+√5)⌋',\n", + " 433: '⌈555-(5!+√5)⌉',\n", + " 434: '⌊555-(5!+.5)⌋',\n", " 435: '⌊555.5-5!⌋',\n", " 436: '⌈555.5-5!⌉',\n", - " 437: '(⌊√5-5!⌋+555)',\n", - " 438: '(⌈√5-5!⌉+555)',\n", - " 439: '⌊(⌈√55⌉*55)-.5⌋',\n", - " 440: '(5+(555-5!))',\n", - " 441: '(5+⌊(5!+5!)/.55⌋)',\n", - " 442: '(5+⌈(5!+5!)/.55⌉)',\n", - " 443: '⌊55*√(5!-55)⌋',\n", - " 444: '⌊√55*(5+55)⌋',\n", - " 445: '⌈√55*(5+55)⌉',\n", - " 446: '⌊55*√(5!*.55)⌋',\n", - " 447: '⌊⌈√5⌉**5.555⌋',\n", - " 448: '⌈⌈√5⌉**5.555⌉',\n", - " 449: '⌈55*(5+√(5+5))⌉',\n", - " 450: '(5!+(⌈5.5⌉*55))',\n", - " 451: '⌊5!*(⌈5.55⌉-√5)⌋',\n", - " 452: '(⌊5*(5!-5.5)⌋-5!)',\n", - " 453: '(⌈5*(5!-5.5)⌉-5!)',\n", - " 454: '(⌊(5+5!)/.55⌋/.5)',\n", - " 455: '(⌊√55⌋*(5!-55))',\n", - " 456: '(5!/(5/((5!/5)-5)))',\n", - " 457: '⌊5*((5**√5)+55)⌋',\n", - " 458: '⌈5*((5**√5)+55)⌉',\n", - " 459: '⌊555/(.5+√.5)⌋',\n", - " 460: '(5*(5!-⌈.5*55⌉))',\n", - " 461: '(⌈5!*(5-√.5)⌉-55)',\n", - " 462: '⌊5*(5!-(.5*55))⌋',\n", - " 463: '⌈5*(5!-(.5*55))⌉',\n", - " 464: '(⌈√55⌉*⌈√5+55⌉)',\n", - " 465: '(5*(5!-⌊.5*55⌋))',\n", - " 466: '⌊⌊√.5*5!⌋*5.55⌋',\n", - " 467: '⌊55*(.5+⌈√55⌉)⌋',\n", - " 468: '(5!*(5-(5.5/5)))',\n", - " 469: '⌊55*(5+(5*√.5))⌋',\n", - " 470: '(555-⌈√.5*5!⌉)',\n", - " 471: '(555-⌊√.5*5!⌋)',\n", - " 472: '((5*5!)-⌈5!+√55⌉)',\n", - " 473: '((5*5!)-⌊5!+√55⌋)',\n", - " 474: '((5*5!)-⌈5!+5.5⌉)',\n", - " 475: '((5!*⌊5-.55⌋)-5)',\n", - " 476: '⌊⌊5!/(.55**5)⌋/5⌋',\n", - " 477: '⌊√.5*(5!+555)⌋',\n", - " 478: '⌈√.5*(5!+555)⌉',\n", - " 479: '((5*5!)-⌈5!+.55⌉)',\n", - " 480: '(5!*⌊555/5!⌋)',\n", - " 481: '((5*5!)+⌈.55-5!⌉)',\n", - " 482: '⌊√55*(5!-55)⌋',\n", - " 483: '⌈√55*(5!-55)⌉',\n", - " 484: '⌊⌈√5*5!⌉/.555⌋',\n", - " 485: '(5+(5!*⌊5-.55⌋))',\n", - " 486: '⌈√5*⌈5!/.555⌉⌉',\n", - " 487: '((5*5!)-⌈5!-√55⌉)',\n", - " 488: '⌊.55*⌊5!*√55⌋⌋',\n", - " 489: '⌊.55*⌈5!*√55⌉⌋',\n", - " 490: '((5*5!)-(55/.5))',\n", - " 491: '⌈5!*((5/.55)-5)⌉',\n", - " 492: '⌊(⌊5/.55⌋**5)/5!⌋',\n", - " 493: '⌈(⌊5/.55⌋**5)/5!⌉',\n", - " 494: '(⌊(5-.5)*55⌋/.5)',\n", - " 495: '(5*⌊55/.55⌋)',\n", - " 496: '(⌊555/√5⌋/.5)',\n", - " 497: '⌈555/(.5*√5)⌉',\n", + " 437: '⌊(555+√5)-5!⌋',\n", + " 438: '⌈(555+√5)-5!⌉',\n", + " 439: '⌊(55*⌈√55⌉)-.5⌋',\n", + " 440: '((555-5!)+5)',\n", + " 441: '⌊(5^5)/√(55-5)⌋',\n", + " 442: '⌈(5^5)/√(55-5)⌉',\n", + " 443: '⌊√(5!-55)*55⌋',\n", + " 444: '⌊(55+5)*√55⌋',\n", + " 445: '⌈(55+5)*√55⌉',\n", + " 446: '⌊√(.55*5!)*55⌋',\n", + " 447: '⌊⌈√5⌉^5.555⌋',\n", + " 448: '⌈⌈√5⌉^5.555⌉',\n", + " 449: '⌈(√(5+5)+5)*55⌉',\n", + " 450: '((55*⌈5.5⌉)+5!)',\n", + " 451: '⌊(⌈5.55⌉-√5)*5!⌋',\n", + " 452: '⌊(⌈5.5⌉+√5)*55⌋',\n", + " 453: '⌈(⌈5.5⌉+√5)*55⌉',\n", + " 454: '⌊(⌈5!/√55⌉/5)^5⌋',\n", + " 455: '((5!-55)*⌊√55⌋)',\n", + " 456: '⌊⌊√5^5.5⌋*5.5⌋',\n", + " 457: '⌊(55+(5^√5))*5⌋',\n", + " 458: '⌈(55+(5^√5))*5⌉',\n", + " 459: '⌊555/(√.5+.5)⌋',\n", + " 460: '(⌊5!-(55*.5)⌋*5)',\n", + " 461: '⌈√⌊√5.5^5⌋*55⌉',\n", + " 462: '⌊(5!-(55*.5))*5⌋',\n", + " 463: '⌈(5!-(55*.5))*5⌉',\n", + " 464: '(⌈55+√5⌉*⌈√55⌉)',\n", + " 465: '(⌈5!-(55*.5)⌉*5)',\n", + " 466: '⌊5.55*⌊5!*√.5⌋⌋',\n", + " 467: '⌊(⌈√55⌉+.5)*55⌋',\n", + " 468: '((5-(5.5/5))*5!)',\n", + " 469: '⌊((√.5*5)+5)*55⌋',\n", + " 470: '⌊555-(5!*√.5)⌋',\n", + " 471: '⌈555-(5!*√.5)⌉',\n", + " 472: '⌈5.55*⌈5!*√.5⌉⌉',\n", + " 473: '⌈(5!*5)-(√55+5!)⌉',\n", + " 474: '⌊(5!*5)-(5.5+5!)⌋',\n", + " 475: '((⌊5-.55⌋*5!)-5)',\n", + " 476: '⌊5!/((.55^5)*5)⌋',\n", + " 477: '⌊(555+5!)*√.5⌋',\n", + " 478: '⌈(555+5!)*√.5⌉',\n", + " 479: '⌊(5!*5)-(.55+5!)⌋',\n", + " 480: '(⌊555/5!⌋*5!)',\n", + " 481: '⌈(.55-5!)+(5!*5)⌉',\n", + " 482: '⌊(5!-55)*√55⌋',\n", + " 483: '⌈(5!-55)*√55⌉',\n", + " 484: '⌈(5!*√5)/.555⌉',\n", + " 485: '((⌊5-.55⌋*5!)+5)',\n", + " 486: '⌈⌈5!/.555⌉*√5⌉',\n", + " 487: '⌊((5!*5)-5!)+√55⌋',\n", + " 488: '⌊⌊√55*5!⌋*.55⌋',\n", + " 489: '⌊(√55*.55)*5!⌋',\n", + " 490: '⌈(√55*.55)*5!⌉',\n", + " 491: '⌈5!*(5-(5/5.5))⌉',\n", + " 492: '⌊((55/5)+5)^√5⌋',\n", + " 493: '⌈((55/5)+5)^√5⌉',\n", + " 494: '⌊((55*√5)*5)-5!⌋',\n", + " 495: '(⌊55/.55⌋*5)',\n", + " 496: '⌊555/(√5*.5)⌋',\n", + " 497: '⌈555/(√5*.5)⌉',\n", " 498: '(⌈555/√5⌉/.5)',\n", - " 499: '⌊5*(55/.55)⌋',\n", + " 499: '⌊(55/.55)*5⌋',\n", " 500: '(555-55)',\n", - " 501: '(555-⌈5!/√5⌉)',\n", - " 502: '(555-⌊5!/√5⌋)',\n", - " 503: '⌊⌊5.5**5⌋/(5+5)⌋',\n", - " 504: '⌈⌊5.5**5⌋/(5+5)⌉',\n", - " 505: '(5!+(⌊√55⌋*55))',\n", - " 506: '(((5+(5**5))/5)-5!)',\n", - " 507: '(⌊5*(5!+5.5)⌋-5!)',\n", - " 508: '(⌈5*(5!+5.5)⌉-5!)',\n", - " 509: '⌊√.5*⌈5.555⌉!⌋',\n", - " 510: '((5*⌈5!+5.5⌉)-5!)',\n", - " 511: '⌊(5!-5)*(5-.55)⌋',\n", - " 512: '(5!+⌊√.5*555⌋)',\n", - " 513: '(5!+⌈√.5*555⌉)',\n", - " 514: '⌊5!/(⌈.5*55⌉/5!)⌋',\n", - " 515: '(5!+(5!+(5*55)))',\n", - " 516: '(5!+⌊.55*⌈5.5⌉!⌋)',\n", - " 517: '(5!+⌊55*(√5+5)⌋)',\n", - " 518: '(555-⌈5**√5⌉)',\n", - " 519: '(555-⌊5**√5⌋)',\n", - " 520: '((5*(5!-5))-55)',\n", - " 521: '⌈(5**5)/⌈5.55⌉⌉',\n", - " 522: '⌊55*(5+(5-.5))⌋',\n", - " 523: '⌈55*(5+(5-.5))⌉',\n", - " 524: '⌈5!/(55/(5!+5!))⌉',\n", - " 525: '(5*((55/.5)-5))',\n", - " 526: '⌈(.5+⌈5!/55⌉)**5⌉',\n", - " 527: '(5!+⌊55*√55⌋)',\n", - " 528: '(5!+⌈55*√55⌉)',\n", - " 529: '((5!*(5-.55))-5)',\n", + " 501: '⌊555-(5!/√5)⌋',\n", + " 502: '⌈555-(5!/√5)⌉',\n", + " 503: '⌊⌈5.5^5⌉/(5+5)⌋',\n", + " 504: '⌈⌈5.5^5⌉/(5+5)⌉',\n", + " 505: '((55*⌊√55⌋)+5!)',\n", + " 506: '((((5^5)+5)/5)-5!)',\n", + " 507: '⌊((5.5+5!)*5)-5!⌋',\n", + " 508: '⌈((5.5+5!)*5)-5!⌉',\n", + " 509: '⌊(√55^5.5)/5!⌋',\n", + " 510: '⌈(√55^5.5)/5!⌉',\n", + " 511: '⌊(5-.55)*(5!-5)⌋',\n", + " 512: '⌊(555*√.5)+5!⌋',\n", + " 513: '⌈(555*√.5)+5!⌉',\n", + " 514: '⌈(5!/55)^⌈√55⌉⌉',\n", + " 515: '(((55*5)+5!)+5!)',\n", + " 516: '⌈⌊√5⌋^(5/.555)⌉',\n", + " 517: '⌊⌈(5/.55)^5⌉/5!⌋',\n", + " 518: '⌊555-(5^√5)⌋',\n", + " 519: '⌈555-(5^√5)⌉',\n", + " 520: '(((5!-5)*5)-55)',\n", + " 521: '⌈(5^5)/⌈5.55⌉⌉',\n", + " 522: '⌊((5+5)-.5)*55⌋',\n", + " 523: '⌈((5+5)-.5)*55⌉',\n", + " 524: '⌈((5!+5!)/55)*5!⌉',\n", + " 525: '(((55/.5)-5)*5)',\n", + " 526: '⌈(⌈5!/55⌉+.5)^5⌉',\n", + " 527: '⌊(√55*55)+5!⌋',\n", + " 528: '⌈(√55*55)+5!⌉',\n", + " 529: '(((5-.55)*5!)-5)',\n", " 530: '(555-(5*5))',\n", " 531: '(555-(5!/5))',\n", - " 532: '⌊5**(5-(5.5/5))⌋',\n", - " 533: '⌊5!*(5-.555)⌋',\n", - " 534: '⌈5!*(5-.555)⌉',\n", - " 535: '((5*5!)-(5!-55))',\n", - " 536: '⌊55*√(5!-(5*5))⌋',\n", - " 537: '⌊5*(5!-(5+√55))⌋',\n", - " 538: '⌈5*(5!-(5+√55))⌉',\n", - " 539: '(5+(5!*(5-.55)))',\n", - " 540: '((5*5!)-(5+55))',\n", - " 541: '(5!+⌊(5**5)/√55⌋)',\n", - " 542: '(⌊5*(5!-.5)⌋-55)',\n", - " 543: '(555-⌈√5*5⌉)',\n", - " 544: '(555-⌊√5*5⌋)',\n", + " 532: '⌊5^(5-(5.5/5))⌋',\n", + " 533: '⌊(5-.555)*5!⌋',\n", + " 534: '⌈(5-.555)*5!⌉',\n", + " 535: '((55+(5!*5))-5!)',\n", + " 536: '⌊√(5!-(5*5))*55⌋',\n", + " 537: '⌊(5-(√55/5))^5⌋',\n", + " 538: '⌈(5-(√55/5))^5⌉',\n", + " 539: '(((5-.55)*5!)+5)',\n", + " 540: '((5!*5)-(55+5))',\n", + " 541: '⌊((5^5)/√55)+5!⌋',\n", + " 542: '⌊((5!-.5)*5)-55⌋',\n", + " 543: '⌊555-(5*√5)⌋',\n", + " 544: '⌈555-(5*√5)⌉',\n", " 545: '(555-(5+5))',\n", - " 546: '((5!*5.55)-5!)',\n", + " 546: '((5.55*5!)-5!)',\n", " 547: '⌊555-√55⌋',\n", " 548: '⌈555-√55⌉',\n", " 549: '⌊555-5.5⌋',\n", - " 550: '⌈555-5.5⌉',\n", + " 550: '⌊555.5-5⌋',\n", " 551: '⌈555.5-5⌉',\n", - " 552: '(555-⌈.5*5⌉)',\n", - " 553: '(555-⌊.5*5⌋)',\n", + " 552: '⌊555-√5.5⌋',\n", + " 553: '⌈555-√5.5⌉',\n", " 554: '⌊555-.55⌋',\n", " 555: '⌊555.55⌋',\n", " 556: '⌈555.55⌉',\n", - " 557: '(⌊.5*5⌋+555)',\n", - " 558: '(⌈.5*5⌉+555)',\n", - " 559: '(5+⌊555-.5⌋)',\n", - " 560: '⌊5+555.5⌋',\n", - " 561: '⌈5+555.5⌉',\n", - " 562: '⌊√55+555⌋',\n", - " 563: '⌈√55+555⌉',\n", - " 564: '⌈(5**5)/5.55⌉',\n", - " 565: '(5+(5+555))',\n", - " 566: '(⌊√5*5⌋+555)',\n", - " 567: '(⌈√5*5⌉+555)',\n", - " 568: '(⌈5*(5!-5.5)⌉-5)',\n", - " 569: '⌊(5*(5!-5))-5.5⌋',\n", - " 570: '(5*⌊5!-5.55⌋)',\n", - " 571: '((5*5!)-(5+(5!/5)))',\n", - " 572: '⌊5*(5!-5.55)⌋',\n", - " 573: '⌈5*(5!-5.55)⌉',\n", - " 574: '(5+⌈(5**5)/5.5⌉)',\n", - " 575: '(5*⌈5!-5.55⌉)',\n", - " 576: '((5!/5)**⌊5!/55⌋)',\n", - " 577: '⌊55*(5+5.5)⌋',\n", - " 578: '⌈55*(5+5.5)⌉',\n", - " 579: '((5!/5)+555)',\n", - " 580: '((5*5)+555)',\n", - " 581: '⌈5.5+(5*(5!-5))⌉',\n", - " 582: '⌊√55+(5*(5!-5))⌋',\n", - " 583: '(⌊5!/√5⌋*(55/5))',\n", - " 584: '⌈5*(5!-√(55/5))⌉',\n", - " 585: '(5*(5!-⌈5!/55⌉))',\n", - " 586: '⌊5*(5!-(5*.55))⌋',\n", - " 587: '((⌊√5⌋**5)+555)',\n", - " 588: '((5*5!)-⌊5+√55⌋)',\n", - " 589: '((5*5!)-(55/5))',\n", + " 557: '⌊555+√5.5⌋',\n", + " 558: '⌈555+√5.5⌉',\n", + " 559: '⌊(555+5)-.5⌋',\n", + " 560: '⌊555.5+5⌋',\n", + " 561: '⌈555.5+5⌉',\n", + " 562: '⌊555+√55⌋',\n", + " 563: '⌈555+√55⌉',\n", + " 564: '⌈(5^5)/5.55⌉',\n", + " 565: '((555+5)+5)',\n", + " 566: '⌊555+(5*√5)⌋',\n", + " 567: '⌈555+(5*√5)⌉',\n", + " 568: '⌈((5^5)-5)/5.5⌉',\n", + " 569: '⌊((5^5)+5)/5.5⌋',\n", + " 570: '(⌊5!-5.55⌋*5)',\n", + " 571: '⌈(⌊5!-5.5⌋*5)+.5⌉',\n", + " 572: '⌊(5!-5.55)*5⌋',\n", + " 573: '⌈(5!-5.55)*5⌉',\n", + " 574: '⌈((5^5)/5.5)+5⌉',\n", + " 575: '(⌈5!-5.55⌉*5)',\n", + " 576: '((5!/5)^⌊5!/55⌋)',\n", + " 577: '⌊(5.5+5)*55⌋',\n", + " 578: '⌈(5.5+5)*55⌉',\n", + " 579: '(555+(5!/5))',\n", + " 580: '(555+(5*5))',\n", + " 581: '⌈((5!-5)*5)+5.5⌉',\n", + " 582: '⌊((5!-5)*5)+√55⌋',\n", + " 583: '⌈((5!-5)*5)+√55⌉',\n", + " 584: '⌈(5!-√(55/5))*5⌉',\n", + " 585: '(⌊5!-(5!/55)⌋*5)',\n", + " 586: '⌊(5!-(.55*5))*5⌋',\n", + " 587: '(555+(⌊√5⌋^5))',\n", + " 588: '⌈(5!*5)-(√55+5)⌉',\n", + " 589: '⌊5!*(5-(5/55))⌋',\n", " 590: '⌈5!*(5-(5/55))⌉',\n", - " 591: '(⌊5**√5⌋+555)',\n", - " 592: '(⌈5**√5⌉+555)',\n", - " 593: '(⌈5*(5!-.55)⌉-5)',\n", - " 594: '⌊(5*5!)-5.55⌋',\n", - " 595: '(5*⌊5!-.555⌋)',\n", - " 596: '((5*5!)-⌊5-.55⌋)',\n", - " 597: '⌊5*(5!-.555)⌋',\n", - " 598: '⌈5*(5!-.555)⌉',\n", - " 599: '⌊(5*5!)-.555⌋',\n", - " 600: '(5*⌈555/5!⌉!)',\n", - " 601: '⌈(5*5!)+.555⌉',\n", - " 602: '⌊5*(5!+.555)⌋',\n", - " 603: '⌈5*(5!+.555)⌉',\n", - " 604: '(⌊5.5*55⌋/.5)',\n", - " 605: '(55*(55/5))',\n", - " 606: '⌈(5*5!)+5.55⌉',\n", - " 607: '(5+⌊5*(5!+.55)⌋)',\n", - " 608: '(⌊5!/√5⌋+555)',\n", - " 609: '(⌈5!/√5⌉+555)',\n", - " 610: '(55+555)',\n", - " 611: '(⌈√5**5⌉+555)',\n", - " 612: '(5+⌊(5*5!)+√55⌋)',\n", - " 613: '⌊5*(5!+(5*.55))⌋',\n", - " 614: '(((5**5)-55)/5)',\n", - " 615: '((.5*5!)+555)',\n", - " 616: '(5.5*⌊5!-√55⌋)',\n", - " 617: '⌈5*(5!+√(55/5))⌉',\n", - " 618: '⌈(5*(5+5!))-√55⌉',\n", - " 619: '⌊√5*⌊.5*555⌋⌋',\n", - " 620: '(5*⌊√5*55.5⌋)',\n", - " 621: '(.5*⌈√5*555⌉)',\n", - " 622: '⌈√5*⌈.5*555⌉⌉',\n", - " 623: '(⌈5*(5!+5.5)⌉-5)',\n", - " 624: '(⌈(5**5)-5.5⌉/5)',\n", - " 625: '(5**⌊555/5!⌋)',\n", - " 626: '(⌊5.5+(5**5)⌋/5)',\n", - " 627: '⌊5*(5!+5.55)⌋',\n", - " 628: '⌈5*(5!+5.55)⌉',\n", - " 629: '⌊5.5*(5!-5.5)⌋',\n", - " 630: '(5*⌈5!+5.55⌉)',\n", - " 631: '⌈5.5+(5*(5+5!))⌉',\n", - " 632: '⌊5.5*⌈5!-5.5⌉⌋',\n", - " 633: '⌈5.5*⌈5!-5.5⌉⌉',\n", - " 634: '⌊5!*√⌈5*5.55⌉⌋',\n", - " 635: '(5+(5*⌈5!+5.5⌉))',\n", - " 636: '(((5**5)+55)/5)',\n", - " 637: '(5+⌊5.5*(5!-5)⌋)',\n", - " 638: '⌊(5!-5)*5.55⌋',\n", - " 639: '⌈(5!-5)*5.55⌉',\n", - " 640: '(5*⌊√5.5*55⌋)',\n", - " 641: '⌈5*(5!+√(5!-55))⌉',\n", - " 642: '(5+⌊5*(5!+√55)⌋)',\n", - " 643: '(5+⌈5*(5!+√55)⌉)',\n", - " 644: '⌊√5.5*(5*55)⌋',\n", - " 645: '(5*⌈√5.5*55⌉)',\n", - " 646: '⌈5*(5!+(5/.55))⌉',\n", - " 647: '⌈5.5*(5!-(.5*5))⌉',\n", - " 648: '(5!*(⌊.5*55⌋/5))',\n", - " 649: '⌊⌊5!-√5⌋*5.55⌋',\n", - " 650: '((5+5)*(5!-55))',\n", - " 651: '(⌈√5⌉*⌈5!/.555⌉)',\n", - " 652: '(55+⌊5*(5!-.5)⌋)',\n", - " 653: '(55+⌈5*(5!-.5)⌉)',\n", - " 654: '⌊5.5*⌊5!-.55⌋⌋',\n", - " 655: '⌊(5*5!)+55.5⌋',\n", - " 656: '⌈(5*5!)+55.5⌉',\n", - " 657: '⌈5.5*(5!-.55)⌉',\n", - " 658: '(55+⌈5*(.5+5!)⌉)',\n", - " 659: '⌊(5!*5.5)-.55⌋',\n", - " 660: '(55*⌊5+√55⌋)',\n", - " 661: '((5!*5.55)-5)',\n", - " 662: '⌊5*(5+(5!+√55))⌋',\n", - " 663: '⌊(5!-.5)*5.55⌋',\n", + " 591: '⌊555+(5^√5)⌋',\n", + " 592: '⌈555+(5^√5)⌉',\n", + " 593: '⌈(5!*5)-√55.5⌉',\n", + " 594: '⌊(5!*5)-5.55⌋',\n", + " 595: '⌈(5!*5)-5.55⌉',\n", + " 596: '⌈√(5+5)^5.55⌉',\n", + " 597: '⌊(5!-.555)*5⌋',\n", + " 598: '⌈(5!-.555)*5⌉',\n", + " 599: '⌊(5!*5)-.555⌋',\n", + " 600: '(⌊5.555⌋!*5)',\n", + " 601: '⌈.555+(5!*5)⌉',\n", + " 602: '⌊(.555+5!)*5⌋',\n", + " 603: '⌈(.555+5!)*5⌉',\n", + " 604: '(⌊55*5.5⌋/.5)',\n", + " 605: '((55*55)/5)',\n", + " 606: '⌈5.55+(5!*5)⌉',\n", + " 607: '⌊√55.5+(5!*5)⌋',\n", + " 608: '⌊555+(5!/√5)⌋',\n", + " 609: '⌈555+(5!/√5)⌉',\n", + " 610: '(555+55)',\n", + " 611: '⌈555+(√5^5)⌉',\n", + " 612: '⌊(√55+(5!*5))+5⌋',\n", + " 613: '⌊((.55*5)+5!)*5⌋',\n", + " 614: '(((5^5)-55)/5)',\n", + " 615: '(555+(5!*.5))',\n", + " 616: '(⌊5!-√55⌋*5.5)',\n", + " 617: '⌊((5^5)/5)-√55⌋',\n", + " 618: '⌈((5^5)/5)-√55⌉',\n", + " 619: '⌊⌊555*.5⌋*√5⌋',\n", + " 620: '⌊(55.5*√5)*5⌋',\n", + " 621: '⌈(55.5*√5)*5⌉',\n", + " 622: '⌈⌈555*.5⌉*√5⌉',\n", + " 623: '⌊((5^5)-5.5)/5⌋',\n", + " 624: '⌊((5^5)-.55)/5⌋',\n", + " 625: '(5^⌊555/5!⌋)',\n", + " 626: '⌈((5^5)/5)+.55⌉',\n", + " 627: '⌊(5.55+5!)*5⌋',\n", + " 628: '⌈(5.55+5!)*5⌉',\n", + " 629: '⌊(5!-5.5)*5.5⌋',\n", + " 630: '(⌈5.55+5!⌉*5)',\n", + " 631: '⌈((5^5)/5)+5.5⌉',\n", + " 632: '⌊⌈5!-5.5⌉*5.5⌋',\n", + " 633: '⌈⌈5!-5.5⌉*5.5⌉',\n", + " 634: '⌊√⌈5.55*5⌉*5!⌋',\n", + " 635: '⌈√⌈5.55*5⌉*5!⌉',\n", + " 636: '((55+(5^5))/5)',\n", + " 637: '⌊(√55.5+5!)*5⌋',\n", + " 638: '⌊5.55*(5!-5)⌋',\n", + " 639: '⌈5.55*(5!-5)⌉',\n", + " 640: '(⌊55*√5.5⌋*5)',\n", + " 641: '⌈(√(5!-55)+5!)*5⌉',\n", + " 642: '⌊((√55+5!)*5)+5⌋',\n", + " 643: '⌈((√55+5!)*5)+5⌉',\n", + " 644: '⌊(55*√5.5)*5⌋',\n", + " 645: '⌈(55*√5.5)*5⌉',\n", + " 646: '⌈((5/.55)+5!)*5⌉',\n", + " 647: '⌊(5!-√5.5)*5.5⌋',\n", + " 648: '((⌊55*.5⌋/5)*5!)',\n", + " 649: '⌊5.55*⌊5!-√5⌋⌋',\n", + " 650: '((55+(5!*5))-5)',\n", + " 651: '⌊(((5^5)*5)*5)/5!⌋',\n", + " 652: '⌊((5.5+5!)+5)*5⌋',\n", + " 653: '⌈((5.5+5!)+5)*5⌉',\n", + " 654: '⌊⌊5!-.55⌋*5.5⌋',\n", + " 655: '⌊55.5+(5!*5)⌋',\n", + " 656: '⌈55.5+(5!*5)⌉',\n", + " 657: '⌈(5!-.55)*5.5⌉',\n", + " 658: '⌈√⌊55*.55⌋*5!⌉',\n", + " 659: '⌊(5.5*5!)-.55⌋',\n", + " 660: '(⌊√55+5⌋*55)',\n", + " 661: '((5.55*5!)-5)',\n", + " 662: '⌊((√55+5)+5!)*5⌋',\n", + " 663: '⌊(.55+5!)*5.5⌋',\n", " 664: '⌊⌈5.5⌉!-55.5⌋',\n", " 665: '(⌈5.55⌉!-55)',\n", - " 666: '⌊5!*5.555⌋',\n", - " 667: '⌈5!*5.555⌉',\n", - " 668: '⌊(.5+5!)*5.55⌋',\n", - " 669: '⌈(.5+5!)*5.55⌉',\n", - " 670: '(5!+(555-5))',\n", - " 671: '(5+(5!*5.55))',\n", - " 672: '(5!+⌊555-√5⌋)',\n", - " 673: '(5!+⌈555-√5⌉)',\n", - " 674: '(5!+⌊555-.5⌋)',\n", - " 675: '⌊5!+555.5⌋',\n", - " 676: '⌈5!+555.5⌉',\n", - " 677: '(5!+⌊√5+555⌋)',\n", - " 678: '(5!+⌈√5+555⌉)',\n", - " 679: '⌈(5.5**5)/√55⌉',\n", - " 680: '(5+(5!+555))',\n", - " 681: '⌈5!*(5+(5/√55))⌉',\n", - " 682: '⌊55*(5+√55)⌋',\n", - " 683: '⌈55*(5+√55)⌉',\n", - " 684: '((5!/5)+(5!*5.5))',\n", - " 685: '(5*⌊.5*(5*55)⌋)',\n", - " 686: '⌊(√5-⌈.5⌉)*555⌋',\n", - " 687: '⌊.5*(5*(5*55))⌋',\n", - " 688: '⌈.5*(5*(5*55))⌉',\n", - " 689: '(5!+⌈(5**5)/5.5⌉)',\n", - " 690: '(5*⌈.5*(5*55)⌉)',\n", - " 691: '⌈5.5*(5!+5.5)⌉',\n", - " 692: '(5+⌊5.5*(5+5!)⌋)',\n", - " 693: '⌊(5+5!)*5.55⌋',\n", - " 694: '⌈(5+5!)*5.55⌉',\n", + " 666: '⌊5.555*5!⌋',\n", + " 667: '⌈5.555*5!⌉',\n", + " 668: '⌊5.55*(5!+.5)⌋',\n", + " 669: '⌈5.55*(5!+.5)⌉',\n", + " 670: '((555+5!)-5)',\n", + " 671: '((5.55*5!)+5)',\n", + " 672: '⌊(555-√5)+5!⌋',\n", + " 673: '⌈(555-√5)+5!⌉',\n", + " 674: '⌊(555+5!)-.5⌋',\n", + " 675: '⌊555.5+5!⌋',\n", + " 676: '⌈555.5+5!⌉',\n", + " 677: '⌊(555+√5)+5!⌋',\n", + " 678: '⌈(555+√5)+5!⌉',\n", + " 679: '⌈⌊5.5^5⌋/√55⌉',\n", + " 680: '((555+5!)+5)',\n", + " 681: '⌈((5/√55)+5)*5!⌉',\n", + " 682: '⌊(√55+5)*55⌋',\n", + " 683: '⌈(√55+5)*55⌉',\n", + " 684: '(⌊5!-5.5⌋*⌈5.5⌉)',\n", + " 685: '(⌊(55*5)*.5⌋*5)',\n", + " 686: '⌊555*(√5-⌈.5⌉)⌋',\n", + " 687: '⌊((55*5)*5)*.5⌋',\n", + " 688: '⌈((55*5)*5)*.5⌉',\n", + " 689: '⌈((5^5)/5.5)+5!⌉',\n", + " 690: '⌊(5.5+5!)*5.5⌋',\n", + " 691: '⌈(5.5+5!)*5.5⌉',\n", + " 692: '⌊((5!+5)*5.5)+5⌋',\n", + " 693: '⌊5.55*(5!+5)⌋',\n", + " 694: '⌈5.55*(5!+5)⌉',\n", " 695: '(⌈5.55⌉!-(5*5))',\n", " 696: '(⌈5.55⌉!-(5!/5))',\n", - " 697: '(⌈5.5⌉!-((5!-5)/5))',\n", - " 698: '⌊5.5*⌊5!+√55⌋⌋',\n", - " 699: '⌈5.5*⌊5!+√55⌋⌉',\n", - " 700: '(5*(5*⌈.5*55⌉))',\n", - " 701: '⌈5.5*(5!+√55)⌉',\n", - " 702: '⌊(5**5)/(5-.55)⌋',\n", - " 703: '⌈(5**5)/(5-.55)⌉',\n", - " 704: '(5.5*⌈5!+√55⌉)',\n", - " 705: '(5*(5!+⌊5!/5.5⌋))',\n", - " 706: '⌊(5!-√5)*⌈5.55⌉⌋',\n", - " 707: '(⌈5.5⌉!-⌈5+√55⌉)',\n", - " 708: '(⌈5!-√5⌉*⌈5.55⌉)',\n", + " 697: '⌈((√55*.5)^5)-5⌉',\n", + " 698: '⌊⌈5^5.5⌉/(5+5)⌋',\n", + " 699: '⌈⌈5^5.5⌉/(5+5)⌉',\n", + " 700: '((⌈55*.5⌉*5)*5)',\n", + " 701: '⌈(√55+5!)*5.5⌉',\n", + " 702: '⌊(5^5)/(5-.55)⌋',\n", + " 703: '⌈(5^5)/(5-.55)⌉',\n", + " 704: '(⌈√55+5!⌉*5.5)',\n", + " 705: '⌈(5^(5.5/5))*5!⌉',\n", + " 706: '⌊⌈5.55⌉*(5!-√5)⌋',\n", + " 707: '⌈⌈5.55⌉*(5!-√5)⌉',\n", + " 708: '⌊⌈5.55⌉!-(5*√5)⌋',\n", " 709: '(⌈5.5⌉!-(55/5))',\n", " 710: '(⌈5.55⌉!-(5+5))',\n", - " 711: '(⌈5.5⌉!-⌊5/.55⌋)',\n", + " 711: '⌈⌈5.5⌉!-(5/.55)⌉',\n", " 712: '⌊⌈5.55⌉!-√55⌋',\n", " 713: '⌈⌈5.55⌉!-√55⌉',\n", - " 714: '⌊⌈5.55⌉!-5.5⌋',\n", + " 714: '⌊⌈5.5⌉!-5.55⌋',\n", " 715: '(⌈5.555⌉!-5)',\n", - " 716: '(⌈5.5⌉!-⌊5-.55⌋)',\n", + " 716: '⌊(5!-.55)*⌈5.5⌉⌋',\n", " 717: '⌊⌈5.555⌉!-√5⌋',\n", " 718: '⌈⌈5.555⌉!-√5⌉',\n", - " 719: '⌊⌈5.555⌉!-.5⌋',\n", + " 719: '⌊⌈5.5⌉!-.555⌋',\n", " 720: '⌈5.5555⌉!',\n", - " 721: '⌈.5+⌈5.555⌉!⌉',\n", - " 722: '⌊√5+⌈5.555⌉!⌋',\n", - " 723: '⌈√5+⌈5.555⌉!⌉',\n", - " 724: '(⌊5!/√.5⌋+555)',\n", - " 725: '(5+⌈5.555⌉!)',\n", - " 726: '⌈5.5+⌈5.55⌉!⌉',\n", - " 727: '⌊√55+⌈5.55⌉!⌋',\n", - " 728: '⌈√55+⌈5.55⌉!⌉',\n", - " 729: '(⌈5!/55⌉**⌈5.5⌉)',\n", - " 730: '(5+(5+⌈5.55⌉!))',\n", - " 731: '(⌈5.5⌉!+(55/5))',\n", - " 732: '(5!*(5+(5.5/5)))',\n", - " 733: '(5+⌈⌈5.5⌉!+√55⌉)',\n", - " 734: '(5!+⌊5*(√5*55)⌋)',\n", - " 735: '(5*(5!+⌊.5*55⌋))',\n", - " 736: '(⌈5.5⌉!+⌊5!/√55⌋)',\n", - " 737: '⌊5*(5!+(.5*55))⌋',\n", - " 738: '⌈5*(5!+(.5*55))⌉',\n", - " 739: '((5!/5)+(⌈5.5⌉!-5))',\n", - " 740: '(5*(5!+⌈.5*55⌉))',\n", - " 741: '(⌈5.5⌉!+⌊5!/5.5⌋)',\n", - " 742: '(⌈5.5⌉!+⌈5!/5.5⌉)',\n", - " 743: '⌊(5!**√5)/(5+55)⌋',\n", - " 744: '((5!/5)+⌈5.55⌉!)',\n", - " 745: '((5*5)+⌈5.55⌉!)',\n", - " 746: '(5!+((5+(5**5))/5))',\n", - " 747: '(5!+⌊5*(5!+5.5)⌋)',\n", - " 748: '(5!+⌈5*(5!+5.5)⌉)',\n", - " 749: '(5+((5!/5)+⌈5.5⌉!))',\n", - " 750: '((5+5!)*⌈5.55⌉)',\n", - " 751: '⌈5!*(√.5+5.55)⌉',\n", - " 752: '(5!+⌊5.5*(5!-5)⌋)',\n", - " 753: '(5!+⌈5.5*(5!-5)⌉)',\n", - " 754: '(5!+⌊5!*√⌈.5*55⌉⌋)',\n", - " 755: '((5*(5!+55))-5!)',\n", - " 756: '(⌈5.5⌉*⌈5!+5.5⌉)',\n", - " 757: '(5!+⌊5*(5!+√55)⌋)',\n", - " 758: '(5!+⌈5*(5!+√55)⌉)',\n", - " 759: '⌈5!*√(5!/⌈5!/55⌉)⌉',\n", - " 760: '(5*⌊55*(5-√5)⌋)',\n", - " 761: '⌈5*(55*(5-√5))⌉',\n", - " 762: '(⌈5.5⌉*⌊5!+√55⌋)',\n", - " 763: '⌈5*(5!**(.5+.55))⌉',\n", - " 764: '(⌊5!*√55⌋-(5+5!))',\n", - " 765: '(5*⌈55*(5-√5)⌉)',\n", - " 766: '⌊((5*5)-5.5)**√5⌋',\n", - " 767: '⌈((5*5)-5.5)**√5⌉',\n", - " 768: '(⌈5.5⌉*⌈5!+√55⌉)',\n", - " 769: '⌊55**√(5*.55)⌋',\n", - " 770: '(⌈5.5⌉!+(55-5))',\n", - " 771: '⌈(5*5.55)**⌊√5⌋⌉',\n", - " 772: '(⌈5.5⌉!+⌊55-√5⌋)',\n", - " 773: '(⌊5!*√55.5⌋-5!)',\n", - " 774: '(⌈5.5⌉!+⌊55-.5⌋)',\n", - " 775: '(55+⌈5.55⌉!)',\n", - " 776: '⌈⌈5.5⌉!+55.5⌉',\n", + " 721: '⌈⌈5.55⌉!+.55⌉',\n", + " 722: '⌊⌈5.555⌉!+√5⌋',\n", + " 723: '⌈⌈5.555⌉!+√5⌉',\n", + " 724: '⌈5^((5/.55)-5)⌉',\n", + " 725: '(⌈5.555⌉!+5)',\n", + " 726: '⌈5.55+⌈5.5⌉!⌉',\n", + " 727: '⌊⌈5.55⌉!+√55⌋',\n", + " 728: '⌈⌈5.55⌉!+√55⌉',\n", + " 729: '(⌈5!/55⌉^⌈5.5⌉)',\n", + " 730: '((⌈5.55⌉!+5)+5)',\n", + " 731: '((55/5)+⌈5.5⌉!)',\n", + " 732: '(((5.5/5)+5)*5!)',\n", + " 733: '⌈(√55+⌈5.5⌉!)+5⌉',\n", + " 734: '⌊((55*√5)*5)+5!⌋',\n", + " 735: '(⌊(55*.5)+5!⌋*5)',\n", + " 736: '⌊√5.5^√(55+5)⌋',\n", + " 737: '⌊((55*.5)+5!)*5⌋',\n", + " 738: '⌈((55*.5)+5!)*5⌉',\n", + " 739: '⌈⌈(5!*5)*√5⌉*.55⌉',\n", + " 740: '(⌈(55*.5)+5!⌉*5)',\n", + " 741: '⌊(5!/5.5)+⌈5.5⌉!⌋',\n", + " 742: '⌈(5!/5.5)+⌈5.5⌉!⌉',\n", + " 743: '⌊⌈5!^√5⌉/(55+5)⌋',\n", + " 744: '(⌈5.55⌉!+(5!/5))',\n", + " 745: '(⌈5.55⌉!+(5*5))',\n", + " 746: '((((5^5)+5)/5)+5!)',\n", + " 747: '⌊((5.5+5!)*5)+5!⌋',\n", + " 748: '⌈((5.5+5!)*5)+5!⌉',\n", + " 749: '⌈(√55^(5*.5))*5⌉',\n", + " 750: '(⌈5.55⌉*(5!+5))',\n", + " 751: '⌊(5/.55)^⌈5*.5⌉⌋',\n", + " 752: '⌊((5!-5)*5.5)+5!⌋',\n", + " 753: '((5.5+5!)*⌈5.5⌉)',\n", + " 754: '⌊(√⌈55*.5⌉*5!)+5!⌋',\n", + " 755: '(((55+5!)*5)-5!)',\n", + " 756: '⌈(55/5)^(5-√5)⌉',\n", + " 757: '⌈(55*.5)^⌊5*.5⌋⌉',\n", + " 758: '⌈(√55*5)+⌈5.5⌉!⌉',\n", + " 759: '⌈√⌊√55*5.5⌋*5!⌉',\n", + " 760: '⌊((5-√5)*55)*5⌋',\n", + " 761: '⌈((5-√5)*55)*5⌉',\n", + " 762: '(⌊√55+5!⌋*⌈5.5⌉)',\n", + " 763: '⌈(5!^(.55+.5))*5⌉',\n", + " 764: '⌊(√55+5!)*⌈5.5⌉⌋',\n", + " 765: '(⌈(5-√5)*55⌉*5)',\n", + " 766: '⌊((5*5)-5.5)^√5⌋',\n", + " 767: '⌈((5*5)-5.5)^√5⌉',\n", + " 768: '⌊√⌈5.55⌉^√55⌋',\n", + " 769: '⌊55^√(.55*5)⌋',\n", + " 770: '((55+⌈5.5⌉!)-5)',\n", + " 771: '⌈(5.55*5)^⌊√5⌋⌉',\n", + " 772: '⌊((5*.5)^5.5)*5⌋',\n", + " 773: '⌊(√55.5*5!)-5!⌋',\n", + " 774: '⌈(√55.5*5!)-5!⌉',\n", + " 775: '(⌈5.55⌉!+55)',\n", + " 776: '⌈55.5+⌈5.5⌉!⌉',\n", " 777: '⌊(555-5)/√.5⌋',\n", " 778: '⌈(555-5)/√.5⌉',\n", - " 779: '(⌊555/√.5⌋-5)',\n", - " 780: '(5+(⌈5.5⌉!+55))',\n", - " 781: '⌊(5**5)/⌊5-.55⌋⌋',\n", - " 782: '⌈(5**5)/⌊5-.55⌋⌉',\n", - " 783: '⌊⌊555/√.5⌋-.5⌋',\n", - " 784: '⌊√⌊.5*5⌋*555⌋',\n", + " 779: '⌊(555/√.5)-5⌋',\n", + " 780: '((55+⌈5.5⌉!)+5)',\n", + " 781: '⌊(5^5)/⌊5-.55⌋⌋',\n", + " 782: '⌈(5^5)/⌊5-.55⌋⌉',\n", + " 783: '⌊⌊555-.5⌋/√.5⌋',\n", + " 784: '⌊555*√⌊5*.5⌋⌋',\n", " 785: '⌊555.5/√.5⌋',\n", - " 786: '(5!+(5!*5.55))',\n", - " 787: '⌊(5-.5)*(5!+55)⌋',\n", - " 788: '⌈(5-.5)*(5!+55)⌉',\n", - " 789: '(5+⌊555/√.5⌋)',\n", - " 790: '(5+⌈555/√.5⌉)',\n", - " 791: '⌊(5+555)/√.5⌋',\n", - " 792: '⌈(5+555)/√.5⌉',\n", - " 793: '⌈⌈5.5⌉!*(5.5/5)⌉',\n", - " 794: '(⌊55*(√5+5)⌋/.5)',\n", - " 795: '(5!+(5!+555))',\n", - " 796: '⌈55**(5/⌈.5*5⌉)⌉',\n", - " 797: '⌊5.5*(5!+(5*5))⌋',\n", - " 798: '((⌈√5⌉**5)+555)',\n", - " 799: '⌈⌊5!**√⌈5!/55⌉⌋/5⌉',\n", - " 800: '(5*((⌈√5⌉*55)-5))',\n", - " 801: '⌊⌊√55⌋*(5!-5.5)⌋',\n", - " 802: '⌈⌊√55⌋*(5!-5.5)⌉',\n", - " 803: '⌊⌊5!**√5⌋/55.5⌋',\n", - " 804: '⌈⌊5!**√5⌋/55.5⌉',\n", - " 805: '⌈5!*√(55-(5+5))⌉',\n", - " 806: '(⌈⌊5!**√5⌋/55⌉-5)',\n", - " 807: '(5!+⌊5.5*(5+5!)⌋)',\n", - " 808: '(5!+⌈5.5*(5+5!)⌉)',\n", - " 809: '(⌊5!*√(5+55)⌋-5!)',\n", - " 810: '(⌈√5⌉*((5*55)-5))',\n", - " 811: '⌈(⌈5!**√5⌉-5)/55⌉',\n", - " 812: '⌈5!*(⌊5/.55⌋-√5)⌉',\n", - " 813: '(⌊5!*(√5+5)⌋-55)',\n", - " 814: '(⌊55*√55⌋/.5)',\n", - " 815: '⌊55/(.5/√55)⌋',\n", - " 816: '(⌈55*√55⌉/.5)',\n", - " 817: '⌊5**(5*(5/⌈5.5⌉))⌋',\n", - " 818: '((5*5!)+⌊5!/.55⌋)',\n", - " 819: '((5*5!)+⌈5!/.55⌉)',\n", - " 820: '((⌈√5⌉*(5*55))-5)',\n", - " 821: '⌊5!/(√.5**5.55)⌋',\n", - " 822: '⌊5!*√⌊55-√55⌋⌋',\n", - " 823: '(⌊√5*5!⌋+555)',\n", - " 824: '(⌈√5*5!⌉+555)',\n", - " 825: '(55*(5+(5+5)))',\n", - " 826: '⌊(5*5!)**(.5+.55)⌋',\n", - " 827: '⌊(5-.55)**(5-.5)⌋',\n", - " 828: '(⌊((5+5)**5)/5!⌋-5)',\n", - " 829: '(⌈((5+5)**5)/5!⌉-5)',\n", - " 830: '(5*⌊⌈√5⌉*55.5⌋)',\n", - " 831: '(⌈√5⌉*⌊.5*555⌋)',\n", - " 832: '⌊(.5+⌈.5⌉)*555⌋',\n", - " 833: '⌈(.5+⌈.5⌉)*555⌉',\n", - " 834: '(⌊5!*√55⌋-55)',\n", - " 835: '(⌈5!*√55⌉-55)',\n", - " 836: '⌊⌊√55⌋*(5!-.55)⌋',\n", - " 837: '⌈⌊√55⌋*(5!-.55)⌉',\n", - " 838: '⌊√55*⌈5!-√55⌉⌋',\n", - " 839: '⌈√55*⌈5!-√55⌉⌉',\n", - " 840: '(5!+⌈5.555⌉!)',\n", - " 841: '(5!+⌈.5+⌈5.55⌉!⌉)',\n", - " 842: '(⌈5.5⌉!+⌊√5*55⌋)',\n", - " 843: '(⌊5!*√(55-5)⌋-5)',\n", - " 844: '⌊5!*√(55-5.5)⌋',\n", - " 845: '(5+(5!+⌈5.55⌉!))',\n", - " 846: '⌈√55*⌊5!-5.5⌋⌉',\n", - " 847: '(⌊(5!-5)*√55⌋-5)',\n", - " 848: '⌊5!*√⌊55.5-5⌋⌋',\n", - " 849: '⌊√55*(5!-5.5)⌋',\n", - " 850: '(5*(5!+(55-5)))',\n", - " 851: '⌊⌊(5!-5)*√55⌋-.5⌋',\n", - " 852: '⌊5!*√(55.5-5)⌋',\n", - " 853: '⌈5!*√(55.5-5)⌉',\n", - " 854: '(5+⌈5!*√(55-5)⌉)',\n", - " 855: '(5*⌈5.55**⌈√5⌉⌉)',\n", - " 856: '⌊5!*√⌈55.5-5⌉⌋',\n", - " 857: '⌈5!*√⌈55.5-5⌉⌉',\n", - " 858: '(5+⌈(5!-5)*√55⌉)',\n", - " 859: '⌊55**(√5-.55)⌋',\n", - " 860: '⌈55**(√5-.55)⌉',\n", - " 861: '⌊5!*(5+(5!/55))⌋',\n", - " 862: '⌈5!*(5+(5!/55))⌉',\n", - " 863: '⌊5*(5!+(55-√5))⌋',\n", - " 864: '(⌊5!*√55⌋-(5*5))',\n", - " 865: '(5*⌊√(5+5)*55⌋)',\n", - " 866: '(⌈5!*√55⌉-(5!/5))',\n", - " 867: '(⌈5!**√⌊5!/55⌋⌉-5)',\n", - " 868: '⌊5!*(√5+⌊5.55⌋)⌋',\n", - " 869: '⌊5*(√(5+5)*55)⌋',\n", + " 786: '((5.55*5!)+5!)',\n", + " 787: '⌈((.55*5)^5)*5⌉',\n", + " 788: '⌈(55+5!)*(5-.5)⌉',\n", + " 789: '⌊(555/√.5)+5⌋',\n", + " 790: '⌈(555/√.5)+5⌉',\n", + " 791: '⌊(555+5)/√.5⌋',\n", + " 792: '⌈(555+5)/√.5⌉',\n", + " 793: '⌈(5.5/5)*⌈5.5⌉!⌉',\n", + " 794: '(⌊(5+√5)*55⌋/.5)',\n", + " 795: '((555+5!)+5!)',\n", + " 796: '⌈55^(5/⌈5*.5⌉)⌉',\n", + " 797: '⌊((5*5)+5!)*5.5⌋',\n", + " 798: '(555+(⌈√5⌉^5))',\n", + " 799: '⌈⌈5!^√⌈5!/55⌉⌉/5⌉',\n", + " 800: '(((5+5)^5)/(5!+5))',\n", + " 801: '⌊(5!-5.5)*⌊√55⌋⌋',\n", + " 802: '⌈(5!-5.5)*⌊√55⌋⌉',\n", + " 803: '⌊(5!^√5)/55.5⌋',\n", + " 804: '⌈(5!^√5)/55.5⌉',\n", + " 805: '⌈√(55-(5+5))*5!⌉',\n", + " 806: '⌊(5-.5)^(5-.55)⌋',\n", + " 807: '⌊((5!+5)*5.5)+5!⌋',\n", + " 808: '⌈((5!+5)*5.5)+5!⌉',\n", + " 809: '⌊(√(55+5)*5!)-5!⌋',\n", + " 810: '⌊⌊(5!^√5)+5⌋/55⌋',\n", + " 811: '⌈⌊(5!^√5)+5⌋/55⌉',\n", + " 812: '⌈(5^√⌊5.5+5⌋)*5⌉',\n", + " 813: '⌊((5+√5)*5!)-55⌋',\n", + " 814: '(⌊√55*55⌋/.5)',\n", + " 815: '⌊(√55*55)/.5⌋',\n", + " 816: '⌈(√55*55)/.5⌉',\n", + " 817: '⌊5^((5/⌈5.5⌉)*5)⌋',\n", + " 818: '⌊(5!/.55)+(5!*5)⌋',\n", + " 819: '⌈(5!/.55)+(5!*5)⌉',\n", + " 820: '(((55*5)*⌈√5⌉)-5)',\n", + " 821: '⌊5!/(√.5^5.55)⌋',\n", + " 822: '⌊√⌊55-√55⌋*5!⌋',\n", + " 823: '⌊555+(5!*√5)⌋',\n", + " 824: '⌈555+(5!*√5)⌉',\n", + " 825: '(((5+5)+5)*55)',\n", + " 826: '⌊(5!*5)^(.55+.5)⌋',\n", + " 827: '⌊(5-.55)^(5-.5)⌋',\n", + " 828: '⌈(5-.55)^(5-.5)⌉',\n", + " 829: '⌈(((5+5)^5)/5!)-5⌉',\n", + " 830: '(⌊55.5*⌈√5⌉⌋*5)',\n", + " 831: '(⌊555*.5⌋*⌈√5⌉)',\n", + " 832: '⌊555*(⌈.5⌉+.5)⌋',\n", + " 833: '⌈555*(⌈.5⌉+.5)⌉',\n", + " 834: '⌊(√55*5!)-55⌋',\n", + " 835: '⌈(√55*5!)-55⌉',\n", + " 836: '⌊(5!-.55)*⌊√55⌋⌋',\n", + " 837: '⌈(5!-.55)*⌊√55⌋⌉',\n", + " 838: '⌊⌊5.5^5⌋/⌈5.5⌉⌋',\n", + " 839: '⌈⌊5.5^5⌋/⌈5.5⌉⌉',\n", + " 840: '(⌈5.555⌉!+5!)',\n", + " 841: '⌈(⌈5.5⌉!+.55)+5!⌉',\n", + " 842: '⌊(55*√5)+⌈5.5⌉!⌋',\n", + " 843: '⌊(√(55-5)*5!)-5⌋',\n", + " 844: '⌊√(55-5.5)*5!⌋',\n", + " 845: '((⌈5.55⌉!+5!)+5)',\n", + " 846: '⌈⌊5!-5.5⌋*√55⌉',\n", + " 847: '⌊(√55*(5!-5))-5⌋',\n", + " 848: '⌊√⌊55.5-5⌋*5!⌋',\n", + " 849: '⌈√⌊55.5-5⌋*5!⌉',\n", + " 850: '(((55+5!)-5)*5)',\n", + " 851: '⌈5!^((5/5.5)+.5)⌉',\n", + " 852: '⌊⌈5!-5.5⌉*√55⌋',\n", + " 853: '⌈⌈5!-5.5⌉*√55⌉',\n", + " 854: '⌈(√(55-5)*5!)+5⌉',\n", + " 855: '⌈(5.55^⌈√5⌉)*5⌉',\n", + " 856: '⌊√55.5*(5!-5)⌋',\n", + " 857: '⌈√55.5*(5!-5)⌉',\n", + " 858: '⌈(√55*(5!-5))+5⌉',\n", + " 859: '⌊55^(√5-.55)⌋',\n", + " 860: '⌈55^(√5-.55)⌉',\n", + " 861: '⌊((5!/55)+5)*5!⌋',\n", + " 862: '⌈((5!/55)+5)*5!⌉',\n", + " 863: '⌈5^(⌊5!/5.5⌋/5)⌉',\n", + " 864: '⌊(√55*5!)-(5*5)⌋',\n", + " 865: '(⌊55*√(5+5)⌋*5)',\n", + " 866: '⌈(√55*5!)-(5!/5)⌉',\n", + " 867: '⌊((√5-.5)^5)*55⌋',\n", + " 868: '⌊(√⌊5.55⌋+5)*5!⌋',\n", + " 869: '⌊(55*√(5+5))*5⌋',\n", " 870: '((555-5!)/.5)',\n", - " 871: '⌊5!**√⌈5.55/5⌉⌋',\n", - " 872: '⌊5*(5!+(55-.5))⌋',\n", - " 873: '⌈5*(5!+(55-.5))⌉',\n", - " 874: '⌊(5*(5!+55))-.5⌋',\n", - " 875: '(5*⌊5!+55.5⌋)',\n", - " 876: '⌈.5+(5*(5!+55))⌉',\n", - " 877: '⌊5*(5!+55.5)⌋',\n", - " 878: '⌈5*(5!+55.5)⌉',\n", - " 879: '(⌊5!*√55⌋-(5+5))',\n", - " 880: '(5*⌈5!+55.5⌉)',\n", - " 881: '⌊5!*√⌊55-.55⌋⌋',\n", - " 882: '⌈5!*√⌊55-.55⌋⌉',\n", - " 883: '⌊⌊5!*√55⌋-5.5⌋',\n", - " 884: '⌊⌈5!*√55⌉-5.5⌋',\n", - " 885: '⌈⌈5!*√55⌉-5.5⌉',\n", - " 886: '⌈√55*(5!-.55)⌉',\n", - " 887: '(⌈(5.5**5)/5⌉-5!)',\n", - " 888: '(⌊5!*√55.5⌋-5)',\n", - " 889: '⌊5!*(55/√55)⌋',\n", - " 890: '⌈5!*(55/√55)⌉',\n", - " 891: '⌈.55+(5!*√55)⌉',\n", - " 892: '(⌊5!*√⌈55.5⌉⌋-5)',\n", - " 893: '⌊⌊5.5⌋!*√55.5⌋',\n", - " 894: '⌊5.5+⌊5!*√55⌋⌋',\n", - " 895: '(5!+(⌈5.5⌉!+55))',\n", - " 896: '⌈5.5+⌈5!*√55⌉⌉',\n", - " 897: '⌊5!*√⌈55.55⌉⌋',\n", - " 898: '⌈5!*√⌈55.55⌉⌉',\n", - " 899: '(5+⌈5!*√55.5⌉)',\n", - " 900: '(5*(5+(5!+55)))',\n", - " 901: '⌊⌈.5+5!⌉*√55.5⌋',\n", - " 902: '⌊(5-(5.5/5))**5⌋',\n", - " 903: '⌈(5-(5.5/5))**5⌉',\n", - " 904: '(5!+⌊555/√.5⌋)',\n", - " 905: '(5!+⌈555/√.5⌉)',\n", - " 906: '(⌈√5⌉*⌊5.5*55⌋)',\n", - " 907: '⌊⌈√5⌉*(5.5*55)⌋',\n", - " 908: '⌈⌈√5⌉*(5.5*55)⌉',\n", - " 909: '(⌈√5⌉*⌈5.5*55⌉)',\n", - " 910: '⌊√5*⌊55*√55⌋⌋',\n", - " 911: '⌈√5*⌊55*√55⌋⌉',\n", - " 912: '⌊√5*⌈55*√55⌉⌋',\n", - " 913: '⌈√5*⌈55*√55⌉⌉',\n", - " 914: '⌊⌊5.5**5⌋/5.5⌋',\n", - " 915: '⌊5.5**⌊5-.55⌋⌋',\n", - " 916: '⌈5.5**⌊5-.55⌋⌉',\n", - " 917: '⌈⌈√5+5!⌉*√55.5⌉',\n", - " 918: '⌊(5+5!)*√⌊55-.5⌋⌋',\n", - " 919: '⌈(5+5!)*√⌊55-.5⌋⌉',\n", - " 920: '(5+⌊5.5**⌊5-.5⌋⌋)',\n", - " 921: '(5+⌈5.5**⌊5-.5⌋⌉)',\n", - " 922: '(⌊(5+5!)*√55⌋-5)',\n", - " 923: '(55+⌊5!*(√5+5)⌋)',\n", - " 924: '(55+⌈5!*(√5+5)⌉)',\n", - " 925: '(5*(5!+(5!-55)))',\n", - " 926: '⌊⌊(5+5!)*√55⌋-.5⌋',\n", - " 927: '⌊5*(5*(5*√55))⌋',\n", - " 928: '⌈5*(5*(5*√55))⌉',\n", - " 929: '⌊5!*√⌊5+55.5⌋⌋',\n", - " 930: '(5*⌈5*(5*√55)⌉)',\n", - " 931: '⌊(5+5!)*√55.5⌋',\n", - " 932: '⌈(5+5!)*√55.5⌉',\n", - " 933: '⌊5!*√(5+55.5)⌋',\n", - " 934: '⌊5!*(√5+5.55)⌋',\n", - " 935: '(55*⌈5!/√55⌉)',\n", - " 936: '⌈(5+5!)*√⌈55.5⌉⌉',\n", - " 937: '⌊5!*√⌈5+55.5⌉⌋',\n", - " 938: '⌈5!*√⌈5+55.5⌉⌉',\n", - " 939: '(⌈5.5⌉!+⌈5!/.55⌉)',\n", - " 940: '⌈5.5/(.5**√55)⌉',\n", - " 941: '⌊√55*⌊5!+√55⌋⌋',\n", - " 942: '⌊⌊5**5.5⌋/√55⌋',\n", - " 943: '⌈⌊5**5.5⌋/√55⌉',\n", - " 944: '(55+⌊5!*√55⌋)',\n", - " 945: '(55+⌈5!*√55⌉)',\n", - " 946: '(5.5*⌊(5+5)**√5⌋)',\n", - " 947: '(⌈5**(5-√.5)⌉-55)',\n", - " 948: '⌊5.55**⌊5-.5⌋⌋',\n", - " 949: '⌈5.55**⌊5-.5⌋⌉',\n", - " 950: '(5*(5*⌈5*√55⌉))',\n", - " 951: '⌊5.5*⌈(5+5)**√5⌉⌋',\n", - " 952: '⌊5!*√⌈55+√55⌉⌋',\n", - " 953: '⌈5!*√⌈55+√55⌉⌉',\n", - " 954: '⌊(5!+555)/√.5⌋',\n", - " 955: '⌊5!*(.55+√55)⌋',\n", - " 956: '⌈5!*(.55+√55)⌉',\n", - " 957: '⌊(5**5)/(5.5-√5)⌋',\n", - " 958: '⌈(5**5)/(5.5-√5)⌉',\n", - " 959: '⌊(5!*⌈√55⌉)-.55⌋',\n", - " 960: '(5!*⌈55/√55⌉)',\n", - " 961: '⌊√⌈.5*5⌉*555⌋',\n", - " 962: '⌊5.5*(5!+55)⌋',\n", - " 963: '⌈5.5*(5!+55)⌉',\n", - " 964: '⌈(√5-.5)*555⌉',\n", - " 965: '(5*⌊5!**(5.5/5)⌋)',\n", - " 966: '⌈(5!/5.55)**√5⌉',\n", - " 967: '⌊5!*√(5+(5+55))⌋',\n", - " 968: '⌊(5+5!)*√(5+55)⌋',\n", - " 969: '((⌊5-.5⌋**5)-55)',\n", - " 970: '(5*⌈5!**(5.5/5)⌉)',\n", - " 971: '(⌈5*(5!/.55)⌉-5!)',\n", - " 972: '⌊√5*(555-5!)⌋',\n", - " 973: '⌈√5*(555-5!)⌉',\n", - " 974: '⌊5!*√⌊5!*.555⌋⌋',\n", - " 975: '((5*⌈5!/.55⌉)-5!)',\n", - " 976: '(⌈√55⌉*⌊√5*55⌋)',\n", - " 977: '⌈(5+5)*((.5*5)**5)⌉',\n", - " 978: '⌈√5*⌈(5!+5!)/.55⌉⌉',\n", - " 979: '⌊5!*(5+√⌊5+5.5⌋)⌋',\n", - " 980: '((5+5)*⌈(.5*5)**5⌉)',\n", - " 981: '((5-.5)*⌊5!/.55⌋)',\n", - " 982: '⌊5!*√⌈5!*.555⌉⌋',\n", - " 983: '⌈5!*√⌈5!*.555⌉⌉',\n", - " 984: '(⌈√55⌉*⌈√5*55⌉)',\n", - " 985: '⌊(5-.5)*⌈5!/.55⌉⌋',\n", - " 986: '⌈(5-.5)*⌈5!/.55⌉⌉',\n", - " 987: '(⌈(5**5)/⌈√5⌉⌉-55)',\n", - " 988: '⌊5!*(√5+⌈5.55⌉)⌋',\n", - " 989: '⌊5**(5!/⌈.5*55⌉)⌋',\n", + " 871: '⌊5!^√⌊.555*5⌋⌋',\n", + " 872: '⌊((55+5!)-.5)*5⌋',\n", + " 873: '⌈((55+5!)-.5)*5⌉',\n", + " 874: '⌊((55+5!)*5)-.5⌋',\n", + " 875: '(⌊55.5+5!⌋*5)',\n", + " 876: '⌈((55+5!)*5)+.5⌉',\n", + " 877: '⌊(55.5+5!)*5⌋',\n", + " 878: '⌈(55.5+5!)*5⌉',\n", + " 879: '⌊(√55*5!)-(5+5)⌋',\n", + " 880: '(⌈55.5+5!⌉*5)',\n", + " 881: '⌊√⌊55-.55⌋*5!⌋',\n", + " 882: '⌊⌊5!-.55⌋*√55⌋',\n", + " 883: '⌈⌊5!-.55⌋*√55⌉',\n", + " 884: '⌊(√55*5!)-5.5⌋',\n", + " 885: '⌊(5!-.55)*√55⌋',\n", + " 886: '⌈(5!-.55)*√55⌉',\n", + " 887: '⌈(⌈5.5^5⌉/5)-5!⌉',\n", + " 888: '⌊⌊√55*5!⌋-.55⌋',\n", + " 889: '⌊(55/√55)*5!⌋',\n", + " 890: '⌈(55/√55)*5!⌉',\n", + " 891: '⌈⌈√55*5!⌉+.55⌉',\n", + " 892: '⌈(5!^√5)/(55-5)⌉',\n", + " 893: '⌊√55.5*⌊5.5⌋!⌋',\n", + " 894: '⌊(.55+5!)*√55⌋',\n", + " 895: '⌊(√55*5!)+5.5⌋',\n", + " 896: '⌈(√55*5!)+5.5⌉',\n", + " 897: '⌊√⌈55.55⌉*5!⌋',\n", + " 898: '⌈√⌈55.55⌉*5!⌉',\n", + " 899: '⌈(√55.5*5!)+5⌉',\n", + " 900: '(((55+5)+5!)*5)',\n", + " 901: '⌊√55.5*⌈5!+.5⌉⌋',\n", + " 902: '⌊(5-(5.5/5))^5⌋',\n", + " 903: '⌈(5-(5.5/5))^5⌉',\n", + " 904: '⌊⌊55*√5⌋*√55⌋',\n", + " 905: '⌈⌊55*√5⌋*√55⌉',\n", + " 906: '(⌊55*5.5⌋*⌈√5⌉)',\n", + " 907: '⌊(55*5.5)*⌈√5⌉⌋',\n", + " 908: '⌈(55*5.5)*⌈√5⌉⌉',\n", + " 909: '(⌈55*5.5⌉*⌈√5⌉)',\n", + " 910: '⌊⌊√55*55⌋*√5⌋',\n", + " 911: '⌈⌊√55*55⌋*√5⌉',\n", + " 912: '⌊⌈55*√5⌉*√55⌋',\n", + " 913: '⌈⌈55*√5⌉*√55⌉',\n", + " 914: '⌊⌊5.5^5⌋/5.5⌋',\n", + " 915: '⌊5.5^⌊5-.55⌋⌋',\n", + " 916: '⌈5.5^⌊5-.55⌋⌉',\n", + " 917: '⌈√55.5*⌈5!+√5⌉⌉',\n", + " 918: '⌊(√5.5+5)*(5!+5)⌋',\n", + " 919: '⌊(55+5)^(5/⌈√5⌉)⌋',\n", + " 920: '⌊(5.5^⌊5-.5⌋)+5⌋',\n", + " 921: '⌊(5*.5)^√55.5⌋',\n", + " 922: '⌊(√55*(5!+5))-5⌋',\n", + " 923: '⌊((5+√5)*5!)+55⌋',\n", + " 924: '⌈((5+√5)*5!)+55⌉',\n", + " 925: '(((5!-55)+5!)*5)',\n", + " 926: '⌈⌊5^√(55*.5)⌋/5⌉',\n", + " 927: '⌊((√55*5)*5)*5⌋',\n", + " 928: '⌈((√55*5)*5)*5⌉',\n", + " 929: '⌊√⌊55.5+5⌋*5!⌋',\n", + " 930: '⌊(5.5+5!)*√55⌋',\n", + " 931: '⌈(5.5+5!)*√55⌉',\n", + " 932: '⌈√55.5*(5!+5)⌉',\n", + " 933: '⌊√(55.5+5)*5!⌋',\n", + " 934: '⌈√(55.5+5)*5!⌉',\n", + " 935: '(⌈5!/√55⌉*55)',\n", + " 936: '⌈√⌈55.5⌉*(5!+5)⌉',\n", + " 937: '⌊√⌈55.5+5⌉*5!⌋',\n", + " 938: '⌈√⌈55.5+5⌉*5!⌉',\n", + " 939: '⌊5.5/(.5^√55)⌋',\n", + " 940: '⌈5.5/(.5^√55)⌉',\n", + " 941: '⌊⌊√55+5!⌋*√55⌋',\n", + " 942: '⌊⌈5^5.5⌉/√55⌋',\n", + " 943: '⌈⌈5^5.5⌉/√55⌉',\n", + " 944: '⌊(√55*5!)+55⌋',\n", + " 945: '⌈(√55*5!)+55⌉',\n", + " 946: '⌈√((5.5+5)+5)^5⌉',\n", + " 947: '⌊((5+5)^√5)*5.5⌋',\n", + " 948: '⌊5.55^⌊5-.5⌋⌋',\n", + " 949: '⌈5.55^⌊5-.5⌋⌉',\n", + " 950: '((⌈√55*5⌉*5)*5)',\n", + " 951: '⌊⌈(5+5)^√5⌉*5.5⌋',\n", + " 952: '⌊√⌈√55+55⌉*5!⌋',\n", + " 953: '⌈√⌈√55+55⌉*5!⌉',\n", + " 954: '⌊(555+5!)/√.5⌋',\n", + " 955: '⌊(√55+.55)*5!⌋',\n", + " 956: '⌈(√55+.55)*5!⌉',\n", + " 957: '⌊(5^5)/(5.5-√5)⌋',\n", + " 958: '⌈(5^5)/(5.5-√5)⌉',\n", + " 959: '⌊(⌈√55⌉*5!)-.55⌋',\n", + " 960: '(⌈55/√55⌉*5!)',\n", + " 961: '⌊555*√⌈5*.5⌉⌋',\n", + " 962: '⌊(55+5!)*5.5⌋',\n", + " 963: '⌈(55+5!)*5.5⌉',\n", + " 964: '⌈555*(√5-.5)⌉',\n", + " 965: '⌊(5!/5.55)^√5⌋',\n", + " 966: '⌈(5!/5.55)^√5⌉',\n", + " 967: '⌊√((55+5)+5)*5!⌋',\n", + " 968: '⌊(5!^(5.5/5))*5⌋',\n", + " 969: '((⌊5-.5⌋^5)-55)',\n", + " 970: '(⌈5!^(5.5/5)⌉*5)',\n", + " 971: '⌈((5/.55)*5!)-5!⌉',\n", + " 972: '⌊(555-5!)*√5⌋',\n", + " 973: '⌈(555-5!)*√5⌉',\n", + " 974: '⌊√⌊.555*5!⌋*5!⌋',\n", + " 975: '⌈√⌊.555*5!⌋*5!⌉',\n", + " 976: '(⌊55*√5⌋*⌈√55⌉)',\n", + " 977: '⌈((5*.5)^5)*(5+5)⌉',\n", + " 978: '⌊⌈(5*√5)+5!⌉*√55⌋',\n", + " 979: '⌊(√⌊5.5+5⌋+5)*5!⌋',\n", + " 980: '(⌈(5*.5)^5⌉*(5+5))',\n", + " 981: '⌊((5-.5)/.55)*5!⌋',\n", + " 982: '⌊((5.5^5)-5!)/5⌋',\n", + " 983: '⌈((5.5^5)-5!)/5⌉',\n", + " 984: '⌈(55*⌈√55⌉)*√5⌉',\n", + " 985: '⌊⌈5!/.55⌉*(5-.5)⌋',\n", + " 986: '⌈⌈5!/.55⌉*(5-.5)⌉',\n", + " 987: '⌊√⌈5*√5⌉^5.55⌋',\n", + " 988: '⌊(⌈5.55⌉+√5)*5!⌋',\n", + " 989: '⌊5^(5!/⌈55*.5⌉)⌋',\n", " 990: '((555/.5)-5!)',\n", - " 991: '⌊5!*(5-(√5-5.5))⌋',\n", - " 992: '⌈5!*(5-(√5-5.5))⌉',\n", - " 993: '(5+⌊(5**5)/√(5+5)⌋)',\n", - " 994: '⌊5!*(5*√(5*.55))⌋',\n", - " 995: '(5!+(5*(5!+55)))',\n", - " 996: '⌊5!*√⌈.55*(5+5!)⌉⌋',\n", - " 997: '⌊5!*(5+√(55/5))⌋',\n", - " 998: '⌈5!*(5+√(55/5))⌉',\n", - " 999: '⌈⌊5**5.5⌋/⌊√55⌋⌉',\n", + " 991: '⌊((5.5-√5)+5)*5!⌋',\n", + " 992: '⌈((5.5-√5)+5)*5!⌉',\n", + " 993: '⌊((5^5)/√(5+5))+5⌋',\n", + " 994: '⌊(√(.55*5)*5!)*5⌋',\n", + " 995: '(((55+5!)*5)+5!)',\n", + " 996: '⌊√⌈(5!+5)*.55⌉*5!⌋',\n", + " 997: '⌊(√(55/5)+5)*5!⌋',\n", + " 998: '⌈(√(55/5)+5)*5!⌉',\n", + " 999: '⌈⌈5^5.5⌉/⌊√55⌋⌉',\n", " ...}" ] }, - "execution_count": 71, + "execution_count": 73, "metadata": {}, "output_type": "execute_result" } @@ -2810,7 +2828,7 @@ "source": [ "clear()\n", "\n", - "%time makeable(ff)" + "%time makeable(five5s)" ] }, { @@ -2828,7 +2846,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 74, "metadata": { "button": false, "new_sheet": false, @@ -2843,13 +2861,13 @@ "23308" ] }, - "execution_count": 72, + "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "unmakeable(ff)" + "unmakeable(five5s)" ] }, { @@ -2876,16 +2894,16 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "'2.0+(1*8), 2.0-(1-8), (2.0-1)*8, (2*0)-(1-8), √(2.0*18), -2.0-(1-8), √(-2.0+18), 2.0+(1^8), 20-18, 2.0-(1^8), 2*(0/18)'" + "'(20*.1)+8, (2.0-1)+8, (2.0-1)*8, (-2.0+1)+8, √(20*1.8), (-2.0-1)+8, √(-2.0+18), 2.0+(1^8), 20-18, (2.0-1)^8, (2*0)*18'" ] }, - "execution_count": 80, + "execution_count": 75, "metadata": {}, "output_type": "execute_result" } @@ -2901,7 +2919,7 @@ "def littman(year, i):\n", " \"Return a string that makes i with the digits of year.\"\n", " digits = tuple(map(int, str(year)))\n", - " return unbracket(expressions(digits).get(i, '???').replace('**', '^'))\n", + " return unbracket(expressions(digits).get(i, '???'))\n", "\n", "littman_countdown(2018)" ] @@ -2917,37 +2935,28 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 76, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "2011:\n", - "20/(1+1), 20-11, -2.0+(1/.1), (2.0+1)!+1, √(20-11)!, (2.0+1)!-1, 2.0*(1+1), √(20-11), 2+(0/11), 2.0/(1+1), 2*(0/11)\n", - "2012:\n", - "20/(1*2), (2.0+1)^2, 20-12, 2.0+(1/.2), 2.0*(1+2), 2.0+(1+2), 2.0*(1*2), 2.0-(1-2), 2+(0/12), -.20+1.2, 2*(0/12)\n", - "2013:\n", - "20/(-1+3), (2.0+1)*3, 2.0*(1+3), 20-13, 2.0+(1+3), 20/(1+3), 2.0-(1-3), (2.0-1)*3, 2+(0/13), (2.0+1)/3, 2*(0/13)\n", - "2014:\n", - "2.0*(1+4), (2.0+1)^√4, 2.0/(1/4), 2.0+(1+4), 20-14, 20*(1/4), 20/(1+4), -20-(1-4!), 2+(0/14), .20*(1+4), 2*(0/14)\n", - "2015:\n", - "2.0*(1*5), √(201-5!), 2.0+(1+5), 2.0+(1*5), (.20*15)!, 20-15, 20/(1*5), .20*15, 2+(0/15), 2*(0.1*5), 2*(0/15)\n", - "2016:\n", - "2*(0-(1-6)), 2.0+(1+6), 2.0*√16, 2.0-(1-6), √(20+16), 20/√16, 20-16, 2.0+(1^6), 2+(0/16), .20*(-1+6), 2*(0/16)\n", - "2017:\n", - "2.0+(1+7), 2.0+(1*7), 2.0-(1-7), (2.0-1)*7, (20-17)!, -2.0+(1*7), -2.0-(1-7), 20-17, 2+(0/17), 2.0-(1^7), 2*(0/17)\n", - "2018:\n", - "2.0+(1*8), 2.0-(1-8), (2.0-1)*8, (2*0)-(1-8), √(2.0*18), -2.0-(1-8), √(-2.0+18), 2.0+(1^8), 20-18, 2.0-(1^8), 2*(0/18)\n", - "2019:\n", - "20-(1+9), (2.0-1)*9, (2*0)-(1-9), -2.0+(1*9), -2.0-(1-9), 20/(1+√9), 2.0-(1-√9), 2.0+(1^9), 2+(0/19), 20-19, 2*(0/19)\n" + "20/(1+1), 20-11, (-.20+1)/.1, (2.0+1)!+1, √(20-11)!, (2.0+1)!-1, (2.0+1)+1, √(20-11), 2+(0*11), (2.0-1)*1, (2*0)*11 ... Happy New Year 2011!\n", + "-2.0+12, (2.0+1)^2, 20-12, 2.0+(1/.2), (2.0+1)*2, (2.0+1)+2, (20*1)*.2, (2.0-1)+2, 2+(0*12), (2.0+1)-2, (2*0)*12 ... Happy New Year 2012!\n", + "20/(-1+3), (2.0+1)*3, 2.0*(1+3), 20-13, (20*1)*.3, 20/(1+3), (2.0-1)+3, (2.0-1)*3, 2+(0*13), (2.0+1)/3, (2*0)*13 ... Happy New Year 2013!\n", + "2.0*(1+4), √((2.0+1)^4), (20*1)*.4, (2.0+1)+4, 20-14, (20*1)/4, 20/(1+4), (-20-1)+4!, 2+(0*14), .20*(1+4), (2*0)*14 ... Happy New Year 2014!\n", + "(20*1)*.5, √(201-5!), (2.0+1)+5, (20*.1)+5, (20*.15)!, 20-15, (20*1)/5, 20*.15, 2+(0*15), (.20*1)*5, (2*0)*15 ... Happy New Year 2015!\n", + "2.0*(-1+6), (2.0+1)+6, (20*.1)+6, (2.0-1)+6, √(20+16), 20/√16, 20-16, 2.0+(1^6), 2+(0*16), (2.0-1)^6, (2*0)*16 ... Happy New Year 2016!\n", + "(2.0+1)+7, (20*.1)+7, (2.0-1)+7, (2.0-1)*7, (20-17)!, (-2.0*1)+7, (-2.0-1)+7, 20-17, 2+(0*17), (2.0-1)^7, (2*0)*17 ... Happy New Year 2017!\n", + "(20*.1)+8, (2.0-1)+8, (2.0-1)*8, (-2.0+1)+8, √(20*1.8), (-2.0-1)+8, √(-2.0+18), 2.0+(1^8), 20-18, (2.0-1)^8, (2*0)*18 ... Happy New Year 2018!\n", + "20-(1+9), (2.0-1)*9, (-2.0+1)+9, (-2.0*1)+9, (-2.0-1)+9, 20/(1+√9), (2.0-1)+√9, 2.0+(1^9), 2+(0*19), 20-19, (2*0)*19 ... Happy New Year 2019!\n" ] } ], "source": [ "for y in range(2011, 2020):\n", - " print('{}:\\n{}'.format(y, littman_countdown(y)))" + " print('{} ... Happy New Year {}!'.format(littman_countdown(y), y))" ] } ],