ipynb/Countdown.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "<div style=\"text-align:right\"><i>Peter Norvig<br>Jan 2016<br>revised 2018, 2020</i></div>\n",
    "\n",
    "# Making Numbers: Countdowns, Four 4s, Five 5s, ...\n",
    "\n",
    "In this notebook we solve a range of related puzzles that all involve making mathematical expressions by combining numbers and operators in various ways to make target numeric values.  First some imports, and then we can look at the first problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter, defaultdict, namedtuple\n",
    "from fractions   import Fraction\n",
    "from functools   import lru_cache\n",
    "from itertools   import product, permutations\n",
    "from math        import sqrt, factorial, floor, ceil\n",
    "from operator    import add, sub, mul, neg, truediv as div\n",
    "from typing      import List, Tuple, Dict, Union, Sequence, Set, Optional\n",
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Countdown to 2016\n",
    "\n",
    "On January 1, 2016 Alex Bellos [posed](http://www.theguardian.com/science/2016/jan/04/can-you-solve-it-complete-the-equation-10-9-8-7-6-5-4-3-2-1-2016) (and subsequently [answered](http://www.theguardian.com/science/2016/jan/04/did-you-solve-it-complete-the-equation-10-9-8-7-6-5-4-3-2-1-2016)) this New Year's puzzle:\n",
    "\n",
    "\n",
    "> Fill in the blanks so that this equation makes arithmetical sense:\n",
    ">\n",
    "> `10 ␣ 9 ␣ 8 ␣ 7 ␣ 6 ␣ 5 ␣ 4 ␣ 3 ␣ 2 ␣ 1 = 2016`\n",
    ">\n",
    "> You are allowed to use *only* the four basic arithmetical operations: +, -, &times;, ÷. But brackets (parentheses) can be used wherever needed. So, for example, the solution could begin\n",
    ">\n",
    "> `(10 + 9) * (8` ...  or  `10 + (9 * 8)` ...\n",
    "# Countdown to 2016: Four Operators, No Brackets\n",
    "\n",
    "We'll start with a  simpler version of the puzzle: a countdown with no brackets.   \n",
    "\n",
    "There are nine blanks,  each of which can be filled by one of four operators, so there are 9<sup>4</sup> = 262,144 possibilities, few enough that we can enumerate them all, using `itertools.product` to get tuples of operators, and then `str.format` to plug them into blanks, and then `eval` to evaluate the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "countdown = '10{}9{}8{}7{}6{}5{}4{}3{}2{}1'\n",
    "\n",
    "allops = list(product('+-*/', repeat=9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('+', '+', '+', '+', '+', '+', '+', '+', '+')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allops[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('-', '*', '+', '-', '*', '*', '*', '+', '/')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "allops[100003]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10-9*8+7-6*5*4*3+2/1'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "countdown.format(*allops[100003])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-413.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(*Warning*: don't use eval on strings that you aren't sure are safe.)\n",
    "\n",
    "We need to catch errors such as dividing by zero, so I'll define a wrapper function, `evaluate`, to do that: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "Exp = str # The type of expressions, such as \"(10+9)\"\n",
    "\n",
    "def evaluate(exp: Exp) -> object:\n",
    "    \"\"\"eval(exp), or None if there is an arithmetic error.\"\"\"\n",
    "    try:\n",
    "        return eval(exp)\n",
    "    except ArithmeticError:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can try to find an expression that evaluates to 2016:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "for ops in allops:\n",
    "    exp = countdown.format(*ops)\n",
    "    if evaluate(exp) == 2016:\n",
    "        print(exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Too bad; we did all that work and no solution was printed. What years *can* we find solutions for? I'll define the function `simple_countdowns` to take a collection of target years and return a dict of the form `{year: 'expression'}` for each expression that evaluates to one of the target years. I'll generalize the function to allow any format string, and any collection of Python operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1979: '10*9*8+7*6*5*4*3/2-1',\n",
       " 1980: '10*9*8+7*6*5*4*3/2/1',\n",
       " 1981: '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",
       " 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'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def simple_countdowns(targets, operators='+-*/', fmt=countdown) -> Dict[int, Exp]:\n",
    "    \"\"\"All solutions to the countdown puzzle (with no brackets) for target years.\"\"\"\n",
    "    exps = (fmt.format(*ops)\n",
    "            for ops in product(operators, repeat=fmt.count('{}')))\n",
    "    table = {evaluate(exp): exp for exp in exps}\n",
    "    return {t: table[t] for t in targets if t in table}\n",
    "\n",
    "simple_countdowns(range(1900, 2100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Interesting: in the 20th and 21st centuries, there are only two \"golden eras\" where the bracketless countdown equation works: the three year period centered on 1980, and the seven year period that is centered on 2016, but omits 2016. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Countdown to 2016: Four  Operators, With Brackets\n",
    "\n",
    "Now we return to the original problem. Can I make use of what I have so far? Well,  `simple_countdowns` accepts a `fmt` string as input, so I could give it all possible bracketed format strings and let it fill in all possible operator combinations. How long would that take? I happen to remember that the number of bracketings of *n* operands is the nth [Catalan number](https://oeis.org/A000108), so for *n* = 9 there are 4,862 bracketings. A single call to `simple_countdown` took about 2 seconds, so we could do 4,862 calls in about 160 minutes. That's not terrible, but (a) it would still take work to generate all the bracketings, and (b) I think I can find another way that is much faster.\n",
    "\n",
    "I'll restate the problem as: given the ordered sequence of numbers (10, 9, ... 1), find an expression whose value is 2016. But to get there I'll solve a more general problem: given any sequence of numbers, like `(10, 9, 8)`, what `{value: expression}` pairs can I make with them? I'll define  `expressions(numbers)` to return an **expression table**: a dict of `{value: expression}` for all expressions (strings) whose numeric value is `value` that can be made from `numbers`, for example:\n",
    "\n",
    "    expressions((10,)) ⇒ {10: '10'}\n",
    "    expressions((9, 8)) ⇒ {1: '(9-8)', 1.125: '(9/8)', 17: '(9+8)', 72: '(9*8)'}\n",
    "\n",
    "I'll use the idea of [**dynamic programming**](https://en.wikipedia.org/wiki/Dynamic_programming): break the problem down into simpler subparts, compute an answer for each subpart, and remember intermediate results so we don't need to re-compute them later. How do we break the problem into parts? `expressions((10, 9, 8))` should consist of all the ways of splitting `(10, 9, 8)` into two parts, finding all the expressions that can be made with each part, and combining pairs of expressions with any of the four operators:\n",
    "\n",
    "    expressions((10, 9, 8)) ⇒ {11: '(10+(9-8))', 27: '(10+(9+8))', 720: '(10*(9*8))', ...}\n",
    "\n",
    "First the function `splits`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def splits(sequence) -> List[Tuple[Sequence, Sequence]]:\n",
    "    \"Split sequence into two non-empty parts, in all ways.\"\n",
    "    return [(sequence[:i], sequence[i:]) \n",
    "            for i in range(1, len(sequence))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((10,), (9, 8, 7, 6, 5, 4, 3, 2, 1)),\n",
       " ((10, 9), (8, 7, 6, 5, 4, 3, 2, 1)),\n",
       " ((10, 9, 8), (7, 6, 5, 4, 3, 2, 1)),\n",
       " ((10, 9, 8, 7), (6, 5, 4, 3, 2, 1)),\n",
       " ((10, 9, 8, 7, 6), (5, 4, 3, 2, 1)),\n",
       " ((10, 9, 8, 7, 6, 5), (4, 3, 2, 1)),\n",
       " ((10, 9, 8, 7, 6, 5, 4), (3, 2, 1)),\n",
       " ((10, 9, 8, 7, 6, 5, 4, 3), (2, 1)),\n",
       " ((10, 9, 8, 7, 6, 5, 4, 3, 2), (1,))]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c10 = (10, 9, 8, 7, 6, 5, 4, 3, 2, 1) # A countdown from 10 to 1\n",
    "\n",
    "splits(c10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Now the function `expressions`. Note that we place the dummy `@` operator in the `exp` string, and then replace it with real operators in four ways. Note also that `for (L, R) in product(..., ...)` is equivalent to the two lines\n",
    "     \n",
    "       for L in ...\n",
    "           for R in ...\n",
    "           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "ExpTable = Dict[float, Exp] # A table of {1.125: '(9/8)', ...}\n",
    "    \n",
    "@lru_cache(None)\n",
    "def expressions(numbers: tuple) -> ExpTable:\n",
    "    \"\"\"Return a {value: exp} table for all expressions that can be made from `numbers`.\"\"\"\n",
    "    if len(numbers) == 1: \n",
    "        return {numbers[0]: str(numbers[0])}\n",
    "    else: \n",
    "        table = {}\n",
    "        for (Lnums, Rnums) in splits(numbers):\n",
    "            for (L, R) in product(expressions(Lnums), expressions(Rnums)):\n",
    "                exp = '(' + expressions(Lnums)[L] + '@' + expressions(Rnums)[R] + ')'\n",
    "                if R != 0: \n",
    "                    table[L / R] = exp.replace('@', '/')\n",
    "                table[L * R] = exp.replace('@', '*')\n",
    "                table[L - R] = exp.replace('@', '-')\n",
    "                table[L + R] = exp.replace('@', '+')\n",
    "        return table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "For example, at one point in a call to `expressions((10, 9, 8))` we would have:\n",
    "\n",
    "     Lnums, Rnums          = (10,),  (9, 8)\n",
    "     L,     R              = 10,     1\n",
    "     expressions(Lnums)[L] = '10'\n",
    "     expressions(Rnums)[R] = '(9-8)'\n",
    "     exp                   = '(10@(9-8))'\n",
    "\n",
    "This would lead to us adding the following four entries to `table`:\n",
    "\n",
    "     table[10] = '(10/(9-8))'\n",
    "     table[10] = '(10*(9-8))'\n",
    "     table[9]  = '(10-(9-8))'\n",
    "     table[11] = '(10+(9-8))'\n",
    "     \n",
    "The decorator `@lru_cache` takes care of storing the intermediate results so we don't have to recompute them. Rather than catching errors, we just avoid division by 0.\n",
    "\n",
    "Let's give it a try:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{10: '10'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expressions((10,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1.125: '(9/8)', 72: '(9*8)', 1: '(9-8)', 17: '(9+8)'}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expressions((9, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{8.88888888888889: '((10/9)*8)',\n",
       " 11.25: '((10*9)/8)',\n",
       " 8.875: '(10-(9/8))',\n",
       " 11.125: '(10+(9/8))',\n",
       " 0.1388888888888889: '((10/9)/8)',\n",
       " 720: '((10*9)*8)',\n",
       " -62: '(10-(9*8))',\n",
       " 82: '((10*9)-8)',\n",
       " 10.0: '(10*(9-8))',\n",
       " 9: '((10-9)+8)',\n",
       " 11: '((10+9)-8)',\n",
       " 0.5882352941176471: '(10/(9+8))',\n",
       " 170: '(10*(9+8))',\n",
       " -7: '((10-9)-8)',\n",
       " 27: '((10+9)+8)',\n",
       " -6.888888888888889: '((10/9)-8)',\n",
       " 9.11111111111111: '((10/9)+8)',\n",
       " 98: '((10*9)+8)',\n",
       " 0.125: '((10-9)/8)',\n",
       " 8: '((10-9)*8)',\n",
       " 2.375: '((10+9)/8)',\n",
       " 152: '((10+9)*8)'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expressions((10, 9, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "That looks reasonable. Let's solve the whole puzzle.\n",
    "\n",
    "# Countdown to 2016: A Solution\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 27.3 s, sys: 714 ms, total: 28 s\n",
      "Wall time: 28.6 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'(((((((((10*9)+8)*7)-6)-5)-4)*3)+2)+1)'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%time expressions(c10)[2016]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "We have an answer! And in seconds, not hours, thanks to dynamic programming! Here are solutions for nearby years:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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)',\n",
       " 2025: '(((((10*(((9*8)*(7-6))-5))+4)*3)+2)+1)'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{y: expressions(c10)[y] for y in range(2010, 2026)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "# Counting Solutions\n",
    "\n",
    "Alex Bellos had another challenge:  \n",
    "\n",
    "> I was half hoping a computer scientist would let me know exactly how many solutions [to the Countdown problem] there are with only the four basic operations. Maybe someone will. \n",
    "\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. 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 &times; 4<sup>9</sup> = 1.2 bilion of them) and checking which ones equal 2016. That would take about 40 hours with my Python program. A better approach is to mimic `expressions`, but to make a table of counts, rather than expression strings. I want:\n",
    "\n",
    "    expression_counts((10, 9, 8))[27] == 2\n",
    "    \n",
    "because there are 2 ways to make 27 with the numbers `(10, 9, 8)`, namely, `((10+9)+8)` and `(10+(9+8))`. And in general, if there are `Lcount` ways to make `L` using `Lnums` and `Rcount` ways to make `R` using `Rnums` then there are `Lcount * Rcount` ways of making `L + R` using `Lnums` followed by `Rnums`. So we have:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "@lru_cache(None)\n",
    "def expression_counts(numbers: tuple) -> Counter:\n",
    "    \"Return a Counter of {value: count} for every value that can be made from numbers.\"\n",
    "    if len(numbers) == 1: # Only one way to make an expression out of a single number\n",
    "        return Counter(numbers)\n",
    "    else: \n",
    "        table = Counter()\n",
    "        for (Lnums, Rnums) in splits(numbers):\n",
    "            for L, R in product(expression_counts(Lnums), expression_counts(Rnums)):\n",
    "                count = expression_counts(Lnums)[L] * expression_counts(Rnums)[R]\n",
    "                if R != 0:\n",
    "                    table[L / R] += count\n",
    "                table[L + R] += count\n",
    "                table[L - R] += count\n",
    "                table[L * R] += count\n",
    "        return table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1.0: 1, 4: 2, 0: 1})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expression_counts((2, 2)) # corresponds to {0: '2-2', 1.0: '2/2', 4: '2+2' or '2*2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expression_counts((10, 9, 8))[27] # (10+9)+8 or 10+(9+8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Looks good to me. Now let's see if we can answer Alex's question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30066"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expression_counts(c10)[2016]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "This says there are 30,066 distinct expressions for 2016. Is that the answer Alex wanted?\n",
    "\n",
    "# The Trouble with Round-off Error\n",
    "\n",
    "I don't think it is the right answer. The trouble is: round-off error.\n",
    "\n",
    "Let's find all the values in `expressions(c10)` that are very near to `2016`, within ±0.0000000001:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2016.0000000000002: '((((10*((9*(8+7))-(6/(5+4))))*3)/2)+1)',\n",
       " 2016.0: '(((((((((10*9)+8)*7)-6)-5)-4)*3)+2)+1)',\n",
       " 2015.9999999999995: '((((((10*9)*8)*7)*((6/5)-(4-3)))*2)*1)',\n",
       " 2015.999999999997: '(((10*9)*8)/(7-(6-(((5/(4+3))/2)-1))))',\n",
       " 2016.0000000000005: '(((((10*9)*8)*((((7*6)/5)-4)-3))*2)*1)',\n",
       " 2016.0000000000018: '((((((10*9)*8)*7)*(((6/5)-4)+3))*2)*1)',\n",
       " 2016.0000000000023: '(10*((9*8)/((7-(6-((5/(4+3))/2)))-1)))',\n",
       " 2015.9999999999998: '((10*((9*(((8-(7/6))*5)-(4*3)))+2))+1)',\n",
       " 2015.9999999999993: '(10*(((((9*8)*7)*6)/5)*(((4/3)-2)+1)))',\n",
       " 2016.000000000002: '(((10*9)*8)/((7-(6-((5/(4+3))/2)))-1))',\n",
       " 2015.999999999999: '((((10*9)*(8+7))-6)/(((5-(4/3))-2)-1))'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{y: expressions(c10)[y]\n",
    " for y in expressions(c10)\n",
    " if abs(y - 2016) < 1e-10}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "I suspect that all of these actually should be *exactly* equal to 2016. To determine if they are, I could re-do *all* the calculations using exact rational arithmetic, as provided by the `fractions.Fraction` class. From experience I know that would be at least an order of magnitude slower, so instead I'll just verify the small set of expressions in the output above. I'll define `exact(exp)` to return a string that, when passed to `eval`, will exactly calculate `exp` using rational arithmetic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fraction(1)/(Fraction(5)-Fraction(2))'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def exact(exp) -> Exp: return re.sub(r\"([0-9]+)\", r\"Fraction(\\1)\", exp)\n",
    "\n",
    "exact('1/(5-2)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert eval(exact('1/(5-2)')) == Fraction(1, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I can count up all the expressions in the `expression_counts(c10)` table that are near 2016, but with `exact` computation to check that the expressions evaluate to exactly 2016:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "44499"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(expression_counts(c10)[y] \n",
    "    for y, exp in expressions(c10).items()\n",
    "    if abs(y - 2016) < 1e-10 and eval(exact(exp)) == 2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "I can claim that the answer is  **44,499**, but I would feel more confident if I did *all* the computations with exact arithmetic, and if the result was independently verified by someone else, and passed an extensive test suite. And of course, if you have a different definition of \"distinct solution,\" you will get a different answer; there are multiple possible definitions that are all very reasonable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Four 4s\n",
    "\n",
    "Alex Bellos continued his original puzzle column with a related puzzle:\n",
    "    \n",
    "> The most famous “fill in the gaps in the equation” puzzle is known as  [**four fours**](https://en.wikipedia.org/wiki/Four_fours), because every equation is of the form\n",
    ">\n",
    "> `4 ␣ 4 ␣ 4 ␣ 4 = x.`\n",
    ">\n",
    ">In the classic form of the puzzle you must find a solution for x = 0 to 9 using just addition, subtraction, multiplication and division (and brackets).\n",
    "\n",
    "This puzzle goes back to a [1914 publication](https://archive.org/details/mathematicalrecr00ball) by the mathematician/magician [W. W. Rouse Ball](https://en.wikipedia.org/wiki/W._W._Rouse_Ball). The solution is easy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: '(((4-4)-4)+4)',\n",
       " 1: '(((4/4)-4)+4)',\n",
       " 2: '((4/(4+4))*4)',\n",
       " 3: '(((4+4)+4)/4)',\n",
       " 4: '(((4-4)*4)+4)',\n",
       " 5: '(((4*4)+4)/4)',\n",
       " 6: '(((4+4)/4)+4)',\n",
       " 7: '((4-(4/4))+4)',\n",
       " 8: '(((4+4)/4)*4)',\n",
       " 9: '(((4/4)+4)+4)'}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i: expressions((4, 4, 4, 4))[i] for i in range(10)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that I didn't do anything special to take advantage of the fact that in `(4, 4, 4, 4)` the digits are all the same. Happily, `lru_cache` does that for me automatically! If I split that into `(4, 4)` and `(4, 4)`, when it comes time to do the second half of the split, the result will already be in the cache, and so won't be recomputed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# New Mathematical Operations\n",
    "\n",
    "Bellos then writes:\n",
    "    \n",
    "> If you want to show off, you can introduce **new mathematical operations** such as powers, square roots, concatenation and decimals, ... or use the factorial symbol, `!`.\n",
    "\n",
    "It seems there are a lot of puzzles that are similar to four 4s, and they all have different rules for which numbers are required and which operators are allowed. To facilitate solving a range of puzzles with different operators, I will redefine `expressions` to take a second argument, `ops`, listing the allowable operations.\n",
    "\n",
    "The operations will be specified as a string of one-character codes. The table below gives the allowable codes, binary operators on the left and unary operators on the right, except that the last row gives two pseudo-operations  on digits, decimal points and concatenation:\n",
    "\n",
    "|Code|Operator|Code|Operator|\n",
    "|------|--------|------|--------|\n",
    "|`'+'`|addition: 1 + 2 = 3      |`'_'`|unary minus: -2 = -2|\n",
    "|`'-'`|subtraction: 3 - 2 = 1   |`'√'`|square root: √9 = 3|\n",
    "|`'*'`|multiplication: 2 * 3 = 6|`'!'`|factorial: 4! = 24 |\n",
    "|`'/'`|division: 6 / 3 = 2      |`'⌊'`|floor:⌊4.4⌋ = 4|\n",
    "|`'^'`|exponentiation: 2 ^ 3 = 8|`'⌈'`|ceiling: ⌈4.4⌉ = 5|\n",
    "|`'.'`|decimal point: 1.23 = 1.23|`'$'`|concatenation of digits: 123 = 123|\n",
    "\n",
    "I will define the data type `Operator` to define an operator, giving its code symbol, its arity (binary or unary), the Python function to call to do the calculation, the format string for unary operations, and for some operations, a `guard` that says when it is applicable (for example, division is applicable when the second argument is not zero, and for square root, factorial, and exponentiation I impose some limits that are not mathematically necessary, but keep the table from being overpopulated with numbers that are unlikely to help lead to solutions). For binary operations, the code symbol is used to construct the expression string, but for uunary ops the `fmt` field gives a format string; this allows us to have prefix and postfix operators. The function `operators` picks out the operators you want from the `OPERATORS` global variable. You can augment this with new operators as you wish."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def true(*args): return True\n",
    "\n",
    "Operator = namedtuple('Operator', 'symbol, func, fmt, guard', defaults=[None, true])\n",
    "\n",
    "OPERATORS = {\n",
    "    2: {Operator('+', add),\n",
    "        Operator('-', sub),\n",
    "        Operator('*', mul),\n",
    "        Operator('/', div,       None,  lambda L, R: R != 0),\n",
    "        Operator('^', pow,       None,  lambda L, R: -10 <= R <= 10 and (L > 0 or R == int(R)) \n",
    "                                                     and not (L == 0 == R))},\n",
    "    1: {Operator('√', sqrt,      '√{}', lambda v: 0 < v <= 100 and (120. * v).is_integer()),\n",
    "        Operator('!', factorial, '{}!', lambda v: v in range(7)),\n",
    "        Operator('_', neg,       '-{}'),\n",
    "        Operator('⌊', floor,     '⌊{}⌋'),\n",
    "        Operator('⌈', ceil,      '⌈{}⌉')}}\n",
    "\n",
    "OPS = '+-*/^_√!.$' # Default set of operators; omits floor and ceiling.\n",
    "\n",
    "def operators(arity: int, ops: str) -> List[Operator]:\n",
    "    \"\"\"All the operators in OPERATORS with given arity whose code symbol is one of `ops`.\"\"\"\n",
    "    return [op for op in OPERATORS[arity] if op.symbol in ops]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are some complications; here's how I'll handle them:\n",
    "\n",
    "- **Irrationals**: `√2` is an irrational number (I'll use floating point approximations for everything).\n",
    "- **Imaginaries**: `√-1` is an imaginary number (I won't allow imaginary numbers).\n",
    "- **Overflow**: `(10. ^ (9. ^ 8.))`, as a `float`, gives an `OverflowError` (I'll drop overflow results).\n",
    "- **Memory**: `(10 ^ (9 ^ (8 ^ 7)))`, as an `int`, gives an `OutOfMemoryError` (I'll limit exponents).\n",
    "- **Infinite unary operators**: `√√√√√√...(4!!!!!!!!...)` (I'll only allow two unary operators per expression).\n",
    "- **Round-off error**:`(49*(1/49)) == 0.9999999999999999`, not `1` (I'll try to round off)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'll define the function `do` to do an arithmetic computation, catch any errors, and try to correct round-off errors. The idea is that since my expressions start with integers, results that are close to an integer probably are that integer. So I'll correct `(49*(1/49))` to be `1.0`. Of course, an expression like `(1+(10^-99))` is also very close to `1.0`, but it should not be rounded off. Instead, I'll try to avoid such expressions by silently dropping any value whose magnitude is outside the range of 10<sup>-10</sup> to 10<sup>10</sup> (except of course I will accept an exact 0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def do(operator, *args) -> Optional[float]: \n",
    "    \"Return op(*args), trying to correct for roundoff error, or `None` if too big/small/erroneous.\"\n",
    "    if operator.guard(*args):\n",
    "        try:\n",
    "            val = operator.func(*args)\n",
    "            return (val        if val == 0 else\n",
    "                    None       if isinstance(val, complex) else\n",
    "                    None       if not (1e-10 < abs(val) < 1e10) else\n",
    "                    round(val) if abs(val - round(val)) < 1e-12 else \n",
    "                    val)\n",
    "        except (ArithmeticError, ValueError):\n",
    "            pass\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Refactoring `expressions`\n",
    "\n",
    "I'll take this opportunity to refactor `expressions` to use the new `OPERATORS`. I introduce  these subfunctions:\n",
    "- `digit_expressions(digits, ops)`: returns a table of expressions with just digits (and maybe a decimal place). If `'$'` is in `ops` allow concatenation of digits (e.g. `{44: '44'}`) and if `'.'` is in ops allow decimals (e.g. `{4.4: '4.4'}`. \n",
    "- `add_unary_expressions(table, ops)`: add expressions like `√4` and `4!` to `table` and return `table`. \n",
    "- `add_binary_expressions(table, numbers, ops)`: add expressions like `4+√4` and `4^4` to `table` and return `table`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "@lru_cache(None)\n",
    "def expressions(numbers: Tuple[int], ops=OPS) -> ExpTable:\n",
    "    \"Return {value: expr} for all expressions that can be made from numbers using ops.\"\n",
    "    table = digit_expressions(numbers, ops)\n",
    "    table = add_binary_expressions(table, numbers, ops)\n",
    "    return  add_unary_expressions(table, ops)\n",
    "\n",
    "def digit_expressions(digits: Tuple[int], ops: str) -> ExpTable:\n",
    "    \"All ways of making numbers from these digits (in order), and a decimal point.\"\n",
    "    D = ''.join(map(str, digits))\n",
    "    table = {}\n",
    "    if '.' in ops: table.update({float(d): d for d in decimals(D)})\n",
    "    if '$' in ops or len(digits) == 1: table[int(D)] = D\n",
    "    return table\n",
    "\n",
    "def decimals(digits: str)-> List[str]:\n",
    "    \"\"\"All ways to insert a decimal point into digits.\"\"\"\n",
    "    return [digits[:i] + '.' + digits[i:]\n",
    "            for i in range(len(digits))\n",
    "            if i <= 1 or not digits.startswith('0')]\n",
    "      \n",
    "def add_binary_expressions(table: ExpTable, numbers: tuple, ops: str) -> ExpTable:\n",
    "    \"Add binary expressions by splitting numbers and combining with an op.\"\n",
    "    binary_ops = operators(2, ops)\n",
    "    for (Lnums, Rnums) in splits(numbers):\n",
    "        for (L, R) in product(expressions(Lnums, ops), expressions(Rnums, ops)):\n",
    "            exp = '(' + expressions(Lnums, ops)[L] + '@' + expressions(Rnums, ops)[R] + ')'\n",
    "            for op in binary_ops:\n",
    "                assign(table, do(op, L, R), exp.replace('@', op.symbol))\n",
    "    return table\n",
    "                \n",
    "def add_unary_expressions(table: ExpTable, ops: str, nesting_level=2) -> ExpTable:\n",
    "    \"Add unary expressions (possibly -v, √v and v!) to table\"\n",
    "    unary_ops = operators(1, ops)\n",
    "    for _ in range(nesting_level):\n",
    "        for v in tuple(table):\n",
    "            for op in unary_ops:\n",
    "                assign(table, do(op, v), op.fmt.format(table[v]))\n",
    "    return table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `assign` adds a `{val: exp}` entry to `table`, but if there is already an entry for `val`, it prefers the entry with the lowest total *weight*: the number of characters plus extra points for particularly complex characters. The idea is to prefer simpler expressions, but the weights are completely arbitrary. If you prefer complex expressions, you can change the weights to be negative. The weights don't change how many different values can be made, they just change which of two or more expressions are chosen to represent a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def assign(table: dict, val: float, exp: str): \n",
    "    \"Assign table[val] = exp, unless we already have a lighter exp or val is None.\"\n",
    "    if val is not None and (val not in table or weight(exp) < weight(table[val])): \n",
    "        table[val] = exp\n",
    "        \n",
    "WEIGHTS = Counter({'√':2, '!':2, '.':1, '^':1, '/':0.2, '-':0.1, '⌊': 2, '⌈':2})\n",
    "        \n",
    "def weight(exp: str) -> int: return len(exp) + sum(WEIGHTS[c] for c in exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's a lot of new code; let's have some tests:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert digit_expressions((1, 2), OPS) == {12: '12', 0.12: '.12', 1.2: '1.2'}\n",
    "assert digit_expressions((1, 2), '$') == {12: '12'}\n",
    "assert digit_expressions((1, 2), '') == {} \n",
    "assert digit_expressions((1,), '$') == {1: '1'}\n",
    "\n",
    "assert decimals('123') == ['.123', '1.23', '12.3']\n",
    "assert decimals('007') == ['.007', '0.07']\n",
    "\n",
    "assert add_unary_expressions({16: '16'}, '_') == {16: '16', -16: '-16'}\n",
    "assert add_unary_expressions({16: '16'}, OPS) == {16: '16', -16: '-16', 4: '√16', -4: '-√16', \n",
    "                                                  2: '√√16', 24: '√16!'}\n",
    "\n",
    "assert expressions((3, 2), '+-*$') == {32.0: '32', 5: '(3+2)', 1: '(3-2)', 6: '(3*2)'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "I'll define a function to print a table of consecutive integers (starting at 0) that can be made by a sequence of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "def show(numbers: tuple, limit=None, ops=OPS, clear=True):\n",
    "    \"\"\"Print expressions for integers from 0 up to limit or the first unmakeable integer.\"\"\"\n",
    "    if clear: expressions.cache_clear() # To free up memory\n",
    "    table = expressions(numbers, ops)\n",
    "    print(f'Can make 0 to {unmakeable(table)-1} with expressions({numbers}, \"{ops}\").'\n",
    "          f' ({len(table):,} table entries)\\n')\n",
    "    for i in range(limit or unmakeable(table)): \n",
    "        print('{:4} = {}'.format(i, unbracket(table[i])))\n",
    "        \n",
    "def unmakeable(table) -> int:\n",
    "    \"\"\"The integer i such that table makes every integer from 0 to i - 1, but not i.\"\"\"\n",
    "    for i in range(len(table) + 1):\n",
    "        if i not in table:\n",
    "            return i\n",
    "              \n",
    "def unbracket(exp: str) -> str:\n",
    "    \"Strip outer parens from exp, if they are there\"\n",
    "    return (exp[1:-1] if exp.startswith('(') and exp.endswith(')') else exp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Four 4s with New Mathematical Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 72 with expressions((4, 4, 4, 4), \"+-*/^_√!.$\"). (705,959 table entries)\n",
      "\n",
      "   0 = 44-44\n",
      "   1 = 44/44\n",
      "   2 = 4*(4/(4+4))\n",
      "   3 = (4+(4+4))/4\n",
      "   4 = 4+(4*(4-4))\n",
      "   5 = (4+(4*4))/4\n",
      "   6 = √(44-(4+4))\n",
      "   7 = (44/4)-4\n",
      "   8 = 4+(4+(4-4))\n",
      "   9 = 4+(4+(4/4))\n",
      "  10 = 44/4.4\n",
      "  11 = 44/√(4*4)\n",
      "  12 = (4+44)/4\n",
      "  13 = √4+(44/4)\n",
      "  14 = 4+(4+(4+√4))\n",
      "  15 = 4+(44/4)\n",
      "  16 = .4*(44-4)\n",
      "  17 = (4/4)+(4*4)\n",
      "  18 = (44/√4)-4\n",
      "  19 = 4!-(4+(4/4))\n",
      "  20 = 4*(4+(4/4))\n",
      "  21 = (4+4.4)/.4\n",
      "  22 = √4*(44/4)\n",
      "  23 = (√4+44)/√4\n",
      "  24 = 4+(4+(4*4))\n",
      "  25 = (4+(4*4!))/4\n",
      "  26 = 4+(44/√4)\n",
      "  27 = 4+(4!-(4/4))\n",
      "  28 = 44-(4*4)\n",
      "  29 = 4+(4!+(4/4))\n",
      "  30 = (4+(4+4))/.4\n",
      "  31 = 4!+((4+4!)/4)\n",
      "  32 = (4*4)+(4*4)\n",
      "  33 = 4!+((4-.4)/.4)\n",
      "  34 = 44-(4/.4)\n",
      "  35 = 4!+(44/4)\n",
      "  36 = 44-(4+4)\n",
      "  37 = ((.4+4!)/.4)-4!\n",
      "  38 = 44-(4+√4)\n",
      "  39 = 44-(√4/.4)\n",
      "  40 = 44-√(4*4)\n",
      "  41 = (.4+(4*4))/.4\n",
      "  42 = √4+(44-4)\n",
      "  43 = 44-(4/4)\n",
      "  44 = 4+(44-4)\n",
      "  45 = 44+(4/4)\n",
      "  46 = 4+(44-√4)\n",
      "  47 = 4!+(4!-(4/4))\n",
      "  48 = 4*(4+(4+4))\n",
      "  49 = 44+(√4/.4)\n",
      "  50 = 4+(√4+44)\n",
      "  51 = (.4+(4!-4))/.4\n",
      "  52 = 4+(4+44)\n",
      "  53 = 4!+(4!+(√4/.4))\n",
      "  54 = 44+(4/.4)\n",
      "  55 = 44/(.4+.4)\n",
      "  56 = 4*(4+(4/.4))\n",
      "  57 = ((.4+4!)/.4)-4\n",
      "  58 = ((4^4)-4!)/4\n",
      "  59 = (4!/.4)-(4/4)\n",
      "  60 = 44+(4*4)\n",
      "  61 = (4/4)+(4!/.4)\n",
      "  62 = (4*(4*4))-√4\n",
      "  63 = ((4^4)-4)/4\n",
      "  64 = (4+4)*(4+4)\n",
      "  65 = (4+(4^4))/4\n",
      "  66 = √4+(4*(4*4))\n",
      "  67 = √4+((√4+4!)/.4)\n",
      "  68 = 4+(4*(4*4))\n",
      "  69 = (4+(4!-.4))/.4\n",
      "  70 = √4+(4!+44)\n",
      "  71 = (4!+4.4)/.4\n",
      "  72 = 4+(4!+44)\n",
      "CPU times: user 29.5 s, sys: 224 ms, total: 29.7 s\n",
      "Wall time: 30 s\n"
     ]
    }
   ],
   "source": [
    "%time show((4, 4, 4, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "We can also solve the \"2016 with four fours\" puzzle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(4!*(4!+(4!/.4)))'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expressions((4, 4, 4, 4), OPS)[2016]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "In a [separate video](https://www.youtube.com/embed/Noo4lN-vSvw), Alex Bellos shows  how to form **every** integer from 0 to infinity using four 4s, if the square root and `log` functions are allowed. The solution comes from Paul Dirac (although [Dirac originally developed it](https://nebusresearch.wordpress.com/2014/04/18/how-dirac-made-every-number/) for the \"four 2s\" problem).\n",
    "\n",
    "Donald Knuth [conjectured](https://www.tandfonline.com/doi/abs/10.1080/0025570X.1964.11975546) that with floor, square root and factorial, you can make any positive integer with just **one** 4.\n",
    "\n",
    "Below are some popular variant problems:\n",
    "\n",
    "# Four 2s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 30 with expressions((2, 2, 2, 2), \"+-*/^_√!.$\"). (109,747 table entries)\n",
      "\n",
      "   0 = 22-22\n",
      "   1 = 22/22\n",
      "   2 = 2+(2*(2-2))\n",
      "   3 = (2+(2*2))/2\n",
      "   4 = .2*(22-2)\n",
      "   5 = 2+(2+(2/2))\n",
      "   6 = (2*(2*2))-2\n",
      "   7 = 2+(2/(.2*2))\n",
      "   8 = 2+(2+(2*2))\n",
      "   9 = (22/2)-2\n",
      "  10 = 22/2.2\n",
      "  11 = 22/√(2*2)\n",
      "  12 = (2+22)/2\n",
      "  13 = 2+(22/2)\n",
      "  14 = (2^(2*2))-2\n",
      "  15 = (2+(2/2))/.2\n",
      "  16 = 2*(2*(2*2))\n",
      "  17 = 22-(√.2^-2)\n",
      "  18 = 22-(2*2)\n",
      "  19 = (2+(2-.2))/.2\n",
      "  20 = 22-√(2*2)\n",
      "  21 = 22-(2/2)\n",
      "  22 = 2+(22-2)\n",
      "  23 = 22+(2/2)\n",
      "  24 = 22+√(2*2)\n",
      "  25 = (2-2.2)^-2\n",
      "  26 = 2+(2+22)\n",
      "  27 = 22+(√.2^-2)\n",
      "  28 = 2+(2+(2*2)!)\n",
      "  29 = 2+(2+(.2^-2))\n",
      "  30 = (2+(2*2))/.2\n"
     ]
    }
   ],
   "source": [
    "show((2, 2, 2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Four 9s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 61 with expressions((9, 9, 9, 9), \"+-*/^_√!.$\"). (539,849 table entries)\n",
      "\n",
      "   0 = 99-99\n",
      "   1 = 99/99\n",
      "   2 = (99/9)-9\n",
      "   3 = (9+(9+9))/9\n",
      "   4 = (9+(9*√9))/9\n",
      "   5 = √9+((9+9)/9)\n",
      "   6 = √(9+(9+(9+9)))\n",
      "   7 = 9-((9+9)/9)\n",
      "   8 = (99/9)-√9\n",
      "   9 = 9+(9*(9-9))\n",
      "  10 = 99/9.9\n",
      "  11 = 9+((9+9)/9)\n",
      "  12 = (9+99)/9\n",
      "  13 = 9+(√9+(9/9))\n",
      "  14 = √9+(99/9)\n",
      "  15 = 9+((9+9)/√9)\n",
      "  16 = 9+((9/.9)-√9)\n",
      "  17 = 9+(9-(9/9))\n",
      "  18 = 99-(9*9)\n",
      "  19 = 9+(9+(9/9))\n",
      "  20 = 9+(99/9)\n",
      "  21 = (9+9.9)/.9\n",
      "  22 = 9+(√9+(9/.9))\n",
      "  23 = √9+((9+9)/.9)\n",
      "  24 = (99/√9)-9\n",
      "  25 = 9+(√9!+(9/.9))\n",
      "  26 = (9*√9)-(9/9)\n",
      "  27 = 9+(9+√(9*9))\n",
      "  28 = 9+(9+(9/.9))\n",
      "  29 = 9+((9+9)/.9)\n",
      "  30 = (99-9)/√9\n",
      "  31 = (99-√9!)/√9\n",
      "  32 = (99-√9)/√9\n",
      "  33 = √9*(99/9)\n",
      "  34 = (√9+99)/√9\n",
      "  35 = (√9!+99)/√9\n",
      "  36 = 9+(9+(9+9))\n",
      "  37 = (9/.9)+(9*√9)\n",
      "  38 = √9!*(√9+(√9/.9))\n",
      "  39 = 9+(9*(√9/.9))\n",
      "  40 = (9+(9*√9))/.9\n",
      "  41 = (.9+(√9!*√9!))/.9\n",
      "  42 = 9+(99/√9)\n",
      "  43 = √9+(√9!*(√9!/.9))\n",
      "  44 = (9*√9!)-(9/.9)\n",
      "  45 = 9+(9+(9*√9))\n",
      "  46 = (9/.9)+(√9!*√9!)\n",
      "  47 = √9*(9+(√9!/.9))\n",
      "  48 = √9!*(9-(9/9))\n",
      "  49 = 9+(√9!*(√9!/.9))\n",
      "  50 = ((9*√9!)-9)/.9\n",
      "  51 = 9*(9-(√9/.9))\n",
      "  52 = √9!*(9-(√9/9))\n",
      "  53 = (9*√9!)-(9/9)\n",
      "  54 = (9*9)-(9*√9)\n",
      "  55 = 99/(.9+.9)\n",
      "  56 = √9!*(9+(√9/9))\n",
      "  57 = √9*(9+(9/.9))\n",
      "  58 = √9!*(9+(√9!/9))\n",
      "  59 = ((9*√9!)-.9)/.9\n",
      "  60 = √9*((9+9)/.9)\n",
      "  61 = (.9+(9*√9!))/.9\n"
     ]
    }
   ],
   "source": [
    "show((9, 9, 9, 9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Four 5s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 38 with expressions((5, 5, 5, 5), \"+-*/^_√!.$\"). (202,937 table entries)\n",
      "\n",
      "   0 = 55-55\n",
      "   1 = 55/55\n",
      "   2 = 5!/(5+55)\n",
      "   3 = (5+(5+5))/5\n",
      "   4 = √(5+(55/5))\n",
      "   5 = 5+(5*(5-5))\n",
      "   6 = (55/5)-5\n",
      "   7 = 5+((5+5)/5)\n",
      "   8 = 5.5+(.5*5)\n",
      "   9 = 5+(5-(5/5))\n",
      "  10 = 55/5.5\n",
      "  11 = 5.5+5.5\n",
      "  12 = (5+55)/5\n",
      "  13 = (5!-55)/5\n",
      "  14 = (5!/5)-(5+5)\n",
      "  15 = (5*5)-(5+5)\n",
      "  16 = 5+(55/5)\n",
      "  17 = 5+(5!/(5+5))\n",
      "  18 = ((5!-5)/5)-5\n",
      "  19 = (5!-(5*5))/5\n",
      "  20 = 5+(5+(5+5))\n",
      "  21 = (5+5.5)/.5\n",
      "  22 = 55/(.5*5)\n",
      "  23 = 55-(.5^-5)\n",
      "  24 = (5*5)-(5/5)\n",
      "  25 = .5*(55-5)\n",
      "  26 = (5/5)+(5*5)\n",
      "  27 = (.5*55)-.5\n",
      "  28 = .5+(.5*55)\n",
      "  29 = (5!+(5*5))/5\n",
      "  30 = 55-(5*5)\n",
      "  31 = 55-(5!/5)\n",
      "  32 = (5.5-5)^-5\n",
      "  33 = .5*(5!*.55)\n",
      "  34 = 5+(5+(5!/5))\n",
      "  35 = 5+(5+(5*5))\n",
      "  36 = (5!+(.5*5!))/5\n",
      "  37 = 5+(.5^-√(5*5))\n",
      "  38 = ((5!/5)-5)/.5\n",
      "CPU times: user 8.6 s, sys: 19.4 ms, total: 8.62 s\n",
      "Wall time: 8.63 s\n"
     ]
    }
   ],
   "source": [
    "%time show((5, 5, 5, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "\n",
    "# Countdown to 2018\n",
    "\n",
    "Now another type of New Year's countdown puzzle. On December 31 2017, [Michael Littman](http://cs.brown.edu/~mlittman/) posted this:\n",
    "\n",
    "> 2+0+1×8, 2+0-1+8, (2+0-1)×8, |2-0-1-8|, -2-0+1×8, -(2+0+1-8), √|2+0-18|, 2+0+1^8, 20-18, 2^(0×18), 2×0×1×8... Happy New Year!\n",
    "\n",
    "Can we replicate that countdown? For 2018 and for following years?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 30 with expressions((2, 0, 1, 8), \"+-*/^_√!.$\"). (50,633 table entries)\n",
      "\n",
      "   0 = 2*(0*18)\n",
      "   1 = 2^(0*18)\n",
      "   2 = 20-18\n",
      "   3 = 2+(01^8)\n",
      "   4 = √(-2+018)\n",
      "   5 = -(2+01)+8\n",
      "   6 = √(2*018)\n",
      "   7 = -2+(01+8)\n",
      "   8 = (2-01)*8\n",
      "   9 = (2-01)+8\n",
      "  10 = 2+(01*8)\n"
     ]
    }
   ],
   "source": [
    "show((2,0,1,8), 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 36 with expressions((2, 0, 1, 9), \"+-*/^_√!.$\"). (72,371 table entries)\n",
      "\n",
      "   0 = 2*(0*19)\n",
      "   1 = 20-19\n",
      "   2 = 2+(0*19)\n",
      "   3 = 2+(01^9)\n",
      "   4 = (2-01)+√9\n",
      "   5 = 2+(01*√9)\n",
      "   6 = -(2+01)+9\n",
      "   7 = -2+(01*9)\n",
      "   8 = -2+(01+9)\n",
      "   9 = (2-01)*9\n",
      "  10 = 20-(1+9)\n"
     ]
    }
   ],
   "source": [
    "show((2,0,1,9), 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 27 with expressions((2, 0, 2, 0), \"+-*/^_√!.$\"). (8,195 table entries)\n",
      "\n",
      "   0 = 202*0\n",
      "   1 = 20/20\n",
      "   2 = 2+(0*20)\n",
      "   3 = 2+(02^0)\n",
      "   4 = .2*020\n",
      "   5 = 2+(02+0!)\n",
      "   6 = 2*(02+0!)\n",
      "   7 = 2+(0!/.20)\n",
      "   8 = 2^(02+0!)\n",
      "   9 = (20/2)-0!\n",
      "  10 = 2/0.20\n"
     ]
    }
   ],
   "source": [
    "show((2,0,2,0), 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 33 with expressions((2, 0, 2, 1), \"+-*/^_√!.$\"). (38,867 table entries)\n",
      "\n",
      "   0 = 2*(0*21)\n",
      "   1 = -20+21\n",
      "   2 = 2+(0*21)\n",
      "   3 = 2+(02-1)\n",
      "   4 = 2*(02*1)\n",
      "   5 = 2+(02+1)\n",
      "   6 = 2*(02+1)\n",
      "   7 = 2+(0.2^-1)\n",
      "   8 = 2^(02+1)\n",
      "   9 = (20/2)-1\n",
      "  10 = 20/(2*1)\n"
     ]
    }
   ],
   "source": [
    "show((2,0,2,1), 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 32 with expressions((2, 0, 2, 2), \"+-*/^_√!.$\"). (43,815 table entries)\n",
      "\n",
      "   0 = 2*(0*22)\n",
      "   1 = 2-(02/2)\n",
      "   2 = -20+22\n",
      "   3 = 2+(02/2)\n",
      "   4 = 2*((0*2)+2)\n",
      "   5 = 20/(2*2)\n",
      "   6 = 2+(02*2)\n",
      "   7 = 2+(0!+(2*2))\n",
      "   8 = 2*(02*2)\n",
      "   9 = (20-2)/2\n",
      "  10 = 20-(2/.2)\n"
     ]
    }
   ],
   "source": [
    "show((2,0,2,2), 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Making 6 from 3 Digits\n",
    "\n",
    "Nicolas Schank posted the following in the Facebook \"omg math\" group.\n",
    "\n",
    "> For each digit from 0 to 9, find at least one way to express 6 using only that digit exactly three times and arithmetic operations. For instance, using the digit 2, `'2+2^2'` = 6.\n",
    "\n",
    "It turns out this is easy (if we assume \"arithmetic operations\" include square root and factorial):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['(0!+(0!+0!))!',\n",
       " '(1+(1+1))!',\n",
       " '(2+(2*2))',\n",
       " '((3*3)-3)',\n",
       " '(4+(4-√4))',\n",
       " '(5+(5/5))',\n",
       " '(6+(6-6))',\n",
       " '(7-(7/7))',\n",
       " '(8-√√(8+8))',\n",
       " '((9+9)/√9)']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[expressions((n, n, n), '+-*/^!√').get(6) for n in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The 24 Problem\n",
    "\n",
    "In the [538 Riddler for July 10th 2020](https://fivethirtyeight.com/features/can-you-make-24/), Zach Wissner-Gross asks \"Can you make 24?\" from the digits (2, 3, 3, 4), in any order, with just the five binary operators. For extra credit, Zach asks for multiple ways to make 24. Readers sent in suggestions for other sets of four digits with which to make 24.\n",
    "\n",
    "We haven't dealt with reporting multiple ways, and we haven't allowed different orders for the digits. I'll deal with both by trying all permutations of the digits, and collecting one expression from each permutation (if there is one). If there are multiple ways with a single permutation we won't get more than one of those, but this approach should be good enough to answer the question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'(((3^2)-3)*4)',\n",
       " '(((4-2)^3)*3)',\n",
       " '(3*((4-2)^3))',\n",
       " '(3*(4^(3/2)))',\n",
       " '(3/((2/4)^3))',\n",
       " '(4*((3^2)-3))'}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def can_make(total: int, numbers: tuple, ops=OPS) -> Set[Exp]:\n",
    "    \"\"\"Can we make the total from the numbers (in any order)? Return a set of ways to do it.\"\"\"\n",
    "    return {expressions(nums, ops).get(total)\n",
    "            for nums in set(permutations(numbers))} - {None}\n",
    "\n",
    "can_make(24, (2, 3, 3, 4), '+-*/^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'((3^2)+(8+8))', '(8+((3^2)+8))', '(8+(8+(3^2)))'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(25, (2, 3, 8, 8), '+-*/^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'(((10-3)*2)+10)',\n",
       " '((2*(10-3))+10)',\n",
       " '((2^10)-(10^3))',\n",
       " '(10+((10-3)*2))',\n",
       " '(10+(2*(10-3)))',\n",
       " '(10-((3-10)*2))',\n",
       " '(10-(2*(3-10)))'}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(24, (2, 3, 10, 10), '+-*/^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'(8/(3-(8/3)))'}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(24, (3, 3, 8, 8), '+-*/^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'(((3*6)-6)*2)',\n",
       " '(((3+2)*6)-6)',\n",
       " '(((3+6)*2)+6)',\n",
       " '(((6+3)*2)+6)',\n",
       " '((2*(3+6))+6)',\n",
       " '((2*(6+3))+6)',\n",
       " '((2+6)*(6-3))',\n",
       " '(6*(6*(2/3)))',\n",
       " '(6+((3+6)*2))',\n",
       " '(6+((6+3)*2))',\n",
       " '(6+(2*(3+6)))',\n",
       " '(6+(2*(6+3)))'}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(24, (2, 3, 6, 6), '+-*/^')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(24, (0, 0, 2, 5), '+-*/^')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I didn't get an answer for that one. I can allow factorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'(((2*0)-0!)+5)!',\n",
       " '((0*2)+(5-0!)!)',\n",
       " '((0-(2^0))+5)!',\n",
       " '((0-0!)+(5^2))',\n",
       " '((2*0)+(5-0!)!)',\n",
       " '((5-0!)!+(0*2))',\n",
       " '((5^(0+2))-0!)',\n",
       " '((5^2)+(0-0!))',\n",
       " '(0+((0!-2)+5)!)',\n",
       " '(0+((5^2)-0!))',\n",
       " '(0+(5+(0!-2))!)',\n",
       " '(2*((5^0)+0!))!'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "can_make(24, (0, 0, 2, 5), '+-*/^!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Even More Fours: The Power of Floor and Ceiling\n",
    "\n",
    "With the standard set of `OPS`, we got all the integers up to 72 with four 4s. If we add the floor and ceiling operators, we get a big jump: suddenly, all the results of a division or a square root that didn't form an integer can now be coerced into integers. Instead of getting the integers only up to 72, we now get all the way up to 1644 (although it takes three times as long to get there):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 1644 with expressions((4, 4, 4, 4), \"+-*/^_√!.$⌊⌈\"). (1,147,507 table entries)\n",
      "\n",
      "   0 = 44-44\n",
      "   1 = 44/44\n",
      "   2 = √⌊4.444⌋\n",
      "   3 = 4-⌈.444⌉\n",
      "   4 = ⌊4.444⌋\n",
      "   5 = ⌈4.444⌉\n",
      "   6 = √(44-(4+4))\n",
      "   7 = (44/4)-4\n",
      "   8 = 4+⌊4.44⌋\n",
      "   9 = 4+⌈4.44⌉\n",
      "  10 = 44/4.4\n",
      "  11 = 44/⌊4.4⌋\n",
      "  12 = (4+44)/4\n",
      "  13 = √4+(44/4)\n",
      "  14 = 4+(4+(4+√4))\n",
      "  15 = 4+(44/4)\n",
      "  16 = .4*(44-4)\n",
      "  17 = ⌊(4*4.44)⌋\n",
      "  18 = ⌈(4*4.44)⌉\n",
      "  19 = ⌊(.44*44)⌋\n",
      "  20 = 4*⌈4.44⌉\n",
      "  21 = (4+4.4)/.4\n",
      "  22 = √4*(44/4)\n",
      "  23 = 4!-⌈.444⌉\n",
      "  24 = 4+(4+(4*4))\n",
      "  25 = ⌊(.444^-4)⌋\n",
      "  26 = 4+(44/√4)\n",
      "  27 = ⌈(4*√44.4)⌉\n",
      "  28 = 44-(4*4)\n",
      "  29 = 4!+⌈4.44⌉\n",
      "  30 = (4+(4+4))/.4\n",
      "  31 = 4+⌈(4*√44)⌉\n",
      "  32 = (4*4)+(4*4)\n",
      "  33 = ⌊(4*(4+4.4))⌋\n",
      "  34 = 44-(4/.4)\n",
      "  35 = 4!+(44/4)\n",
      "  36 = 44-(4+4)\n",
      "  37 = 44-⌈√44⌉\n",
      "  38 = 44-(4+√4)\n",
      "  39 = 44-⌈4.4⌉\n",
      "  40 = 44-⌊4.4⌋\n",
      "  41 = ⌈44.4⌉-4\n",
      "  42 = √4+(44-4)\n",
      "  43 = 44-(4/4)\n",
      "  44 = ⌊44.44⌋\n",
      "  45 = ⌈44.44⌉\n",
      "  46 = 4+(44-√4)\n",
      "  47 = √4+⌈44.4⌉\n",
      "  48 = 4*(4+(4+4))\n",
      "  49 = 4+⌈44.4⌉\n",
      "  50 = 4+(√4+44)\n",
      "  51 = 44+⌈√44⌉\n",
      "  52 = 4+(4+44)\n",
      "  53 = ⌊((4+4)*√44)⌋\n",
      "  54 = 44+(4/.4)\n",
      "  55 = 44/(.4+.4)\n",
      "  56 = 4*(4+(4/.4))\n",
      "  57 = ⌊(4*(4*(4-.4)))⌋\n",
      "  58 = ⌊(.4^-4.44)⌋\n",
      "  59 = ⌈(.4^-4.44)⌉\n",
      "  60 = 44+(4*4)\n",
      "  61 = (4/4)+(4!/.4)\n",
      "  62 = (4*(4*4))-√4\n",
      "  63 = ((4^4)-4)/4\n",
      "  64 = (4+4)*(4+4)\n",
      "  65 = (4+(4^4))/4\n",
      "  66 = √4+(4*(4*4))\n",
      "  67 = 4!+(44-⌈.4⌉)\n",
      "  68 = 4+(4*(4*4))\n",
      "  69 = 4!+⌈44.4⌉\n",
      "  70 = √4+(4!+44)\n",
      "  71 = ⌈(.4*(4*44))⌉\n",
      "  72 = 4+(4!+44)\n",
      "  73 = 4+⌊(44/√.4)⌋\n",
      "  74 = 4+((4+4!)/.4)\n",
      "  75 = ⌊((4+44)/√.4)⌋\n",
      "  76 = ⌈4.4⌉!-44\n",
      "  77 = ⌈(44*(4^.4))⌉\n",
      "  78 = ⌊(4*(4!-4.4))⌋\n",
      "  79 = ⌈(4*(4!-4.4))⌉\n",
      "  80 = 4*(4+(4*4))\n",
      "  81 = (4-(4/4))^4\n",
      "  82 = √4+(4*(4!-4))\n",
      "  83 = 44+⌊(.4^-4)⌋\n",
      "  84 = (√4*44)-4\n",
      "  85 = ⌊(4!*(4-.44))⌋\n",
      "  86 = (44/.4)-4!\n",
      "  87 = (√4*44)-⌈.4⌉\n",
      "  88 = 44+44\n",
      "  89 = ⌈(√4*44.4)⌉\n",
      "  90 = √4+(√4*44)\n",
      "  91 = ⌈(444/√4!)⌉\n",
      "  92 = 4+(√4*44)\n",
      "  93 = ⌈(44*√4.4)⌉\n",
      "  94 = ⌈((4.4^4)/4)⌉\n",
      "  95 = (4*4!)-(4/4)\n",
      "  96 = √4*(4+44)\n",
      "  97 = (4/4)+(4*4!)\n",
      "  98 = ⌈(4*(4!+.44))⌉\n",
      "  99 = ⌊(4^√(44/4))⌋\n",
      " 100 = 44/.44\n",
      " 101 = ⌈4.4⌉+(4*4!)\n",
      " 102 = (.4*(4^4))-.4\n",
      " 103 = (4*4!)+⌈√44⌉\n",
      " 104 = 44+(4!/.4)\n",
      " 105 = (44-√4)/.4\n",
      " 106 = (44/.4)-4\n",
      " 107 = ⌈(4!*4.44)⌉\n",
      " 108 = (44/.4)-√4\n",
      " 109 = (44-.4)/.4\n",
      " 110 = ⌊44.4⌋/.4\n",
      " 111 = 444/4\n",
      " 112 = √4+(44/.4)\n",
      " 113 = ⌈(.44*(4^4))⌉\n",
      " 114 = 4+(44/.4)\n",
      " 115 = (√4+44)/.4\n",
      " 116 = 4+(4*(4+4!))\n",
      " 117 = ⌈(44*√⌈√44⌉)⌉\n",
      " 118 = ⌈4.44⌉!-√4\n",
      " 119 = ⌈4.4⌉!-(4/4)\n",
      " 120 = (4+44)/.4\n",
      " 121 = (44/4)^√4\n",
      " 122 = √4+⌈4.44⌉!\n",
      " 123 = ⌊(4.4*(4+4!))⌋\n",
      " 124 = 4+⌈4.44⌉!\n",
      " 125 = ⌈(44*√(4+4))⌉\n",
      " 126 = ((4^4)-4)/√4\n",
      " 127 = ((4^4)-√4)/√4\n",
      " 128 = 4*(4*(4+4))\n",
      " 129 = (√4+(4^4))/√4\n",
      " 130 = (4+(4^4))/√4\n",
      " 131 = ⌈(4!*(4!/4.4))⌉\n",
      " 132 = 44*⌈√4.4⌉\n",
      " 133 = ⌈((4!-4)*√44)⌉\n",
      " 134 = 4!+(44/.4)\n",
      " 135 = ⌊(4!/.44)⌋/.4\n",
      " 136 = √4*(4!+44)\n",
      " 137 = ⌈(√4.4^√44)⌉\n",
      " 138 = ⌈(.44^-(4+√4))⌉\n",
      " 139 = ⌊(4^(4-.44))⌋\n",
      " 140 = 44+(4*4!)\n",
      " 141 = ⌈(4*((.4^-4)-4))⌉\n",
      " 142 = (4!*(4+√4))-√4\n",
      " 143 = ((4!*4!)-4)/4\n",
      " 144 = (4+(4+4))^√4\n",
      " 145 = (4+(4!*4!))/4\n",
      " 146 = (4!/(.4*.4))-4\n",
      " 147 = ⌊(44^(√4^.4))⌋\n",
      " 148 = 4+(4!*(4+√4))\n",
      " 149 = ⌊(.4*(4.4^4))⌋\n",
      " 150 = .4*⌈(4.4^4)⌉\n",
      " 151 = 4+⌊(4^(4-.4))⌋\n",
      " 152 = (4*44)-4!\n",
      " 153 = ⌈(4/(.4^4))⌉-4\n",
      " 154 = 4+(4!/(.4*.4))\n",
      " 155 = ⌊(4!*√44)⌋-4\n",
      " 156 = ⌊(44*(4!^.4))⌋\n",
      " 157 = ⌈(44*(4!^.4))⌉\n",
      " 158 = ⌊(44*(4-.4))⌋\n",
      " 159 = ⌈(44*(4-.4))⌉\n",
      " 160 = 4*(44-4)\n",
      " 161 = ⌈((4-.44)^4)⌉\n",
      " 162 = ⌈((.4+4!)*√44)⌉\n",
      " 163 = 4+⌊(4!*√44)⌋\n",
      " 164 = 44+⌈4.4⌉!\n",
      " 165 = 4+⌊(√.4*(4^4))⌋\n",
      " 166 = ⌊(4!*√(4+44))⌋\n",
      " 167 = ⌈(4!*√(4+44))⌉\n",
      " 168 = 4*(44-√4)\n",
      " 169 = ⌈(4!*(.4+√44))⌉\n",
      " 170 = (4!+44)/.4\n",
      " 171 = ⌊(4.4/(.4^4))⌋\n",
      " 172 = (4*44)-4\n",
      " 173 = ⌊(4*(44-√.4))⌋\n",
      " 174 = (4*44)-√4\n",
      " 175 = (4*44)-⌈.4⌉\n",
      " 176 = 4*⌊44.4⌋\n",
      " 177 = ⌊(.4*444)⌋\n",
      " 178 = √4+(4*44)\n",
      " 179 = ⌈(.4*(4^4.4))⌉\n",
      " 180 = 4+(4*44)\n",
      " 181 = (4+(4+√4)!)/4\n",
      " 182 = ⌈(4*(√√4+44))⌉\n",
      " 183 = ⌈(4!*(4+(4-.4)))⌉\n",
      " 184 = 4*(√4+44)\n",
      " 185 = ⌊((4+4!)*√44)⌋\n",
      " 186 = ⌈((4+4!)*√44)⌉\n",
      " 187 = ⌊(4.4^4)⌋/√4\n",
      " 188 = (4!*(4+4))-4\n",
      " 189 = ⌊(44/(√.4-.4))⌋\n",
      " 190 = (4!*(4+4))-√4\n",
      " 191 = (4!*(4+4))-⌈.4⌉\n",
      " 192 = 4*(4+44)\n",
      " 193 = ⌊(4.4*44)⌋\n",
      " 194 = ⌈(4.4*44)⌉\n",
      " 195 = ⌊(4*(√4!+44))⌋\n",
      " 196 = 4+(4!*(4+4))\n",
      " 197 = ⌈(44*√(4!-4))⌉\n",
      " 198 = ⌈(44*(√4!-.4))⌉\n",
      " 199 = ⌊(44^(.4+⌈.4⌉))⌋\n",
      " 200 = 4!+(4*44)\n",
      " 201 = ⌊(4!*(4+4.4))⌋\n",
      " 202 = ⌈(4!*(4+4.4))⌉\n",
      " 203 = ⌊(44*(4+√.4))⌋\n",
      " 204 = ⌈(44*(4+√.4))⌉\n",
      " 205 = ⌈((.4+.4)*(4^4))⌉\n",
      " 206 = ⌊(44^√√4)⌋-4\n",
      " 207 = ⌊(4.4^(4-.4))⌋\n",
      " 208 = 4*(4+(√4*4!))\n",
      " 209 = ⌊((4-√.4)^4.4)⌋\n",
      " 210 = ⌊(√44^√(4+4))⌋\n",
      " 211 = ⌊(√4!*44)⌋-4\n",
      " 212 = (4^4)-44\n",
      " 213 = ⌊(44.4^√√4)⌋\n",
      " 214 = ⌈(44.4^√√4)⌉\n",
      " 215 = 4+⌈(44^√√4)⌉\n",
      " 216 = 4!*(4+⌈4.4⌉)\n",
      " 217 = ⌊(√4!*44.4)⌋\n",
      " 218 = ⌈(√4!*44.4)⌉\n",
      " 219 = ⌈(4*(4!/.44))⌉\n",
      " 220 = 44*⌈4.4⌉\n",
      " 221 = ⌈(4!*(4^(.4*4)))⌉\n",
      " 222 = 444/√4\n",
      " 223 = ⌈(4^4.4)⌉/√4\n",
      " 224 = (4+4)*(4+4!)\n",
      " 225 = ⌊(4/(.4^4.4))⌋\n",
      " 226 = ⌈(4/(.4^4.4))⌉\n",
      " 227 = 4+⌈((4^√4!)/4)⌉\n",
      " 228 = (4^4)-(4+4!)\n",
      " 229 = ⌈(4^(4-(√4/4!)))⌉\n",
      " 230 = ((4*4!)-4)/.4\n",
      " 231 = ⌊(.44^-√44)⌋\n",
      " 232 = ⌈(.44^-√44)⌉\n",
      " 233 = ⌈(44*√(4+4!))⌉\n",
      " 234 = √4+((4^4)-4!)\n",
      " 235 = ⌊(√4!*(4+44))⌋\n",
      " 236 = 4+((4^4)-4!)\n",
      " 237 = ⌊(√.4*(4.4^4))⌋\n",
      " 238 = ⌊(44*(4+√√4))⌋\n",
      " 239 = ⌈(44*(4+√√4))⌉\n",
      " 240 = (4^4)-(4*4)\n",
      " 241 = (.4+(4*4!))/.4\n",
      " 242 = √4+(4*(4!/.4))\n",
      " 243 = ⌈√4.4⌉^⌈4.4⌉\n",
      " 244 = 4+(4*(4!/.4))\n",
      " 245 = (√4+(4*4!))/.4\n",
      " 246 = (4^4)-(4/.4)\n",
      " 247 = ⌊(4^(4-(.4^4)))⌋\n",
      " 248 = (4^4)-(4+4)\n",
      " 249 = (4^4)-⌈√44⌉\n",
      " 250 = (4^4)-(4+√4)\n",
      " 251 = (4^4)-⌈4.4⌉\n",
      " 252 = (4^4)-⌊4.4⌋\n",
      " 253 = ⌈.4⌉+((4^4)-4)\n",
      " 254 = √4+((4^4)-4)\n",
      " 255 = (4^4)-(4/4)\n",
      " 256 = 4*(4*(4*4))\n",
      " 257 = (4/4)+(4^4)\n",
      " 258 = 4+((4^4)-√4)\n",
      " 259 = (4^4)+⌈√4.4⌉\n",
      " 260 = 4+(4^⌊4.4⌋)\n",
      " 261 = (4^4)+⌈4.4⌉\n",
      " 262 = 4+(√4+(4^4))\n",
      " 263 = (4^4)+⌈√44⌉\n",
      " 264 = 44*(4+√4)\n",
      " 265 = ⌊(4^(4+(.4^4)))⌋\n",
      " 266 = (4/.4)+(4^4)\n",
      " 267 = ⌈(.4^-(4+√4.4))⌉\n",
      " 268 = ⌊(4!^(4*.44))⌋\n",
      " 269 = ⌈(4!^(4*.44))⌉\n",
      " 270 = ⌊((4*(.4-√√4))^4)⌋\n",
      " 271 = ⌊(4*(4!*√(4+4)))⌋\n",
      " 272 = 4*(4!+44)\n",
      " 273 = ⌊(4^(4!^.44))⌋\n",
      " 274 = ⌈(4^(4!^.44))⌉\n",
      " 275 = 44/(.4*.4)\n",
      " 276 = 4!+((4^4)-4)\n",
      " 277 = ⌈(√4!/(.4^4.4))⌉\n",
      " 278 = ⌊(4*(44/√.4))⌋\n",
      " 279 = ⌈(4*(44/√.4))⌉\n",
      " 280 = ⌊(√.4*444)⌋\n",
      " 281 = ⌈(√.4*444)⌉\n",
      " 282 = √4+(4!+(4^4))\n",
      " 283 = ⌈((4+(.4/4))^4)⌉\n",
      " 284 = 4+(4!+(4^4))\n",
      " 285 = ⌈((4^4)/(√4!-4))⌉\n",
      " 286 = ((4!*4!)-4)/√4\n",
      " 287 = ⌈(√4!^(4-.44))⌉\n",
      " 288 = 4!*(4+(4+4))\n",
      " 289 = ⌊(.4*44)⌋^√4\n",
      " 290 = (⌈4.4⌉!-4)/.4\n",
      " 291 = ⌊(44*√44)⌋\n",
      " 292 = ⌈(44*√44)⌉\n",
      " 293 = ⌊(4^(√4+√4.4))⌋\n",
      " 294 = ⌊(4^(4+(.4/4)))⌋\n",
      " 295 = ⌈(4^(4+(.4/4)))⌉\n",
      " 296 = (⌈4.4⌉!/.4)-4\n",
      " 297 = ⌊(.4*(4!+(4+√4)!))⌋\n",
      " 298 = ⌊((4+(√.4/4))^4)⌋\n",
      " 299 = ⌊((4+(.4*.4))^4)⌋\n",
      " 300 = 44+(4^4)\n",
      " 301 = ⌊((4+(4/4!))^4)⌋\n",
      " 302 = ⌈((4+(4/4!))^4)⌉\n",
      " 303 = ⌈(.4^(.4-√44))⌉\n",
      " 304 = 4!+(4!+(4^4))\n",
      " 305 = ⌈(44*√(√4*4!))⌉\n",
      " 306 = ⌊(4^(4*(.4+√.4)))⌋\n",
      " 307 = ⌈(4^(4*(.4+√.4)))⌉\n",
      " 308 = 44*⌈√44⌉\n",
      " 309 = ⌊((.4*44)^√4)⌋\n",
      " 310 = ⌈((.4*44)^√4)⌉\n",
      " 311 = ⌊((4+(.4/√4))^4)⌋\n",
      " 312 = ⌊((4+4)/(.4^4))⌋\n",
      " 313 = ⌊(444/√√4)⌋\n",
      " 314 = ⌈(444/√√4)⌉\n",
      " 315 = ⌊((4^4.4)/√√4)⌋\n",
      " 316 = (4^4)+(4!/.4)\n",
      " 317 = ⌈(.44*(4+√4)!)⌉\n",
      " 318 = √4*⌊(4!*√44)⌋\n",
      " 319 = ⌊(4^(4+(.4*.4)))⌋\n",
      " 320 = 4*(4*(4!-4))\n",
      " 321 = ⌈(4*(4^√(4/.4)))⌉\n",
      " 322 = ⌊(4^(4+(4/4!)))⌋\n",
      " 323 = ⌈(4^(4+(4/4!)))⌉\n",
      " 324 = ((4+√4)^4)/4\n",
      " 325 = ⌈(.4^(4/-√.4))⌉-4\n",
      " 326 = ⌊((4+(⌈.4⌉/4))^4)⌋\n",
      " 327 = ⌈((4+(⌈.4⌉/4))^4)⌉\n",
      " 328 = ⌊(.4^-√(44-4))⌋\n",
      " 329 = ⌈(.4^-√(44-4))⌉\n",
      " 330 = ⌊((4+4!)^(4^.4))⌋\n",
      " 331 = ⌈((4+4!)^(4^.4))⌉\n",
      " 332 = ⌊((.4+√4)^√44)⌋\n",
      " 333 = ⌊(√4!*(4!+44))⌋\n",
      " 334 = ⌈(√4!*(4!+44))⌉\n",
      " 335 = ⌊(4^√(.4*44))⌋\n",
      " 336 = 4!*(4+(4/.4))\n",
      " 337 = ⌊(√4^(4+4.4))⌋\n",
      " 338 = ⌈(√4^(4+4.4))⌉\n",
      " 339 = ⌊(4!^(44/4!))⌋\n",
      " 340 = ⌈(4!^(44/4!))⌉\n",
      " 341 = ⌈(44*√(4!/.4))⌉\n",
      " 342 = ⌊(4*(4!*(4!^.4)))⌋\n",
      " 343 = ⌈√44⌉^⌈√4.4⌉\n",
      " 344 = 4*⌊(4!*(4-.4))⌋\n",
      " 345 = ⌊(4*(4!*(4-.4)))⌋\n",
      " 346 = ⌊(4!^(4^.44))⌋\n",
      " 347 = ⌈(4!^(4^.44))⌉\n",
      " 348 = 4*⌈(4!*(4-.4))⌉\n",
      " 349 = ⌊((√4-(4/√.4))^4)⌋\n",
      " 350 = ⌊(4.4^4)⌋-4!\n",
      " 351 = ⌈(4.4^4)⌉-4!\n",
      " 352 = 44*(4+4)\n",
      " 353 = ⌈(.4^(.4*(4*-4)))⌉\n",
      " 354 = ⌊((4.4^√4!)/4)⌋\n",
      " 355 = ⌈(4.4^√4!)⌉/4\n",
      " 356 = ((4+√4)!/√4)-4\n",
      " 357 = ⌈(√√4*((4^4)-4))⌉\n",
      " 358 = ⌊((4+4)^√(4+4))⌋\n",
      " 359 = ⌈((4+4)^√(4+4))⌉\n",
      " 360 = (4*(4*4!))-4!\n",
      " 361 = (⌈4.4⌉-4!)^√4\n",
      " 362 = (4+(4+√4)!)/√4\n",
      " 363 = ⌈((4^4)*√(4-√4))⌉\n",
      " 364 = 4+((4+√4)!/√4)\n",
      " 365 = ⌈(4*((4*4!)-√4!))⌉\n",
      " 366 = 4+⌊(√√4*(4^4))⌋\n",
      " 367 = ⌊((4^(4-.4))/.4)⌋\n",
      " 368 = 4*((4*4!)-4)\n",
      " 369 = ⌊((4.4^4)-√4!)⌋\n",
      " 370 = ⌊(4.4^4)⌋-4\n",
      " 371 = ⌈(4.4^4)⌉-4\n",
      " 372 = ⌊(4.4^4)⌋-√4\n",
      " 373 = ⌈(4.4^4)⌉-√4\n",
      " 374 = ⌊((4.4^4)-.4)⌋\n",
      " 375 = ⌊(.4+(4.4^4))⌋\n",
      " 376 = ⌈(.4+(4.4^4))⌉\n",
      " 377 = √4+⌈(4.4^4)⌉\n",
      " 378 = 4+⌊(4.4^4)⌋\n",
      " 379 = 4+⌈(4.4^4)⌉\n",
      " 380 = (4*(4*4!))-4\n",
      " 381 = ⌊((.4^-(4+4))/4)⌋\n",
      " 382 = (4*(4*4!))-√4\n",
      " 383 = (4*(4*4!))-⌈.4⌉\n",
      " 384 = 4*(4*⌊4.4⌋!)\n",
      " 385 = ⌈.4⌉+(4*(4*4!))\n",
      " 386 = √4+(4*(4*4!))\n",
      " 387 = ⌈(4*(√.4+(4*4!)))⌉\n",
      " 388 = ⌊(4.44^4)⌋\n",
      " 389 = ⌈(4.44^4)⌉\n",
      " 390 = ⌊(4*(4*(.4+4!)))⌋\n",
      " 391 = ⌊(44*(4+√4!))⌋\n",
      " 392 = 4*(√4+(4*4!))\n",
      " 393 = ⌊(4!*(.4+(4*4)))⌋\n",
      " 394 = ⌈(4!*(.4+(4*4)))⌉\n",
      " 395 = ⌊((√4!-.44)^4)⌋\n",
      " 396 = 44*⌊(.4*4!)⌋\n",
      " 397 = ⌊(4*(√4^√44))⌋\n",
      " 398 = 4!+⌊(4.4^4)⌋\n",
      " 399 = 4!+⌈(4.4^4)⌉\n",
      " 400 = 4*(4+(4*4!))\n",
      " 401 = ⌈((4^4)/√.4)⌉-4\n",
      " 402 = √4+((4-4!)^√4)\n",
      " 403 = ⌊((4!^(.4*4))/.4)⌋\n",
      " 404 = 4+((4-4!)^√4)\n",
      " 405 = ⌊(.4^-((.4*4)^4))⌋\n",
      " 406 = ⌈(.4^-((.4*4)^4))⌉\n",
      " 407 = ⌈(4*(4*(4!+√√4)))⌉\n",
      " 408 = 4!+(4*(4*4!))\n",
      " 409 = ⌊(.4*(4*(4^4)))⌋\n",
      " 410 = ⌈(.4*(4*(4^4)))⌉\n",
      " 411 = ⌈((4+(√4/4))^4)⌉\n",
      " 412 = 4*⌈(.4*(4^4))⌉\n",
      " 413 = ⌈(.4^-√44)⌉-4!\n",
      " 414 = 4+⌈((.4-√4!)^4)⌉\n",
      " 415 = ⌊(44/(√.4^√4!))⌋\n",
      " 416 = 4*(4*(√4+4!))\n",
      " 417 = ⌈(4!*(4!-√44))⌉\n",
      " 418 = ⌈(4^((4^.4)/.4))⌉\n",
      " 419 = ⌊(((.4-4)^4)/.4)⌋\n",
      " 420 = 444-4!\n",
      " 421 = ⌊(4^4.4)⌋-4!\n",
      " 422 = ⌊(.4*(4!*44))⌋\n",
      " 423 = ⌈(.4*(4!*44))⌉\n",
      " 424 = 4*⌈(4!*4.4)⌉\n",
      " 425 = ⌈(.4^-√(44-.4))⌉\n",
      " 426 = ⌊(44^(.4*4))⌋\n",
      " 427 = ⌈(44^(.4*4))⌉\n",
      " 428 = 4*⌈(4^(4-√.4))⌉\n",
      " 429 = ⌈(4!^(4/√4.4))⌉\n",
      " 430 = √4*⌊(√4!*44)⌋\n",
      " 431 = ⌊(44*√(4*4!))⌋\n",
      " 432 = 4!*(√4+(4*4))\n",
      " 433 = ⌈(.4^-√44)⌉-4\n",
      " 434 = ⌊(.4^-√44)⌋-√4\n",
      " 435 = ⌊((.4^-√44)-.4)⌋\n",
      " 436 = ⌊(.4+(.4^-√44))⌋\n",
      " 437 = ⌊((4+(4^-.4))^4)⌋\n",
      " 438 = ⌈((4+(4^-.4))^4)⌉\n",
      " 439 = ⌊(444-√4!)⌋\n",
      " 440 = 444-4\n",
      " 441 = ⌊(4^4.4)⌋-4\n",
      " 442 = 444-√4\n",
      " 443 = 444-⌈.4⌉\n",
      " 444 = ⌊444.4⌋\n",
      " 445 = ⌈444.4⌉\n",
      " 446 = √4+444\n",
      " 447 = ⌈(.4+(4^4.4))⌉\n",
      " 448 = 4+444\n",
      " 449 = 4+⌊(4^4.4)⌋\n",
      " 450 = 4+⌈(4^4.4)⌉\n",
      " 451 = ⌈(√4!+(4^4.4))⌉\n",
      " 452 = 4*(⌊(4!*√4!)⌋-4)\n",
      " 453 = ⌈((4^4)/(.4*√√4))⌉\n",
      " 454 = ⌊((4^(4+√√4))/4)⌋\n",
      " 455 = ⌈((4^(4+√√4))/4)⌉\n",
      " 456 = 4!*(4!-⌈4.4⌉)\n",
      " 457 = ⌈((4+√.4)^4)⌉-4\n",
      " 458 = ⌊((4+√.4)^4)⌋-√4\n",
      " 459 = ⌈((4+√.4)^4)⌉-√4\n",
      " 460 = ⌊((√4-√44)^4)⌋\n",
      " 461 = ⌈((√4-√44)^4)⌉\n",
      " 462 = ⌊(4^√(4!-4.4))⌋\n",
      " 463 = ⌈(4^√(4!-4.4))⌉\n",
      " 464 = 4*(⌈4.4⌉!-4)\n",
      " 465 = 4+⌈((4+√.4)^4)⌉\n",
      " 466 = ⌊(4*(4!*√4!))⌋-4\n",
      " 467 = ⌊(.4^-√⌈44.4⌉)⌋\n",
      " 468 = 4!+444\n",
      " 469 = 4!+⌊(4^4.4)⌋\n",
      " 470 = 4!+⌈(4^4.4)⌉\n",
      " 471 = ⌊(4^4.44)⌋\n",
      " 472 = ⌈(4^4.44)⌉\n",
      " 473 = ⌊(√4^(4+√4!))⌋-4\n",
      " 474 = 4+⌊(4*(4!*√4!))⌋\n",
      " 475 = 4+⌈(4*(4!*√4!))⌉\n",
      " 476 = (4*⌈4.4⌉!)-4\n",
      " 477 = ⌊(4^(4/(√4!-4)))⌋\n",
      " 478 = (4*⌈4.4⌉!)-√4\n",
      " 479 = (4*⌈4.4⌉!)-⌈.4⌉\n",
      " 480 = 4*⌈4.44⌉!\n",
      " 481 = ⌈.4⌉+(4*⌈4.4⌉!)\n",
      " 482 = √4+(4*⌈4.4⌉!)\n",
      " 483 = ⌊(4^(√4!-.44))⌋\n",
      " 484 = (44^√4)/4\n",
      " 485 = ⌊((4+(.4^.4))^4)⌋\n",
      " 486 = ⌈((4+(.4^.4))^4)⌉\n",
      " 487 = ⌈(4*(4+(4!*√4!)))⌉\n",
      " 488 = (√4*(4^4))-4!\n",
      " 489 = ⌈(4^√(4!-4))⌉-4\n",
      " 490 = ⌊((4+√(√4/4))^4)⌋\n",
      " 491 = ⌈((4+√(√4/4))^4)⌉\n",
      " 492 = ⌊(4^√(4+(4*4)))⌋\n",
      " 493 = ⌈(4^√(4+(4*4)))⌉\n",
      " 494 = √4+⌊(4^√(4!-4))⌋\n",
      " 495 = √4+⌈(4^√(4!-4))⌉\n",
      " 496 = 4*(4+⌈4.4⌉!)\n",
      " 497 = 4+⌈(4^√(4!-4))⌉\n",
      " 498 = ⌊((√.4/4)^(√.4-4))⌋\n",
      " 499 = ⌊(.4^-√(√4+44))⌋\n",
      " 500 = ⌈(.4^-√(√4+44))⌉\n",
      " 501 = ⌊(.4*(√4!*(4^4)))⌋\n",
      " 502 = ⌊((4-.44)^√4!)⌋\n",
      " 503 = ⌈((4-.44)^√4!)⌉\n",
      " 504 = √4*((4^4)-4)\n",
      " 505 = ⌊(√4^(44/√4!))⌋\n",
      " 506 = ⌊(4!*(√4^4.4))⌋\n",
      " 507 = ⌈(4!*(√4^4.4))⌉\n",
      " 508 = (√4*(4^4))-4\n",
      " 509 = ⌈(4!*(4!-√(4+4)))⌉\n",
      " 510 = (√4*(4^4))-√4\n",
      " 511 = (√4*(4^4))-⌈.4⌉\n",
      " 512 = (4^4)+(4^4)\n",
      " 513 = ⌈.4⌉+(√4*(4^4))\n",
      " 514 = √4+(√4*(4^4))\n",
      " 515 = ⌈(4*((4-√.4)^4))⌉\n",
      " 516 = 4+(√4*(4^4))\n",
      " 517 = ⌊(4!*(√4!*4.4))⌋\n",
      " 518 = ⌊(.4*((4+√4)^4))⌋\n",
      " 519 = ⌈(.4*((4+√4)^4))⌉\n",
      " 520 = √4*(4+(4^4))\n",
      " 521 = ⌊(.4^-(4+√(4+4)))⌋\n",
      " 522 = ⌈(.4^-(4+√(4+4)))⌉\n",
      " 523 = ⌊(4^√(.4+(4!-4)))⌋\n",
      " 524 = (4!*(4!-√4))-4\n",
      " 525 = ⌊(44^√√4)⌋/.4\n",
      " 526 = ⌈(4!*(4!-√4.4))⌉\n",
      " 527 = ⌊((44^√√4)/.4)⌋\n",
      " 528 = 4!*(44/√4)\n",
      " 529 = (4!-(4/4))^√4\n",
      " 530 = ⌊((.4+4.4)^4)⌋\n",
      " 531 = ⌈((.4+4.4)^4)⌉\n",
      " 532 = (4!*4!)-44\n",
      " 533 = ⌊(4^(√4+(4*√.4)))⌋\n",
      " 534 = ⌈(4^(√4+(4*√.4)))⌉\n",
      " 535 = ⌊((4!-4)^√4.4)⌋\n",
      " 536 = 4!+(√4*(4^4))\n",
      " 537 = ⌈((4^4)*√4.4)⌉\n",
      " 538 = ⌊(44*(√4!/.4))⌋\n",
      " 539 = ⌈(44*(√4!/.4))⌉\n",
      " 540 = ⌈(√4!*44)⌉/.4\n",
      " 541 = ⌈(4^(√(.4+4!)-.4))⌉\n",
      " 542 = ⌊(4!*(4!-.4))⌋-4!\n",
      " 543 = ⌊(4^(44^.4))⌋\n",
      " 544 = ⌈(4^(44^.4))⌉\n",
      " 545 = ⌊(4^(√4/.44))⌋\n",
      " 546 = ⌈(4^(√4/.44))⌉\n",
      " 547 = 4+⌈(4!*(4!-√√4))⌉\n",
      " 548 = (4!*4!)-(4+4!)\n",
      " 549 = ⌈(4*(√4!*(4+4!)))⌉\n",
      " 550 = (4!*4!)-(√4+4!)\n",
      " 551 = (4!*4!)-(⌈.4⌉+4!)\n",
      " 552 = 4!*(4!-(4/4))\n",
      " 553 = ⌈((.4-4!)^√4)⌉-4\n",
      " 554 = √4+((4!*4!)-4!)\n",
      " 555 = ⌊((4!-.44)^√4)⌋\n",
      " 556 = 4+((4!*4!)-4!)\n",
      " 557 = ⌈(4^(4+(.4^√.4)))⌉\n",
      " 558 = ⌈(.4+((.4-4!)^√4))⌉\n",
      " 559 = ⌊(4!*(4!-(.4^.4)))⌋\n",
      " 560 = (4+4!)*(4!-4)\n",
      " 561 = ⌈(4*(4^(4!^.4)))⌉\n",
      " 562 = ⌊((√4*44)^√√4)⌋\n",
      " 563 = ⌈((√4*44)^√√4)⌉\n",
      " 564 = 4!*(4!-(√4/4))\n",
      " 565 = ⌊(4!*(4!-.44))⌋\n",
      " 566 = (4!*4!)-(4/.4)\n",
      " 567 = ⌊(4^(4+(4^-.4)))⌋\n",
      " 568 = (4!*4!)-(4+4)\n",
      " 569 = (4!*4!)-⌈√44⌉\n",
      " 570 = (4!*4!)-(4+√4)\n",
      " 571 = ⌊(.4^-√(4+44))⌋\n",
      " 572 = (4!^(4-√4))-4\n",
      " 573 = ⌈((4^4)*√⌈4.4⌉)⌉\n",
      " 574 = √4+((4!*4!)-4)\n",
      " 575 = (4!*4!)-(4/4)\n",
      " 576 = 4!^((4+4)/4)\n",
      " 577 = (4/4)+(4!*4!)\n",
      " 578 = 4+((4!*4!)-√4)\n",
      " 579 = ⌈√4.4⌉+(4!*4!)\n",
      " 580 = ((4^4)-4!)/.4\n",
      " 581 = ⌊((4^4)/.44)⌋\n",
      " 582 = ⌈((4^4)/.44)⌉\n",
      " 583 = (4!*4!)+⌈√44⌉\n",
      " 584 = 4+(4+(4!*4!))\n",
      " 585 = ⌊(√44^(4-√.4))⌋\n",
      " 586 = (4/.4)+(4!*4!)\n",
      " 587 = ⌈(4!*(4!+.44))⌉\n",
      " 588 = 4*⌊(4^(4-.4))⌋\n",
      " 589 = ⌈(4*(4^(4-.4)))⌉\n",
      " 590 = ⌊(.4^(4*-(4^.4)))⌋\n",
      " 591 = ⌈(.4^(4*-(4^.4)))⌉\n",
      " 592 = (4*4)+(4!*4!)\n",
      " 593 = ⌈((4.4^4)/√.4)⌉\n",
      " 594 = ⌊((4+√4)^(4!^.4))⌋\n",
      " 595 = ⌊((.4+4!)^(4-√4))⌋\n",
      " 596 = 4!+((4!*4!)-4)\n",
      " 597 = ⌊((4!+.44)^√4)⌋\n",
      " 598 = ⌈((4!+.44)^√4)⌉\n",
      " 599 = 4+⌊((.4+4!)^√4)⌋\n",
      " 600 = 4!/(.44-.4)\n",
      " 601 = (⌈4.4⌉^4)-4!\n",
      " 602 = √4+(4!+(4!*4!))\n",
      " 603 = ⌊((4!+(4^-.4))^√4)⌋\n",
      " 604 = 4+(4!+(4!*4!))\n",
      " 605 = ⌈((4-.4)^⌈4.4⌉)⌉\n",
      " 606 = ⌊(.4^-⌈√44⌉)⌋-4\n",
      " 607 = ⌈(.4^-⌈√44⌉)⌉-4\n",
      " 608 = 4*(4*⌈(4!/√.4)⌉)\n",
      " 609 = ⌊((.4^-⌈√44⌉)-.4)⌋\n",
      " 610 = ⌊(.4/(.4^(4+4)))⌋\n",
      " 611 = ⌈(.4/(.4^(4+4)))⌉\n",
      " 612 = ⌈(4^(4+√.4))⌉-4\n",
      " 613 = ⌊((√.4-.4)^-4.4)⌋\n",
      " 614 = ⌊((.4+√4)*(4^4))⌋\n",
      " 615 = ⌊(4^(√44-√4))⌋\n",
      " 616 = ((4^4)/.4)-4!\n",
      " 617 = √4+⌊(4^(4+√.4))⌋\n",
      " 618 = √4+⌈(4^(4+√.4))⌉\n",
      " 619 = 4+⌊(4^(4+√.4))⌋\n",
      " 620 = 44+(4!*4!)\n",
      " 621 = (⌈4.4⌉^4)-4\n",
      " 622 = (4!*(√4+4!))-√4\n",
      " 623 = (⌈4.4⌉^4)-√4\n",
      " 624 = 4!*⌊(4*√44)⌋\n",
      " 625 = ⌈4.44⌉^4\n",
      " 626 = ⌈.4⌉+(⌈4.4⌉^4)\n",
      " 627 = ⌊(√√4*444)⌋\n",
      " 628 = ⌈(√√4*444)⌉\n",
      " 629 = 4+(⌈4.4⌉^4)\n",
      " 630 = ((4^4)-4)/.4\n",
      " 631 = ⌈(√√4*(4^4.4))⌉\n",
      " 632 = ⌊((4+√4)^(4-.4))⌋\n",
      " 633 = ⌈((4+√4)^(4-.4))⌉\n",
      " 634 = ⌊(4^√4!)⌋-(4^4)\n",
      " 635 = ((4^4)-√4)/.4\n",
      " 636 = ((4^4)/.4)-4\n",
      " 637 = ⌈(4*(4!*√44))⌉\n",
      " 638 = ((4^4)/.4)-√4\n",
      " 639 = ((4^4)-.4)/.4\n",
      " 640 = (4^⌊4.4⌋)/.4\n",
      " 641 = (.4+(4^4))/.4\n",
      " 642 = √4+((4^4)/.4)\n",
      " 643 = ⌊(4!*(4!+√(4+4)))⌋\n",
      " 644 = 4+((4^4)/.4)\n",
      " 645 = (√4+(4^4))/.4\n",
      " 646 = ⌊(4*(4!^(.4*4)))⌋\n",
      " 647 = ⌊(4*(√.4*(4^4)))⌋\n",
      " 648 = 4!*⌈(4*√44)⌉\n",
      " 649 = 4!+(⌈4.4⌉^4)\n",
      " 650 = (4+(4^4))/.4\n",
      " 651 = ⌊(.4^(√(4+4)/-.4))⌋\n",
      " 652 = ((√4+4!)^√4)-4!\n",
      " 653 = ⌈((√4!+(4^4))/.4)⌉\n",
      " 654 = ⌊((4!-√4)^√4.4)⌋\n",
      " 655 = ⌊((4*√(.4*4))^4)⌋\n",
      " 656 = ⌈((4*√(.4*4))^4)⌉\n",
      " 657 = ⌈(4!*(4+(4!-√.4)))⌉\n",
      " 658 = ⌊((√4!+(4/4!))^4)⌋\n",
      " 659 = ⌈((√4!+(4/4!))^4)⌉\n",
      " 660 = 44*⌊(√.4*4!)⌋\n",
      " 661 = ⌊((4^4)*(4-√√4))⌋\n",
      " 662 = ⌈((4^4)*(4-√√4))⌉\n",
      " 663 = ⌈(4!*(4+(4!-.4)))⌉\n",
      " 664 = 4!+((4^4)/.4)\n",
      " 665 = ⌈((⌈4.4⌉^√4!)/4)⌉\n",
      " 666 = ⌊(4^√(44/√4))⌋\n",
      " 667 = ⌈(4^√(44/√4))⌉\n",
      " 668 = (4!*(4+4!))-4\n",
      " 669 = ⌊(4^(4+(.4^.4)))⌋\n",
      " 670 = (4!*(4+4!))-√4\n",
      " 671 = ⌊(4*((.4-4)^4))⌋\n",
      " 672 = 4*(4!*⌈√44⌉)\n",
      " 673 = ⌊((4/.4)^√(4+4))⌋\n",
      " 674 = √4+(4!*(4+4!))\n",
      " 675 = ⌊(√4!^(4+(.4/4)))⌋\n",
      " 676 = (4+√4)!-44\n",
      " 677 = ⌊(4.4^4.4)⌋\n",
      " 678 = ⌈(4.4^4.4)⌉\n",
      " 679 = ⌊(4^((√4*4!)^.4))⌋\n",
      " 680 = 4+((√4+4!)^√4)\n",
      " 681 = ⌊(4!*(4!+4.4))⌋\n",
      " 682 = ⌈(4!*(4!+4.4))⌉\n",
      " 683 = ⌈(4^(4+√(√4/4)))⌉\n",
      " 684 = ⌈((.4+4!)*(4+4!))⌉\n",
      " 685 = ⌊(.4^(4!/(√.4-4)))⌋\n",
      " 686 = ⌊(4^(√4^√⌈4.4⌉))⌋\n",
      " 687 = ⌈(4^(√4^√⌈4.4⌉))⌉\n",
      " 688 = ⌈(√.4*(√4!^4.4))⌉\n",
      " 689 = ⌊((.4^-√44)/√.4)⌋\n",
      " 690 = ⌈((.4^-√44)/√.4)⌉\n",
      " 691 = ⌊((4!-√√4)^√4.4)⌋\n",
      " 692 = (4+√4)!-(4+4!)\n",
      " 693 = ⌈((4-(.4/√4))^√4!)⌉\n",
      " 694 = (4+√4)!-(√4+4!)\n",
      " 695 = (4+√4)!-(⌈.4⌉+4!)\n",
      " 696 = ((4/.4)-4)!-4!\n",
      " 697 = ⌈((.4*(4^4))^√√4)⌉\n",
      " 698 = √4+((4+√4)!-4!)\n",
      " 699 = ⌊((4!/.4)^(.4*4))⌋\n",
      " 700 = (4!+(4^4))/.4\n",
      " 701 = ⌊(⌈√44⌉^(4-√.4))⌋\n",
      " 702 = ⌊(444/√.4)⌋\n",
      " 703 = ⌈(444/√.4)⌉\n",
      " 704 = 4*(4*44)\n",
      " 705 = ⌈((4^4.4)/√.4)⌉\n",
      " 706 = ⌈(⌈(4^4.4)⌉/√.4)⌉\n",
      " 707 = ⌊(4^√(4!-(.4*4)))⌋\n",
      " 708 = (4+√4)!-(4!/√4)\n",
      " 709 = ⌊((4.4^√4!)/√4)⌋\n",
      " 710 = (4+√4)!-(4/.4)\n",
      " 711 = ⌊(.44^-(4+4))⌋\n",
      " 712 = ⌈(.44^-(4+4))⌉\n",
      " 713 = (4+√4)!-⌈√44⌉\n",
      " 714 = (4+√4)!-(4+√4)\n",
      " 715 = (4+√4)!-⌈4.4⌉\n",
      " 716 = ((4/.4)-4)!-4\n",
      " 717 = ⌊((4+4)^√(4/.4))⌋\n",
      " 718 = ((4/.4)-4)!-√4\n",
      " 719 = (4+√4)!-(4/4)\n",
      " 720 = √(44-(4+4))!\n",
      " 721 = (4/4)+(4+√4)!\n",
      " 722 = √4+((4/.4)-4)!\n",
      " 723 = ⌈√4.4⌉+(4+√4)!\n",
      " 724 = 4+((4/.4)-4)!\n",
      " 725 = ⌈((4^4)*√(4+4))⌉\n",
      " 726 = ⌊(44^(4^.4))⌋\n",
      " 727 = ⌈(44^(4^.4))⌉\n",
      " 728 = 4+(4+(4+√4)!)\n",
      " 729 = ⌈(4*√44)⌉^√4\n",
      " 730 = (4/.4)+(4+√4)!\n",
      " 731 = ⌊((4+(√.4^-.4))^4)⌋\n",
      " 732 = ⌊(4^(4+(√4^-.4)))⌋\n",
      " 733 = ⌊((.4*.4)^(.4-4))⌋\n",
      " 734 = ⌈((.4*.4)^(.4-4))⌉\n",
      " 735 = ⌊(4!*(4!+√44))⌋\n",
      " 736 = (4*4)+(4+√4)!\n",
      " 737 = ⌈(4^(√√4*(4-√.4)))⌉\n",
      " 738 = ⌈((4!+√(4/.4))^√4)⌉\n",
      " 739 = (4+√4)!+⌊(4*√4!)⌋\n",
      " 740 = 4!+((4+√4)!-4)\n",
      " 741 = ⌊((√√4-√44)^4)⌋\n",
      " 742 = ⌈((√√4-√44)^4)⌉\n",
      " 743 = ⌈((4^4)*(√4!-√4))⌉\n",
      " 744 = 4!+((4/.4)-4)!\n",
      " 745 = ⌊((4+(√4!/4))^4)⌋\n",
      " 746 = ⌊(4!*(44/√√4))⌋\n",
      " 747 = ⌈(4!*(44/√√4))⌉\n",
      " 748 = √4*⌊(4.4^4)⌋\n",
      " 749 = ⌊(√4*(4.4^4))⌋\n",
      " 750 = √4*⌈(4.4^4)⌉\n",
      " 751 = ⌈(√4!^(4+(4/4!)))⌉\n",
      " 752 = ⌊(√4^(.4*4!))⌋-4!\n",
      " 753 = ⌈(√4^(.4*4!))⌉-4!\n",
      " 754 = ⌊(4.4^√(4!-4))⌋\n",
      " 755 = ⌈(4.4^√(4!-4))⌉\n",
      " 756 = ⌊((√4.4/.4)^4)⌋\n",
      " 757 = ⌈((√4.4/.4)^4)⌉\n",
      " 758 = ⌊((4!-.4)^√4.4)⌋\n",
      " 759 = ⌈((4!-.4)^√4.4)⌉\n",
      " 760 = ((4+4!)^√4)-4!\n",
      " 761 = ⌊(4!^√4.4)⌋-4!\n",
      " 762 = ⌊((.4^-(4+4))/√4)⌋\n",
      " 763 = ⌈(.4^-(4+4))⌉/√4\n",
      " 764 = 44+(4+√4)!\n",
      " 765 = ⌊((4/√.4)^(4-.4))⌋\n",
      " 766 = ⌈((4/√.4)^(4-.4))⌉\n",
      " 767 = ⌈(4^√(4+4!))⌉/√4\n",
      " 768 = 4*(4!*(4+4))\n",
      " 769 = ⌈((4+√(.4*4))^4)⌉\n",
      " 770 = ⌊((44/.4)^√√4)⌋\n",
      " 771 = ⌈((44/.4)^√√4)⌉\n",
      " 772 = ⌈(4^√(4!-(4/4)))⌉\n",
      " 773 = ⌈(√4^(.4*4!))⌉-4\n",
      " 774 = ⌊(.4*(44^√4))⌋\n",
      " 775 = ⌈(.4*(44^√4))⌉\n",
      " 776 = ⌊(4^(.4+4.4))⌋\n",
      " 777 = ⌈(4^(.4+4.4))⌉\n",
      " 778 = ⌊(.4^-(√.4+√44))⌋\n",
      " 779 = ⌊(4!*(√4!*√44))⌋\n",
      " 780 = ((4+4!)^√4)-4\n",
      " 781 = ⌊(4!^√4.4)⌋-4\n",
      " 782 = ((4+4!)^√4)-√4\n",
      " 783 = ⌈((4*4)^(4^√.4))⌉\n",
      " 784 = (4+4!)*(4+4!)\n",
      " 785 = ⌊(.4+(4!^√4.4))⌋\n",
      " 786 = √4+((4+4!)^√4)\n",
      " 787 = √4+⌊(4!^√4.4)⌋\n",
      " 788 = 4+((4+4!)^√4)\n",
      " 789 = 4+⌊(4!^√4.4)⌋\n",
      " 790 = 4+⌈(4!^√4.4)⌉\n",
      " 791 = ⌊(4!^(√4+(.4/4)))⌋\n",
      " 792 = 4+⌊((.4+√4!)^4)⌋\n",
      " 793 = ⌊(4^(4+(4/√4!)))⌋\n",
      " 794 = ⌈(4^(4+(4/√4!)))⌉\n",
      " 795 = ⌊(√44*⌈4.4⌉!)⌋\n",
      " 796 = ⌈(√44*⌈4.4⌉!)⌉\n",
      " 797 = ⌈(4!*((.4+√4)^4))⌉\n",
      " 798 = ⌊(4!^(4-√(4-.4)))⌋\n",
      " 799 = ⌈(4!^(4-√(4-.4)))⌉\n",
      " 800 = ((4/√.4)^4)/√4\n",
      " 801 = ⌈((4+(√4^.4))^4)⌉\n",
      " 802 = ⌊((4-(√4/4!))^√4!)⌋\n",
      " 803 = ⌊(√44^(√√4/.4))⌋\n",
      " 804 = ⌈(√44^(√√4/.4))⌉\n",
      " 805 = ⌈((4+√4)!/√(.4+.4))⌉\n",
      " 806 = ⌊((4!+4.4)^√4)⌋\n",
      " 807 = ⌈((4!+4.4)^√4)⌉\n",
      " 808 = 4!+((4+4!)^√4)\n",
      " 809 = ⌊((4^4)*√(4/.4))⌋\n",
      " 810 = ⌈((4^4)*√(4/.4))⌉\n",
      " 811 = ⌊(4^(4+(√.4^.4)))⌋\n",
      " 812 = ⌊((√4!+.44)^4)⌋\n",
      " 813 = ⌈((√4!+.44)^4)⌉\n",
      " 814 = ⌈((.4+4!)^√4.4)⌉\n",
      " 815 = ⌈(4!*((4!/√.4)-4))⌉\n",
      " 816 = 4!*(4!+(4/.4))\n",
      " 817 = ⌊(4^√(4!-.4))⌋-4!\n",
      " 818 = 4+⌊(4!*(4!*√√4))⌋\n",
      " 819 = ⌊(√.4*((4+√4)^4))⌋\n",
      " 820 = ⌈(√.4*((4+√4)^4))⌉\n",
      " 821 = ⌊(.4*(4!^(.4+√4)))⌋\n",
      " 822 = ⌊(√4!*((.4-4)^4))⌋\n",
      " 823 = ⌈(√4!*((.4-4)^4))⌉\n",
      " 824 = ⌊((4-(4^-√4))^√4!)⌋\n",
      " 825 = ⌈((4-(4^-√4))^√4!)⌉\n",
      " 826 = ⌈√44⌉*⌈(4!*√4!)⌉\n",
      " 827 = ⌊((√4+√4!)*⌈4.4⌉!)⌋\n",
      " 828 = ⌊(4!*(√√4*(.4+4!)))⌋\n",
      " 829 = ⌊(4^√(4!-(√4/4)))⌋\n",
      " 830 = ⌊((4+(√4-√.4))^4)⌋\n",
      " 831 = ⌈((4+(√4-√.4))^4)⌉\n",
      " 832 = (4^4)+(4!*4!)\n",
      " 833 = ⌊(√4!^(4+(√.4-.4)))⌋\n",
      " 834 = ⌊((.4*√4!)^(4/.4))⌋\n",
      " 835 = ⌊((4+√√4)^4)⌋-4!\n",
      " 836 = 44*⌊(4*√4!)⌋\n",
      " 837 = ⌈(((4+4)^4)/√4!)⌉\n",
      " 838 = ⌈(4^√(4!-.4))⌉-4\n",
      " 839 = ⌊((√√4-(.4*4))^-4)⌋\n",
      " 840 = 4*⌊(44^√√4)⌋\n",
      " 841 = (4!+⌈4.4⌉)^√4\n",
      " 842 = ⌈(4!*((.4^-4)-4))⌉\n",
      " 843 = ⌊(4*(44^√√4))⌋\n",
      " 844 = 4*⌈(44^√√4)⌉\n",
      " 845 = 4+⌊(4^√(4!-.4))⌋\n",
      " 846 = ⌊(4^√4!)⌋-44\n",
      " 847 = ⌈(4^√4!)⌉-44\n",
      " 848 = ⌊(√√4*(4!+(4!*4!)))⌋\n",
      " 849 = ⌊((√4!+(√4/4))^4)⌋\n",
      " 850 = ⌊((4+√.4)^4.4)⌋\n",
      " 851 = ⌈((4+√.4)^4.4)⌉\n",
      " 852 = 4*⌊(4!*(4+√4!))⌋\n",
      " 853 = ⌈((4^√√4)*⌈4.4⌉!)⌉\n",
      " 854 = ⌊(.4^(√.4-(4+4)))⌋\n",
      " 855 = ⌊((4+√√4)^4)⌋-4\n",
      " 856 = ⌈((4+√√4)^4)⌉-4\n",
      " 857 = ⌊(4^(.4+√(4!-4)))⌋\n",
      " 858 = ⌊(44^(.4^-√.4))⌋\n",
      " 859 = ⌊((4+√(4-√4))^4)⌋\n",
      " 860 = 4*⌊(√4!*44)⌋\n",
      " 861 = √4+⌊((4+√√4)^4)⌋\n",
      " 862 = ⌊(4*(√4!*44))⌋\n",
      " 863 = ⌈(4*(√4!*44))⌉\n",
      " 864 = 4*⌈(√4!*44)⌉\n",
      " 865 = ⌈(4!*(4^(4-√√4)))⌉\n",
      " 866 = 4!+⌈(4^√(4!-.4))⌉\n",
      " 867 = ⌊(√4^(.4*(.4+4!)))⌋\n",
      " 868 = ⌈(√4^(.4*(.4+4!)))⌉\n",
      " 869 = ⌊((.4^-(4+√4!))/4)⌋\n",
      " 870 = ⌊(√4^((.4^-4)/4))⌋\n",
      " 871 = ⌈(√4^((.4^-4)/4))⌉\n",
      " 872 = ⌊(√4/(.4^√44))⌋\n",
      " 873 = ⌈(√4/(.4^√44))⌉\n",
      " 874 = ⌊(4!^(√44^.4))⌋\n",
      " 875 = ⌈(4!^(√44^.4))⌉\n",
      " 876 = 4+⌈(⌈4.4⌉!^√√4)⌉\n",
      " 877 = ⌊((4+(.4^-.4))^4)⌋\n",
      " 878 = ⌈((4+(.4^-.4))^4)⌉\n",
      " 879 = ⌈((4-.4)^√(4+4!))⌉\n",
      " 880 = 44*(4!-4)\n",
      " 881 = ⌊(4^(√(4+4!)-.4))⌋\n",
      " 882 = ⌊(4^√4!)⌋-(4+4)\n",
      " 883 = ⌈(4^√4!)⌉-(4+4)\n",
      " 884 = ⌈((4^√4!)-√44)⌉\n",
      " 885 = ⌊((4!/4.4)^4)⌋\n",
      " 886 = ⌈((4!/4.4)^4)⌉\n",
      " 887 = ⌈(.4+(4^√4!))⌉-4\n",
      " 888 = √4*444\n",
      " 889 = ⌊((4^√4!)-.44)⌋\n",
      " 890 = √4*⌊(4^4.4)⌋\n",
      " 891 = ⌊(√4*(4^4.4))⌋\n",
      " 892 = √4*⌈(4^4.4)⌉\n",
      " 893 = ⌈((4^√4!)+√4.4)⌉\n",
      " 894 = ⌊(4.4+(4^√4!))⌋\n",
      " 895 = ⌈(4.4+(4^√4!))⌉\n",
      " 896 = ⌊((4^√4!)+√44)⌋\n",
      " 897 = ⌈((4^√4!)+√44)⌉\n",
      " 898 = 4+(4+⌊(4^√4!)⌋)\n",
      " 899 = 4+(4+⌈(4^√4!)⌉)\n",
      " 900 = ((4!/.4)^√4)/4\n",
      " 901 = ⌊(4!^(.4+(4^.4)))⌋\n",
      " 902 = ⌈(4!^(.4+(4^.4)))⌉\n",
      " 903 = ⌈(4^√(4!+(.4/4)))⌉\n",
      " 904 = ⌊(((4!*4!)-4)/√.4)⌋\n",
      " 905 = ⌊(√√4*(4^4))⌋/.4\n",
      " 906 = (4*4)+⌊(4^√4!)⌋\n",
      " 907 = (4*4)+⌈(4^√4!)⌉\n",
      " 908 = ⌊(√44^(4-.4))⌋\n",
      " 909 = ⌈(√44^(4-.4))⌉\n",
      " 910 = 4!+(⌊(4^√4!)⌋-4)\n",
      " 911 = 4!+(⌈(4^√4!)⌉-4)\n",
      " 912 = ⌊((4^4)*(4!^.4))⌋\n",
      " 913 = ⌈((4^4)*(4!^.4))⌉\n",
      " 914 = ⌈(4!/(.4^4))⌉-4!\n",
      " 915 = ⌊(((√4-4!)/4)^4)⌋\n",
      " 916 = ⌈(((√4-4!)/4)^4)⌉\n",
      " 917 = ⌈(((4+√4)^4)/√√4)⌉\n",
      " 918 = 4+(4!+⌊(4^√4!)⌋)\n",
      " 919 = 4+(4!+⌈(4^√4!)⌉)\n",
      " 920 = 4*⌊(.4*(4!*4!))⌋\n",
      " 921 = ⌊((4-.4)*(4^4))⌋\n",
      " 922 = ⌈((4-.4)*(4^4))⌉\n",
      " 923 = ⌈(4^(√4!+(.4^4)))⌉\n",
      " 924 = 4*⌈(.4*(4!*4!))⌉\n",
      " 925 = ⌈(4*((⌈.4⌉-√4!)^4))⌉\n",
      " 926 = ⌊((4!^(4-√√4))/4)⌋\n",
      " 927 = ⌊(4!*((.4^-4)-.4))⌋\n",
      " 928 = 4*((4^4)-4!)\n",
      " 929 = ⌊(4^(.4^-(4^.4)))⌋\n",
      " 930 = ⌈(4^(.4^-(4^.4)))⌉\n",
      " 931 = ⌈(.4^-4)⌉+⌈(4^√4!)⌉\n",
      " 932 = (4!*⌊(.4^-4)⌋)-4\n",
      " 933 = ⌊(4!/(.4^4))⌋-4\n",
      " 934 = 44+⌊(4^√4!)⌋\n",
      " 935 = ⌊(4.4^4)⌋/.4\n",
      " 936 = 4!*⌊(44-√4!)⌋\n",
      " 937 = ⌊((4.4^4)/.4)⌋\n",
      " 938 = ⌈((4.4^4)/.4)⌉\n",
      " 939 = ⌈(4!*(44-√4!))⌉\n",
      " 940 = 4+(4!*⌊(.4^-4)⌋)\n",
      " 941 = 4+⌊(4!/(.4^4))⌋\n",
      " 942 = 4+⌈(4!/(.4^4))⌉\n",
      " 943 = ⌈(.4+(4^√(.4+4!)))⌉\n",
      " 944 = 4*⌈(4!*√(4*4!))⌉\n",
      " 945 = 4+⌊(4^√(.4+4!))⌋\n",
      " 946 = 4+⌈(4^√(.4+4!))⌉\n",
      " 947 = ⌊(4!*(.4+(.4^-4)))⌋\n",
      " 948 = ⌊((4+√(.4+√4))^4)⌋\n",
      " 949 = ⌈((4+√(.4+√4))^4)⌉\n",
      " 950 = ⌊(4!*(√√4*(4+4!)))⌋\n",
      " 951 = ⌈(4!*(√√4*(4+4!)))⌉\n",
      " 952 = (4+4!)*⌈(4!*√√4)⌉\n",
      " 953 = ⌊((.4+4!)/(.4^4))⌋\n",
      " 954 = ⌈((.4+4!)/(.4^4))⌉\n",
      " 955 = ⌊(4^√(4!+(√4/4)))⌋\n",
      " 956 = ⌊(4.4^(4+√.4))⌋\n",
      " 957 = ⌈(4.4^(4+√.4))⌉\n",
      " 958 = ⌊(44^(.4+√√4))⌋\n",
      " 959 = ⌈(44^(.4+√√4))⌉\n",
      " 960 = 4!*(44-4)\n",
      " 961 = (4!+⌈√44⌉)^√4\n",
      " 962 = 4!+⌈(4!/(.4^4))⌉\n",
      " 963 = ⌈((√.4+4!)/(.4^4))⌉\n",
      " 964 = 4+(4!*⌈(.4^-4)⌉)\n",
      " 965 = ⌊(√.4/(.4^(4+4)))⌋\n",
      " 966 = ⌈(√.4/(.4^(4+4)))⌉\n",
      " 967 = ⌊(.4^-(.4+(4^√√4)))⌋\n",
      " 968 = 44*(4!-√4)\n",
      " 969 = ⌈((4!*(.4-√.4))^4)⌉\n",
      " 970 = ⌊((4+(√.4/.4))^4)⌋\n",
      " 971 = ⌈((4+(√.4/.4))^4)⌉\n",
      " 972 = ⌈(.4^-(√.4^-4.4))⌉\n",
      " 973 = ⌊((√√4-⌈√44⌉)^4)⌋\n",
      " 974 = ⌈((√√4-⌈√44⌉)^4)⌉\n",
      " 975 = ⌊(4!^(.4*(4+√√4)))⌋\n",
      " 976 = (4^4)+(4+√4)!\n",
      " 977 = ⌈(4/(.4^(4+√4)))⌉\n",
      " 978 = ⌊(4!^(√4+(4/4!)))⌋\n",
      " 979 = ⌈(4!^(√4+(4/4!)))⌉\n",
      " 980 = 4*⌈(.4^-(4+√4))⌉\n",
      " 981 = ⌈(((4+√√4)^√4!)/4)⌉\n",
      " 982 = ⌊((4+(.4/√4!))^√4!)⌋\n",
      " 983 = ⌊((4+(.4*4))^4)⌋\n",
      " 984 = ⌈((4+(.4*4))^4)⌉\n",
      " 985 = ⌊(√4*(4^√(4!-4)))⌋\n",
      " 986 = (4*4!)+⌊(4^√4!)⌋\n",
      " 987 = (4*4!)+⌈(4^√4!)⌉\n",
      " 988 = ⌊((⌈4.4⌉^4)/√.4)⌋\n",
      " 989 = ⌊(√(4+4)^√44)⌋\n",
      " 990 = ⌈(√(4+4)^√44)⌉\n",
      " 991 = ⌈(√(4!-⌈.4⌉)^4.4)⌉\n",
      " 992 = ⌊((4!+√√4)/(.4^4))⌋\n",
      " 993 = ⌊(44*(4!-√√4))⌋\n",
      " 994 = ⌈(44*(4!-√√4))⌉\n",
      " 995 = ⌊(4^√(4!+(.4+.4)))⌋\n",
      " 996 = ⌈(4^√(4!+(.4+.4)))⌉\n",
      " 997 = ⌈(4^((.4+4!)/√4!))⌉\n",
      " 998 = ⌊(√4^(√√4^√44))⌋\n",
      " 999 = ⌈(√4^(√√4^√44))⌉\n",
      "1000 = (4*(4^4))-4!\n",
      "1001 = ⌊((√4+√4.4)^√4!)⌋\n",
      "1002 = ⌊(4!*(4!*(4^.4)))⌋\n",
      "1003 = ⌈(4!*(4!*(4^.4)))⌉\n",
      "1004 = 4*⌊((4^4)-√4!)⌋\n",
      "1005 = ⌈(4*((4^4)-√4!))⌉\n",
      "1006 = ⌊((√.4+⌈4.4⌉)^4)⌋\n",
      "1007 = ⌊((⌈.4⌉-√44)^4)⌋\n",
      "1008 = 4*((4^4)-4)\n",
      "1009 = ⌈(√4!^((4^.4)/.4))⌉\n",
      "1010 = ⌊((4^4)/√.4)⌋/.4\n",
      "1011 = ⌊(4*(4!^(4^.4)))⌋\n",
      "1012 = 44*(4!-⌈.4⌉)\n",
      "1013 = ⌊(4!^(⌈√44⌉^.4))⌋\n",
      "1014 = (√4+4!)*⌊(.4^-4)⌋\n",
      "1015 = ⌊((√4+4!)/(.4^4))⌋\n",
      "1016 = 4*((4^4)-√4)\n",
      "1017 = ⌈(((4!-√√4)/4)^4)⌉\n",
      "1018 = ⌊(4*((4^4)-√√4))⌋\n",
      "1019 = ⌈(4*((4^4)-√√4))⌉\n",
      "1020 = (4*(4^4))-4\n",
      "1021 = ⌊(4*((4^4)-√.4))⌋\n",
      "1022 = (4*(4^4))-√4\n",
      "1023 = (4*(4^4))-⌈.4⌉\n",
      "1024 = 4^⌈4.44⌉\n",
      "1025 = ⌈.4⌉+(4*(4^4))\n",
      "1026 = √4+(4*(4^4))\n",
      "1027 = ⌈(4*(√.4+(4^4)))⌉\n",
      "1028 = 4+(4*(4^4))\n",
      "1029 = ⌈(44*(4!-√.4))⌉\n",
      "1030 = ⌈(4*(√√4+(4^4)))⌉\n",
      "1031 = ⌈(⌈√44⌉^(4!^.4))⌉\n",
      "1032 = (4!*44)-4!\n",
      "1033 = ⌊(4!*(4+(.4^-4)))⌋\n",
      "1034 = ⌈(4!*(4+(.4^-4)))⌉\n",
      "1035 = ⌈(4!*(4!+(4!-√4!)))⌉\n",
      "1036 = (4+4!)*⌊(4!/√.4)⌋\n",
      "1037 = ⌊(4!^(4^√.4))⌋/√4\n",
      "1038 = ⌊(44*(4!-.4))⌋\n",
      "1039 = ⌈(44*(4!-.4))⌉\n",
      "1040 = 4*(4+(4^4))\n",
      "1041 = ⌈(4!*(44-√.4))⌉\n",
      "1042 = ⌊((.4*.44)^-4)⌋\n",
      "1043 = ⌈((.4*.44)^-4)⌉\n",
      "1044 = 4*⌈(√4!+(4^4))⌉\n",
      "1045 = ⌈(4^(4+(√√4-.4)))⌉\n",
      "1046 = ⌊(4!*(44-.4))⌋\n",
      "1047 = ⌈(4!*(44-.4))⌉\n",
      "1048 = 4!+(4*(4^4))\n",
      "1049 = ⌈(√(4!-.4)^4.4)⌉\n",
      "1050 = ⌈(((4-.4)/√.4)^4)⌉\n",
      "1051 = ⌊((4!*44)-√4!)⌋\n",
      "1052 = (4!*44)-4\n",
      "1053 = ⌊(√4!*⌊(√4!*44)⌋)⌋\n",
      "1054 = (4!*44)-√4\n",
      "1055 = (4!*44)-⌈.4⌉\n",
      "1056 = 4!*⌊44.4⌋\n",
      "1057 = ⌈.4⌉+(4!*44)\n",
      "1058 = √4+(4!*44)\n",
      "1059 = ⌊(4^((4*√√4)-√.4))⌋\n",
      "1060 = 4+(4!*44)\n",
      "1061 = ⌈(√4!+(4!*44))⌉\n",
      "1062 = ⌊(4!*((4+4!)/√.4))⌋\n",
      "1063 = ⌊(√4!^4.4)⌋-4!\n",
      "1064 = ⌈(√4!^4.4)⌉-4!\n",
      "1065 = ⌊(4!*44.4)⌋\n",
      "1066 = ⌈(4!*44.4)⌉\n",
      "1067 = ⌊(((4+4!)/√4!)^4)⌋\n",
      "1068 = ⌈(((4+4!)/√4!)^4)⌉\n",
      "1069 = ⌈(4!/(√4*(.4^√4!)))⌉\n",
      "1070 = ⌈(4^(√.4+√4!))⌉/√4\n",
      "1071 = ⌊(4^(√.4+4.4))⌋\n",
      "1072 = ⌈(4^(√.4+4.4))⌉\n",
      "1073 = ⌊(44*(.4+4!))⌋\n",
      "1074 = ⌈(44*(.4+4!))⌉\n",
      "1075 = ⌈((4!^(√.4+√4))/4)⌉\n",
      "1076 = ⌊((4+(√.4/4))^√4!)⌋\n",
      "1077 = ⌈((4+(√.4/4))^√4!)⌉\n",
      "1078 = ⌊((.4^-(4+4))/√√4)⌋\n",
      "1079 = ⌊((4+√(4-⌈.4⌉))^4)⌋\n",
      "1080 = 4!*⌈44.4⌉\n",
      "1081 = ⌊((4+√4)^(√4!-⌈.4⌉))⌋\n",
      "1082 = ⌊((.4-(4^-.4))^-4)⌋\n",
      "1083 = ⌊(44*(√.4+4!))⌋\n",
      "1084 = ⌈(44*(√.4+4!))⌉\n",
      "1085 = ⌊((4+4!)^√4.4)⌋\n",
      "1086 = ⌊((4+(4^.4))^4)⌋\n",
      "1087 = ⌈((4+(4^.4))^4)⌉\n",
      "1088 = ⌈(4!^(4.4/√4))⌉\n",
      "1089 = ⌊(4!*(√√4+44))⌋\n",
      "1090 = ⌈(4!*(√√4+44))⌉\n",
      "1091 = 4+⌊(√4!^4.4)⌋\n",
      "1092 = 4+⌈(√4!^4.4)⌉\n",
      "1093 = ⌊((4+4!)/(.4^4))⌋\n",
      "1094 = ⌈((4+4!)/(.4^4))⌉\n",
      "1095 = ⌊(⌈(.4^-4)⌉^√(4-.4))⌋\n",
      "1096 = ⌈(⌈(.4^-4)⌉^√(4-.4))⌉\n",
      "1097 = ⌊(.4^(.4*(√4!-4!)))⌋\n",
      "1098 = ⌈(.4^(.4*(√4!-4!)))⌉\n",
      "1099 = ⌊((4+4)^(4-√.4))⌋\n",
      "1100 = 44*(⌈.4⌉+4!)\n",
      "1101 = ⌈((.4+√4)^(4+4))⌉\n",
      "1102 = ⌊(⌈√44⌉^(4-.4))⌋\n",
      "1103 = ⌈(⌈√44⌉^(4-.4))⌉\n",
      "1104 = 4!*(√4+44)\n",
      "1105 = ⌈(4!^(4/(.4+√√4)))⌉\n",
      "1106 = ⌊(((4+4)^√4!)/4!)⌋\n",
      "1107 = ⌈(((4+4)^√4!)/4!)⌉\n",
      "1108 = ⌊(4^(√4!+(√.4/4)))⌋\n",
      "1109 = ⌊((4/(.4^.4))^4)⌋\n",
      "1110 = 444/.4\n",
      "1111 = 4!+⌊(√4!^4.4)⌋\n",
      "1112 = ⌊(4^(4*√(.4*4)))⌋\n",
      "1113 = ⌈(4^(4*√(.4*4)))⌉\n",
      "1114 = ⌊((4^4.4)/.4)⌋\n",
      "1115 = ⌈(4^4.4)⌉/.4\n",
      "1116 = ⌈((4^4)*√⌊(4*√4!)⌋)⌉\n",
      "1117 = ⌈((√4^√.4)*(4+√4)!)⌉\n",
      "1118 = ⌊(44*(4!+√√4))⌋\n",
      "1119 = ⌈(44*(4!+√√4))⌉\n",
      "1120 = 4*(4!+(4^4))\n",
      "1121 = ⌈((4+(.4^-√.4))^4)⌉\n",
      "1122 = ⌈(4^(√4!+(4/4!)))⌉\n",
      "1123 = ⌈((√4*4!)^(.4+√√4))⌉\n",
      "1124 = ⌊(√(.4*44)^√4!)⌋\n",
      "1125 = ⌈(√(.4*44)^√4!)⌉\n",
      "1126 = ⌊(4.4*(4^4))⌋\n",
      "1127 = ⌈(4.4*(4^4))⌉\n",
      "1128 = ⌈(√(.4+4!)^4.4)⌉\n",
      "1129 = ⌈((4!/√4)^√(4+4))⌉\n",
      "1130 = ⌊((4-√(4*4!))^4)⌋\n",
      "1131 = ⌈((4-√(4*4!))^4)⌉\n",
      "1132 = √4*⌊(4!*(4!-.4))⌋\n",
      "1133 = ⌈(√4*(4!*(4!-.4)))⌉\n",
      "1134 = √4*⌈(4!*(4!-.4))⌉\n",
      "1135 = ⌈((4+√4)!/√.4)⌉-4\n",
      "1136 = ⌊(√4!*((4^4)-4!))⌋\n",
      "1137 = ⌈(√4!*((4^4)-4!))⌉\n",
      "1138 = ⌊(((4/.4)-4)!/√.4)⌋\n",
      "1139 = ⌈(((4/.4)-4)!/√.4)⌉\n",
      "1140 = 4!*(⌊(4*√4!)⌋/.4)\n",
      "1141 = ⌈(4!^(4-(.4^-√.4)))⌉\n",
      "1142 = ⌊((√√4+4.4)^4)⌋\n",
      "1143 = ⌈((√√4+4.4)^4)⌉\n",
      "1144 = 44*(√4+4!)\n",
      "1145 = ⌈((4^4)*√(4!-4))⌉\n",
      "1146 = (4^4)+⌊(4^√4!)⌋\n",
      "1147 = (4^4)+⌈(4^√4!)⌉\n",
      "1148 = (√4*(4!*4!))-4\n",
      "1149 = ⌈(4!^(4^(4^-.4)))⌉\n",
      "1150 = (√4*(4!*4!))-√4\n",
      "1151 = ⌊(((4+√.4)^4)/.4)⌋\n",
      "1152 = 4!*(4+44)\n",
      "1153 = ⌈.4⌉+(√4*(4!*4!))\n",
      "1154 = √4+(√4*(4!*4!))\n",
      "1155 = ⌈(4*(√4!^(4!^.4)))⌉\n",
      "1156 = 4+(√4*(4!*4!))\n",
      "1157 = ⌈(√4!+(√4*(4!*4!)))⌉\n",
      "1158 = ⌊(√4!^4.44)⌋\n",
      "1159 = ⌈(√4!^4.44)⌉\n",
      "1160 = √4*(4+(4!*4!))\n",
      "1161 = ⌊(4^(√√4*(4-.4)))⌋\n",
      "1162 = ⌈(4^(√√4*(4-.4)))⌉\n",
      "1163 = 4!+⌈((4+√4)!/√.4)⌉\n",
      "1164 = ⌊(((√.4-4!)/4)^4)⌋\n",
      "1165 = ⌈(((√.4-4!)/4)^4)⌉\n",
      "1166 = ⌈((√4^√4!)/(.4^4))⌉\n",
      "1167 = ⌊(4^(√(4/.4)^√√4))⌋\n",
      "1168 = 4*⌈(4!^(.4^-√.4))⌉\n",
      "1169 = ⌈(⌈(4!+√4!)⌉^√4.4)⌉\n",
      "1170 = ⌊(4^√(√4+4!))⌋-4\n",
      "1171 = ⌈(4^√(√4+4!))⌉-4\n",
      "1172 = ⌈((.4-(.4^-√4))^4)⌉\n",
      "1173 = ⌊(4!*(√4!+44))⌋\n",
      "1174 = ⌈(4!*(√4!+44))⌉\n",
      "1175 = ⌈(4^√⌊(4*√44)⌋)⌉\n",
      "1176 = 4!*⌈(√4!+44)⌉\n",
      "1177 = ⌊(4^((4/.4)-√4!))⌋\n",
      "1178 = ⌈(4^((4/.4)-√4!))⌉\n",
      "1179 = 4+⌈(4^√(√4+4!))⌉\n",
      "1180 = 4*(⌈(4!*√4!)⌉/.4)\n",
      "1181 = ⌊(4^((4^√√4)-√4))⌋\n",
      "1182 = ⌈(4^((4^√√4)-√4))⌉\n",
      "1183 = ⌊(4^(√.4+√(4!-4)))⌋\n",
      "1184 = ⌈(4^(√.4+√(4!-4)))⌉\n",
      "1185 = ⌊((4^4)*(4+√.4))⌋\n",
      "1186 = ⌈((4^4)*(4+√.4))⌉\n",
      "1187 = ⌊(√(√4+(4*4))^√4!)⌋\n",
      "1188 = ⌈(√(√4+(4*4))^√4!)⌉\n",
      "1189 = ⌊(⌈4.4⌉^4.4)⌋\n",
      "1190 = ⌈(⌈4.4⌉^4.4)⌉\n",
      "1191 = ⌈(√4*((.4+4!)^√4))⌉\n",
      "1192 = √4*⌈((.4+4!)^√4)⌉\n",
      "1193 = ⌊((√4^(4+√4!))/.4)⌋\n",
      "1194 = ⌊(√4!^(√4!-.44))⌋\n",
      "1195 = ⌈(√4!^(√4!-.44))⌉\n",
      "1196 = ⌊(√4!/(.4^(4+√4)))⌋\n",
      "1197 = ⌈(√4!/(.4^(4+√4)))⌉\n",
      "1198 = ⌊((4!/(.4^.4))^√4)⌋\n",
      "1199 = ⌈((4!/(.4^.4))^√4)⌉\n",
      "1200 = 4*(⌈4.4⌉!/.4)\n",
      "1201 = ⌈((⌈√44⌉^4)/√4)⌉\n",
      "1202 = ⌊((4+(√4!^.4))^4)⌋\n",
      "1203 = ⌈((4+(√4!^.4))^4)⌉\n",
      "1204 = ⌈(4^(4/(√√4-√.4)))⌉\n",
      "1205 = ⌊(4!^(√.4+(.4*4)))⌋\n",
      "1206 = ⌈(4!^(√.4+(.4*4)))⌉\n",
      "1207 = ⌈((⌈.4⌉+√4!)^4)⌉-4\n",
      "1208 = ⌊(4!*(4!*√4.4))⌋\n",
      "1209 = ⌊((4+√(4-.4))^4)⌋\n",
      "1210 = ⌈((4+√(4-.4))^4)⌉\n",
      "1211 = ⌊(((.4-4!)/4)^4)⌋\n",
      "1212 = ⌈(((.4-4!)/4)^4)⌉\n",
      "1213 = 4+⌊(.4^-√(4!/.4))⌋\n",
      "1214 = ⌊((4+√.4)^(4+√.4))⌋\n",
      "1215 = ⌊(4!^√⌈4.4⌉)⌋-4\n",
      "1216 = ⌈(4!^√⌈4.4⌉)⌉-4\n",
      "1217 = ⌊(4!^√⌈4.4⌉)⌋-√4\n",
      "1218 = ⌊(4.4^√(4!-⌈.4⌉))⌋\n",
      "1219 = ⌊(4!^√⌈4.44⌉)⌋\n",
      "1220 = ⌈(4!^√⌈4.44⌉)⌉\n",
      "1221 = ⌈(4*(√4!^(4-.4)))⌉\n",
      "1222 = √4*⌈(.4^-⌈√44⌉)⌉\n",
      "1223 = 4+⌊(4!^√⌈4.4⌉)⌋\n",
      "1224 = ⌊(√.4*(44^√4))⌋\n",
      "1225 = ⌈(√.4*(44^√4))⌉\n",
      "1226 = ⌊(√4.4^(.4*4!))⌋\n",
      "1227 = ⌈(√4.4^(.4*4!))⌉\n",
      "1228 = ⌈(4/(.4^(.4^-√4)))⌉\n",
      "1229 = ⌊((4-(.4^-4))^√4)⌋\n",
      "1230 = ⌈((4-(.4^-4))^√4)⌉\n",
      "1231 = ⌈(√4*(4^(4+√.4)))⌉\n",
      "1232 = 44*(4+4!)\n",
      "1233 = ⌈((.4-(4/√.4))^4)⌉\n",
      "1234 = ⌊(√4!*((4^4)-4))⌋\n",
      "1235 = ⌈(√4!*((4^4)-4))⌉\n",
      "1236 = ⌊(4!*(√⌈4.4⌉^√4!))⌋\n",
      "1237 = ⌊(4!^(4*(.4^√.4)))⌋\n",
      "1238 = ⌈(4!^(4*(.4^√.4)))⌉\n",
      "1239 = ⌊(((4+4!)^√4)/√.4)⌋\n",
      "1240 = ⌊(.4*(4!^(4*√.4)))⌋\n",
      "1241 = ⌈(.4*(4!^(4*√.4)))⌉\n",
      "1242 = ⌊((4!^√4.4)/√.4)⌋\n",
      "1243 = ⌊((4^4)*√(4!-.4))⌋\n",
      "1244 = ⌈((4^4)*√(4!-.4))⌉\n",
      "1245 = ⌈(√4!*((4^4)-√4))⌉\n",
      "1246 = ⌊(((.4+√4!)^4)/√.4)⌋\n",
      "1247 = ⌊((4!/.4)^(4^.4))⌋\n",
      "1248 = 4!*(4+(√4*4!))\n",
      "1249 = ⌊(4^((4!/.4)^.4))⌋\n",
      "1250 = √4*(⌈4.4⌉^4)\n",
      "1251 = ⌈(√4!*(4^4))⌉-4\n",
      "1252 = ⌊(√4!*((4^4)-.4))⌋\n",
      "1253 = ⌊((4^.4)*(4+√4)!)⌋\n",
      "1254 = ⌊(.4+(√4!*(4^4)))⌋\n",
      "1255 = ⌈(.4+(√4!*(4^4)))⌉\n",
      "1256 = ⌊(√4!*(.4+(4^4)))⌋\n",
      "1257 = ⌈(√4!*(.4+(4^4)))⌉\n",
      "1258 = 4+⌊(√4!*(4^4))⌋\n",
      "1259 = 4+⌈(√4!*(4^4))⌉\n",
      "1260 = ⌈(√4!*(⌈.4⌉+(4^4)))⌉\n",
      "1261 = ⌊((4+(.4*√4!))^4)⌋\n",
      "1262 = ⌈((4+(.4*√4!))^4)⌉\n",
      "1263 = ⌊(√4!*(√4+(4^4)))⌋\n",
      "1264 = ⌊((4^4)*√(.4+4!))⌋\n",
      "1265 = ⌈((4^4)*√(.4+4!))⌉\n",
      "1266 = ⌊((4/(.4^4))^√√4)⌋\n",
      "1267 = ⌊((4*(4+√4!))^√4)⌋\n",
      "1268 = ⌊(44^(√4!^.4))⌋\n",
      "1269 = ⌈(44^(√4!^.4))⌉\n",
      "1270 = ⌈((.4+(.4-√.4))^-4)⌉\n",
      "1271 = ⌊(44*(4!+√4!))⌋\n",
      "1272 = ((4+√4)^4)-4!\n",
      "1273 = ⌊(√4!*(4+(4^4)))⌋\n",
      "1274 = ⌈(√4!*(4+(4^4)))⌉\n",
      "1275 = ⌈(√4!^(4+(√4/4)))⌉\n",
      "1276 = 44*⌈(4!+√4!)⌉\n",
      "1277 = ⌊((.4*4!)^√(4/.4))⌋\n",
      "1278 = 4!+⌊(√4!*(4^4))⌋\n",
      "1279 = 4!+⌈(√4!*(4^4))⌉\n",
      "1280 = (4^4)*⌈4.4⌉\n",
      "1281 = ⌈(((4+√4!)^4)/√4!)⌉\n",
      "1282 = ⌊(4^(√4+√(4/.4)))⌋\n",
      "1283 = ⌈(4^(√4+√(4/.4)))⌉\n",
      "1284 = ⌊((4^√4!)/(.4^.4))⌋\n",
      "1285 = ⌈((4^√4!)/(.4^.4))⌉\n",
      "1286 = ⌈(4^(4/√(⌈.4⌉-.4)))⌉\n",
      "1287 = ⌊(4^(.44^-√4))⌋\n",
      "1288 = ⌈(4^(.44^-√4))⌉\n",
      "1289 = ⌈(√⌈4.4⌉^(4+√4!))⌉\n",
      "1290 = ⌊(((4!^4)/4)^√.4)⌋\n",
      "1291 = ⌊(((4+√4)^4)-√4!)⌋\n",
      "1292 = ((4+√4)^4)-4\n",
      "1293 = ⌈((4+√(.4/4))^√4!)⌉\n",
      "1294 = ((4+√4)^4)-√4\n",
      "1295 = ((4+√4)^4)-⌈.4⌉\n",
      "1296 = ((4/.4)-4)^4\n",
      "1297 = ⌈.4⌉+((4+√4)^4)\n",
      "1298 = √4+((4+√4)^4)\n",
      "1299 = ⌈((4*4)^(4-√√4))⌉\n",
      "1300 = 4+((4+√4)^4)\n",
      "1301 = ⌈(√4!+((4+√4)^4))⌉\n",
      "1302 = ⌊(((4^√.4)/.4)^4)⌋\n",
      "1303 = ⌈(((4^√.4)/.4)^4)⌉\n",
      "1304 = ⌈(√(4+4)^(√4+√4!))⌉\n",
      "1305 = ⌊((4^4)*√(√4+4!))⌋\n",
      "1306 = ⌈((4^4)*√(√4+4!))⌉\n",
      "1307 = ⌈((.4+√√4)*(4+√4)!)⌉\n",
      "1308 = 4*⌊((4!/.4)^√√4)⌋\n",
      "1309 = ⌊(4!*(4!/.44))⌋\n",
      "1310 = ⌈(4!*(4!/.44))⌉\n",
      "1311 = ⌊(4!^(4-(4^.4)))⌋\n",
      "1312 = ⌊(44^√(4-.4))⌋\n",
      "1313 = ⌈(44^√(4-.4))⌉\n",
      "1314 = ⌊(4/(.4^(4/√.4)))⌋\n",
      "1315 = ⌈(4/(.4^(4/√.4)))⌉\n",
      "1316 = ⌈(4^(4!/(4+√.4)))⌉\n",
      "1317 = ⌊(4^(√4!+(.4/√√4)))⌋\n",
      "1318 = ⌈(4^(√4!+(.4/√√4)))⌉\n",
      "1319 = ⌊(√√4/(.4^(4!^√.4)))⌋\n",
      "1320 = 4!+((4+√4)^4)\n",
      "1321 = ⌈(4^(4+√(.4+⌈.4⌉)))⌉\n",
      "1322 = ⌊(4!*((4!/.4)-√4!))⌋\n",
      "1323 = ⌈(4!*((4!/.4)-√4!))⌉\n",
      "1324 = 4*⌊((√.4-√4!)^4)⌋\n",
      "1325 = ⌊((4!-4)^(.4+√4))⌋\n",
      "1326 = ⌈((4!-4)^(.4+√4))⌉\n",
      "1327 = ⌊(4!^(.4*(4*√√4)))⌋\n",
      "1328 = ⌊(((4-.4)^√4!)/.4)⌋\n",
      "1329 = ⌈(((4-.4)^√4!)/.4)⌉\n",
      "1330 = ⌈((4-.4)^√4!)⌉/.4\n",
      "1331 = ⌊((√.4*(4^4))^√√4)⌋\n",
      "1332 = ⌈((√.4*(4^4))^√√4)⌉\n",
      "1333 = ⌊(√4*(4^√(4!-√4)))⌋\n",
      "1334 = √4*⌈(4^√(4!-√4))⌉\n",
      "1335 = ⌊(4!*(4^(√4!-√4)))⌋\n",
      "1336 = ⌊(4.4^√(4!-.4))⌋\n",
      "1337 = ⌈(4.4^√(4!-.4))⌉\n",
      "1338 = ⌊((4!-4)^(4^√.4))⌋\n",
      "1339 = ⌊(4!/(.44^√4!))⌋\n",
      "1340 = ⌈(4!/(.44^√4!))⌉\n",
      "1341 = ⌊(√4/(.4^(4^√√4)))⌋\n",
      "1342 = ⌈(√4/(.4^(4^√√4)))⌉\n",
      "1343 = ⌊(4^√⌈(4*√44)⌉)⌋\n",
      "1344 = 4!*((4!/.4)-4)\n",
      "1345 = ⌊((.4+(4*√√4))^4)⌋\n",
      "1346 = ⌈((.4+(4*√√4))^4)⌉\n",
      "1347 = ⌈(((4^.4)/.4)^√4!)⌉\n",
      "1348 = ⌈((4+(√√4/4))^√4!)⌉\n",
      "1349 = ⌊(4!^(4-√(4-⌈.4⌉)))⌋\n",
      "1350 = ⌈(4!^(4-√(4-⌈.4⌉)))⌉\n",
      "1351 = ⌊(4^(.4*⌈(√4!/.4)⌉))⌋\n",
      "1352 = ⌊(4!/(.4^4.4))⌋\n",
      "1353 = ⌈(4!/(.4^4.4))⌉\n",
      "1354 = ⌊((4^4)*√(4+4!))⌋\n",
      "1355 = ⌈((4^4)*√(4+4!))⌉\n",
      "1356 = ⌊((.4+√4!)*(4^4))⌋\n",
      "1357 = ⌈((.4+√4!)*(4^4))⌉\n",
      "1358 = ⌈(4^(√.4^(.4-4)))⌉\n",
      "1359 = ⌈((.4*(√.4*4!))^4)⌉\n",
      "1360 = ⌈(.4^-√⌊(√√4*44)⌋)⌉\n",
      "1361 = 4+⌈(√⌊(4*√4!)⌋^√4!)⌉\n",
      "1362 = ⌊((4*4!)^(√.4/.4))⌋\n",
      "1363 = ⌈((4*4!)^(√.4/.4))⌉\n",
      "1364 = ⌊((⌊(4!/√.4)⌋^√4)-√4!)⌋\n",
      "1365 = ⌊(√4!^(44^.4))⌋\n",
      "1366 = ⌈(√4!^(44^.4))⌉\n",
      "1367 = ⌈(√(4-.4)*(4+√4)!)⌉\n",
      "1368 = 4!*⌈(.4^-4.4)⌉\n",
      "1369 = ⌈((44^√4)/√√4)⌉\n",
      "1370 = ⌈(4/((.4-√.4)^4))⌉\n",
      "1371 = ⌈(4!^(⌈.4⌉/.44))⌉\n",
      "1372 = 4*⌈((.4-√.4)^-4)⌉\n",
      "1373 = ⌊((√4-(.4^-4))^√4)⌋\n",
      "1374 = ⌈((√4-(.4^-4))^√4)⌉\n",
      "1375 = ⌊(((4^√4!)/4!)^√4)⌋\n",
      "1376 = ⌈(((4^√4!)/4!)^√4)⌉\n",
      "1377 = ⌈((4+√4)!/(√.4^√√4))⌉\n",
      "1378 = ⌊((4^4)*√⌈(4!+√4!)⌉)⌋\n",
      "1379 = ⌊(4^(√4!+√(.4/4)))⌋\n",
      "1380 = ((4!*4!)-4!)/.4\n",
      "1381 = ⌈((√4!^√4!)/(4^.4))⌉\n",
      "1382 = ⌊((4+√4.4)^4)⌋\n",
      "1383 = ⌈((4+√4.4)^4)⌉\n",
      "1384 = ⌊(((.4+4!)/4)^4)⌋\n",
      "1385 = ⌈(((.4+4!)/4)^4)⌉\n",
      "1386 = ⌊((4^4)*(4+√√4))⌋\n",
      "1387 = ⌈((4^4)*(4+√√4))⌉\n",
      "1388 = ⌈(4^(√44-√√4))⌉\n",
      "1389 = ⌈(4!^(√.4*(4-.4)))⌉\n",
      "1390 = ⌊(.4/(.4^(4+√4!)))⌋\n",
      "1391 = ⌈(.4/(.4^(4+√4!)))⌉\n",
      "1392 = 4!*((4!/.4)-√4)\n",
      "1393 = ⌈(((.4-4!)^√4)/.4)⌉\n",
      "1394 = ⌈((√.4+√⌈(√4^√4!)⌉)^4)⌉\n",
      "1395 = ⌊(4.4^√4!)⌋-4!\n",
      "1396 = ⌈(4.4^√4!)⌉-4!\n",
      "1397 = ⌊(4!^(.4^(4-√4!)))⌋\n",
      "1398 = ⌊(4^(4+(√4!/4)))⌋\n",
      "1399 = ⌈(4^(4+(√4!/4)))⌉\n",
      "1400 = ⌈(.4^(√(4/.4)/-.4))⌉\n",
      "1401 = ⌊(((4^√4!)-4)/√.4)⌋\n",
      "1402 = ⌊((4-.4)^(4*√√4))⌋\n",
      "1403 = ⌈((4-.4)^(4*√√4))⌉\n",
      "1404 = ⌈((4^√4!)/√.4)⌉-4\n",
      "1405 = ⌈(4!^(√4+(4!^-.4)))⌉\n",
      "1406 = ⌊((√(4+√4)/.4)^4)⌋\n",
      "1407 = ⌈((√(4+√4)/.4)^4)⌉\n",
      "1408 = ⌈(.4+((4^√4!)/√.4))⌉\n",
      "1409 = ⌈((.4+(4^√4!))/√.4)⌉\n",
      "1410 = ⌊(4!*(4!*√(4+√4)))⌋\n",
      "1411 = ⌈(4!*(4!*√(4+√4)))⌉\n",
      "1412 = 4+⌈((4^√4!)/√.4)⌉\n",
      "1413 = ⌊((4+(4^√4!))/√.4)⌋\n",
      "1414 = ⌈((4+(4^√4!))/√.4)⌉\n",
      "1415 = ⌊(4.4^√4!)⌋-4\n",
      "1416 = ⌈(4.4^√4!)⌉-4\n",
      "1417 = ⌊(4.4^√4!)⌋-√4\n",
      "1418 = ⌈(4.4^√4!)⌉-√4\n",
      "1419 = ⌊((4.4^√4!)-.4)⌋\n",
      "1420 = ⌊(.4+(4.4^√4!))⌋\n",
      "1421 = ⌈(.4+(4.4^√4!))⌉\n",
      "1422 = √4+⌈(4.4^√4!)⌉\n",
      "1423 = 4+⌊(4.4^√4!)⌋\n",
      "1424 = 4+⌈(4.4^√4!)⌉\n",
      "1425 = ⌈(.4*(4*(4^√4!)))⌉\n",
      "1426 = ⌈(.4*(4*⌈(4^√4!)⌉))⌉\n",
      "1427 = ⌊(((4!*4!)-√4!)/.4)⌋\n",
      "1428 = 4*⌈(.4*(4^√4!))⌉\n",
      "1429 = ⌈((.4^-√(√4*4!))/.4)⌉\n",
      "1430 = ((4!*4!)-4)/.4\n",
      "1431 = ⌈(4!*((4!/.4)-.4))⌉\n",
      "1432 = √4*((4+√4)!-4)\n",
      "1433 = ⌈(4*(4*(4!^√√4)))⌉\n",
      "1434 = ⌊(√4!^(4+(4^-.4)))⌋\n",
      "1435 = ((4!*4!)-√4)/.4\n",
      "1436 = (4!*(4!/.4))-4\n",
      "1437 = ⌈(4^(√4.4/.4))⌉\n",
      "1438 = (4!*(4!/.4))-√4\n",
      "1439 = ((4!*4!)-.4)/.4\n",
      "1440 = √4*((4/.4)-4)!\n",
      "1441 = (.4+(4!*4!))/.4\n",
      "1442 = √4+(4!*(4!/.4))\n",
      "1443 = 4!+⌊(4.4^√4!)⌋\n",
      "1444 = 4+(4!*(4!/.4))\n",
      "1445 = (√4+(4!*4!))/.4\n",
      "1446 = ⌈((4+(4^-√.4))^√4!)⌉\n",
      "1447 = ⌈(√(4!-4)^√(4!-.4))⌉\n",
      "1448 = √4*(4+(4+√4)!)\n",
      "1449 = ⌈(4*(√√4*(4^4)))⌉\n",
      "1450 = (4+(4!*4!))/.4\n",
      "1451 = ⌊(⌊(4!^(.4+√4))⌋/√√4)⌋\n",
      "1452 = 44*⌊(4!*√√4)⌋\n",
      "1453 = ⌊((4/.4)^√(4/.4))⌋\n",
      "1454 = ⌈((4/.4)^√(4/.4))⌉\n",
      "1455 = ⌊(4^√(4+(4!-.4)))⌋\n",
      "1456 = ⌈(4^√(4+(4!-.4)))⌉\n",
      "1457 = ⌊(4*(√.4*(4!*4!)))⌋\n",
      "1458 = ⌊((4-√.4)^(4+√4))⌋\n",
      "1459 = ⌈((4-√.4)^(4+√4))⌉\n",
      "1460 = 4*⌈(√.4*(4!*4!))⌉\n",
      "1461 = ⌊(⌈√4.4⌉^√44)⌋\n",
      "1462 = ⌈(⌈√4.4⌉^√44)⌉\n",
      "1463 = ⌊(√(4!-4.4)^√4!)⌋\n",
      "1464 = 4!*((.4+4!)/.4)\n",
      "1465 = ⌈(4!*(.4+4!))⌉/.4\n",
      "1466 = (4!*4!)+⌊(4^√4!)⌋\n",
      "1467 = (4!*4!)+⌈(4^√4!)⌉\n",
      "1468 = 4!+(⌈(4!/√.4)⌉^√4)\n",
      "1469 = ⌊((√4!/.4)*⌈4.4⌉!)⌋\n",
      "1470 = ⌈(√4!*⌈4.4⌉!)⌉/.4\n",
      "1471 = ⌈((.4+(4!/√.4))^√4)⌉\n",
      "1472 = ⌊((4!/(4+√√4))^√4!)⌋\n",
      "1473 = ⌊((√.4-.4)^-⌈4.4⌉)⌋\n",
      "1474 = ⌊((.4*(4*4!))^√4)⌋\n",
      "1475 = ⌈((.4*(4*4!))^√4)⌉\n",
      "1476 = ⌊((√.4-(.4^-4))^√4)⌋\n",
      "1477 = ⌊(4!*((√.4+4!)/.4))⌋\n",
      "1478 = ⌊(4^(4+√(.4*4)))⌋\n",
      "1479 = ⌈(4^(4+√(.4*4)))⌉\n",
      "1480 = 4*⌊(4^(√4!-√.4))⌋\n",
      "1481 = ⌊(4*(4^(√4!-√.4)))⌋\n",
      "1482 = ⌊(4!^((4+4)^.4))⌋\n",
      "1483 = ⌈(4!^((4+4)^.4))⌉\n",
      "1484 = ⌊(4.44^√4!)⌋\n",
      "1485 = ⌈(4.44^√4!)⌉\n",
      "1486 = ⌊(4!*(4!+(4!/√.4)))⌋\n",
      "1487 = ⌈(4!*(4!+(4!/√.4)))⌉\n",
      "1488 = 4!*⌊(√√4*44)⌋\n",
      "1489 = ⌊(.44^-(4+√4!))⌋\n",
      "1490 = ⌈(.44^-(4+√4!))⌉\n",
      "1491 = ⌈(4!^(√4^(√.4^-.4)))⌉\n",
      "1492 = ⌊(4^(.4^-(.4+√√4)))⌋\n",
      "1493 = ⌊(4!*(√√4*44))⌋\n",
      "1494 = ⌈(4!*(√√4*44))⌉\n",
      "1495 = ⌈((.4-(.4^-4))^√4)⌉\n",
      "1496 = 4*⌊(4.4^4)⌋\n",
      "1497 = (⌊(.4^-4)⌋^√4)-4!\n",
      "1498 = ⌊((4*44)^√√4)⌋\n",
      "1499 = ⌊(4*(4.4^4))⌋\n",
      "1500 = 4*⌈(4.4^4)⌉\n",
      "1501 = ⌊(.4^-(4+4))⌋-4!\n",
      "1502 = ⌈(.4^-(4+4))⌉-4!\n",
      "1503 = ⌈((√4!^√4!)/(.4*4))⌉\n",
      "1504 = ⌈(4^((4!^√.4)/√√4))⌉\n",
      "1505 = ⌊(4^(4*(√4^.4)))⌋\n",
      "1506 = ⌈(4^(4*(√4^.4)))⌉\n",
      "1507 = ⌊((.4+√⌈(4!*√√4)⌉)^4)⌋\n",
      "1508 = ⌊(4.4^√(.4+4!))⌋\n",
      "1509 = ⌊((.4-√44)^4)⌋\n",
      "1510 = ⌈((.4-√44)^4)⌉\n",
      "1511 = ⌈(√4.4*(4+√4)!)⌉\n",
      "1512 = 4!*⌈(√√4*44)⌉\n",
      "1513 = ⌈((4+√⌈4.4⌉)^4)⌉\n",
      "1514 = ⌈(4!*(4!+(.4^-4)))⌉\n",
      "1515 = ⌊((√4!-.44)^√4!)⌋\n",
      "1516 = ⌈((√4!-.44)^√4!)⌉\n",
      "1517 = (⌊(.4^-4)⌋^√4)-4\n",
      "1518 = ⌊(√.4*(⌈√44⌉^4))⌋\n",
      "1519 = ⌈(√.4*(⌈√44⌉^4))⌉\n",
      "1520 = ⌊((.4^-(4+4))-√4!)⌋\n",
      "1521 = ⌊(.4^-(4+4))⌋-4\n",
      "1522 = ⌈(.4^-(4+4))⌉-4\n",
      "1523 = ⌊(.4^-(4+4))⌋-√4\n",
      "1524 = ⌈(.4^-(4+4))⌉-√4\n",
      "1525 = ⌊(.4^(4*(√4-4)))⌋\n",
      "1526 = ⌊(√(4+4!)^4.4)⌋\n",
      "1527 = ⌈(√(4+4!)^4.4)⌉\n",
      "1528 = √4+⌈(.4^-(4+4))⌉\n",
      "1529 = 4+⌊(.4^-(4+4))⌋\n",
      "1530 = 4+⌈(.4^-(4+4))⌉\n",
      "1531 = ⌊(4^√(4+4!))⌋-√4\n",
      "1532 = ⌈(4^√(4+4!))⌉-√4\n",
      "1533 = ⌊(4^√(4*⌈√44⌉))⌋\n",
      "1534 = ⌈(4^√(4*⌈√44⌉))⌉\n",
      "1535 = ⌈(.4+(4^√(4+4!)))⌉\n",
      "1536 = 4*(4*(4*4!))\n",
      "1537 = 4+⌊(4^√(4+4!))⌋\n",
      "1538 = 4+⌈(4^√(4+4!))⌉\n",
      "1539 = ⌈(√√4*(√4!^4.4))⌉\n",
      "1540 = ⌈(4^(4+√.4))⌉/.4\n",
      "1541 = 4+⌊(√(4!-4)^√4!)⌋\n",
      "1542 = 4+⌈(√(4!-4)^√4!)⌉\n",
      "1543 = ⌈((√.4-(√4+√4!))^4)⌉\n",
      "1544 = √4*⌈(4^√(4!-⌈.4⌉))⌉\n",
      "1545 = ⌊(4^(.4+√4!))⌋-4\n",
      "1546 = ⌈(4^(.4+√4!))⌉-4\n",
      "1547 = ⌊(4^(.4+√4!))⌋-√4\n",
      "1548 = ⌈(4^(.4+√4!))⌉-√4\n",
      "1549 = 4!+⌊(.4^-(4+4))⌋\n",
      "1550 = 4!+⌈(.4^-(4+4))⌉\n",
      "1551 = ⌈(.4+(4^(.4+√4!)))⌉\n",
      "1552 = √4+⌈(4^(.4+√4!))⌉\n",
      "1553 = 4+⌊(4^(.4+√4!))⌋\n",
      "1554 = 4+⌈(4^(.4+√4!))⌉\n",
      "1555 = ⌈(√4!+(4^(.4+√4!)))⌉\n",
      "1556 = ⌈(4!*((4!-√4!)^√√4))⌉\n",
      "1557 = 4!+⌊(4^√(4+4!))⌋\n",
      "1558 = 4!+⌈(4^√(4+4!))⌉\n",
      "1559 = ⌊((4+4)^(√√4/.4))⌋\n",
      "1560 = 4!*((√4+4!)/.4)\n",
      "1561 = 4!+⌊(√(4!-4)^√4!)⌋\n",
      "1562 = ⌊((⌈4.4⌉^4)/.4)⌋\n",
      "1563 = ⌈((⌈4.4⌉^4)/.4)⌉\n",
      "1564 = ⌊((√.4+(4*√√4))^4)⌋\n",
      "1565 = ⌈((√.4+(4*√√4))^4)⌉\n",
      "1566 = ⌊((⌈.4⌉+√(4+4!))^4)⌋\n",
      "1567 = ⌊(((4+√4!)^4)/4)⌋\n",
      "1568 = √4*((4+4!)^√4)\n",
      "1569 = ⌊(√4!^(4+√.4))⌋-4\n",
      "1570 = √4*⌊(4!^√4.4)⌋\n",
      "1571 = ⌊(√4*(4!^√4.4))⌋\n",
      "1572 = √4*⌈(4!^√4.4)⌉\n",
      "1573 = 4!+⌊(4^(.4+√4!))⌋\n",
      "1574 = 4!+⌈(4^(.4+√4!))⌉\n",
      "1575 = ⌊(√4!^(√44-√4))⌋\n",
      "1576 = ((4/√.4)^4)-4!\n",
      "1577 = 4+⌊(√4!^(4+√.4))⌋\n",
      "1578 = 4+⌈(√4!^(4+√.4))⌉\n",
      "1579 = ⌊((√4!-.4)^√4!)⌋-4\n",
      "1580 = ⌊((4^(√√4+√4!))/4)⌋\n",
      "1581 = ⌈((4^(√√4+√4!))/4)⌉\n",
      "1582 = ⌈((√4!-.4)^√4!)⌉-√4\n",
      "1583 = ⌊((√4+√√4)^(4+√4))⌋\n",
      "1584 = 4!*⌊(4!^(√4^.4))⌋\n",
      "1585 = ⌊((4+(√4/4))^√4!)⌋\n",
      "1586 = ⌈((4+(√4/4))^√4!)⌉\n",
      "1587 = ⌊(√(.4/4!)^(.4-4))⌋\n",
      "1588 = ⌈(√(.4/4!)^(.4-4))⌉\n",
      "1589 = ⌊(((4*4!)^√√4)/.4)⌋\n",
      "1590 = ⌈((4*4!)^√√4)⌉/.4\n",
      "1591 = ⌈(4!*(4!^(√4^.4)))⌉\n",
      "1592 = 4+⌊((√√4+√4!)^4)⌋\n",
      "1593 = ⌊(.4^-(√√4+√44))⌋\n",
      "1594 = ⌊(4^(4+(√4^.4)))⌋\n",
      "1595 = ⌈(4^(4+(√4^.4)))⌉\n",
      "1596 = ((4/√.4)^4)-4\n",
      "1597 = 4!+⌊(√4!^(4+√.4))⌋\n",
      "1598 = ((4/√.4)^4)-√4\n",
      "1599 = ((4/√.4)^4)-⌈.4⌉\n",
      "1600 = (4-44)^√4\n",
      "1601 = ⌈.4⌉+((4/√.4)^4)\n",
      "1602 = √4+((4/√.4)^4)\n",
      "1603 = ⌈(4^(√.4+√(4!-√4)))⌉\n",
      "1604 = 4+((4/√.4)^4)\n",
      "1605 = ⌊((4^(4/√.4))/4)⌋\n",
      "1606 = ⌈(4^(4/√.4))⌉/4\n",
      "1607 = ⌊((√√4-√(4!/.4))^4)⌋\n",
      "1608 = 4!*⌊(4!*√(4+4))⌋\n",
      "1609 = ⌊(√.4*(4^(4*√√4)))⌋\n",
      "1610 = ⌈(√.4*(4^(4*√√4)))⌉\n",
      "1611 = ⌊(√(4+4)^(4^√√4))⌋\n",
      "1612 = ⌈(√(4+4)^(4^√√4))⌉\n",
      "1613 = ⌊(.4^-(√4!+√(4/.4)))⌋\n",
      "1614 = ⌊(4*(4!^(√4!^.4)))⌋\n",
      "1615 = ⌊(4!^((4/√.4)-4))⌋\n",
      "1616 = ⌊(4^√(4!+4.4))⌋\n",
      "1617 = ⌈(4^√(4!+4.4))⌉\n",
      "1618 = ⌈(.44^⌈(.4*-4!)⌉)⌉\n",
      "1619 = ⌊(4*((4^4)/√.4))⌋\n",
      "1620 = 4*⌈((4^4)/√.4)⌉\n",
      "1621 = ⌊(√.4*(√4!^√(.4+4!)))⌋\n",
      "1622 = ⌊((4+√4)^√4!)⌋/4\n",
      "1623 = ⌈(((4+√4)^√4!)/4)⌉\n",
      "1624 = 4!+((4/√.4)^4)\n",
      "1625 = ⌊((4!*√√4)^√4.4)⌋\n",
      "1626 = ⌈((4!*√√4)^√4.4)⌉\n",
      "1627 = ⌈(√4!*⌈((√.4-√4!)^4)⌉)⌉\n",
      "1628 = 44*⌊(4!/√.4)⌋\n",
      "1629 = ⌊(4!*(4!*√(4+4)))⌋\n",
      "1630 = ⌈(4!*(4!*√(4+4)))⌉\n",
      "1631 = ⌊(4^(4+(√.4^-√.4)))⌋\n",
      "1632 = 4!*(4!+44)\n",
      "1633 = ⌈((.4+⌈(.4^-4)⌉)^√4)⌉\n",
      "1634 = ⌊(√(.4+4!)^(4+√.4))⌋\n",
      "1635 = ⌊((4!^√(4+4))/√4!)⌋\n",
      "1636 = ⌊((4+√4)!/.44)⌋\n",
      "1637 = ⌈((4+√4)!/.44)⌉\n",
      "1638 = ⌊(.4*((4+4)^4))⌋\n",
      "1639 = ⌈(.4*((4+4)^4))⌉\n",
      "1640 = 4*⌈((.4-√4!)^4)⌉\n",
      "1641 = ⌈((⌊(.4*4!)⌋^4)/4)⌉\n",
      "1642 = ⌈(√4!^(√(4+4!)-√.4))⌉\n",
      "1643 = ⌊((√.4-⌈√44⌉)^4)⌋\n",
      "1644 = ⌈((√.4-⌈√44⌉)^4)⌉\n",
      "CPU times: user 1min 25s, sys: 512 ms, total: 1min 25s\n",
      "Wall time: 1min 26s\n"
     ]
    }
   ],
   "source": [
    "%time show((4, 4, 4, 4), ops=OPS + \"⌊⌈\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Even More Fives: Five 5s\n",
    "\n",
    "In the [xkcd forum](http://forums.xkcd.com/viewtopic.php?f=14&t=116813&start=280) they took up the problem of **five 5s** and got all the integers up to 298, using the \"double factorial\" and π functions. We can get up to 171, using just the default operators, but with five digits it does take about seven minutes, whereas all the other puzzles with four or three digits (and without floor and ceiling) took less than a minute. I suspect you could go much further using floor and ceiling, but that computation would take even longer, so for now let's stick with our default set of operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can make 0 to 171 with expressions((5, 5, 5, 5, 5), \"+-*/^_√!.$\"). (7,624,387 table entries)\n",
      "\n",
      "   0 = 5*(55-55)\n",
      "   1 = 5^(55-55)\n",
      "   2 = 55/(.5*55)\n",
      "   3 = .5*((55/5)-5)\n",
      "   4 = 5-(55/55)\n",
      "   5 = 5+(55-55)\n",
      "   6 = 5+(55/55)\n",
      "   7 = ((5+55)/5)-5\n",
      "   8 = .5*(5+(55/5))\n",
      "   9 = 5!-(555/5)\n",
      "  10 = 5!-(55+55)\n",
      "  11 = 5*(55/(5*5))\n",
      "  12 = (5/5)+(55/5)\n",
      "  13 = (5+(5+55))/5\n",
      "  14 = (5*5)-(55/5)\n",
      "  15 = 5+(55/5.5)\n",
      "  16 = (55+(5*5))/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",
      "  22 = (55+55)/5\n",
      "  23 = (5+(55/.5))/5\n",
      "  24 = (5-(55/55))!\n",
      "  25 = 55-(5+(5*5))\n",
      "  26 = 5*(5+(5/(5*5)))\n",
      "  27 = 5+(55/(.5*5))\n",
      "  28 = .5*(55+(5/5))\n",
      "  29 = 5+((5*5)-(5/5))\n",
      "  30 = 5*((55/5)-5)\n",
      "  31 = 5+((5/5)+(5*5))\n",
      "  32 = (5+(55/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.5-5)^-5)\n",
      "  38 = .5+(5*(5+(.5*5)))\n",
      "  39 = ((5*5)-5.5)/.5\n",
      "  40 = 55-(5+(5+5))\n",
      "  41 = (5!*.55)-(5*5)\n",
      "  42 = (5+5.5)/(.5*.5)\n",
      "  43 = 55-(5!/(5+5))\n",
      "  44 = 55-(55/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 = 55+((5/5)-5)\n",
      "  52 = 55-(.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",
      "  62 = (55-(5!/5))/.5\n",
      "  63 = .5+(.5*(5*(5*5)))\n",
      "  64 = .5^(5-(55/5))\n",
      "  65 = 5+(55+√(5*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 = 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 = 5+(5+(5!*.55))\n",
      "  77 = 5+(5!*(.5+(.5/5)))\n",
      "  78 = 55+((5!-5)/5)\n",
      "  79 = (5!+(5*55))/5\n",
      "  80 = 5*(5+(55/5))\n",
      "  81 = 5+(.5*(5!+(.5^-5)))\n",
      "  82 = 55+((.5^-5)-5)\n",
      "  83 = (.5*5!)+((5!-5)/5)\n",
      "  84 = 5+(55+(5!/5))\n",
      "  85 = 5+(55+(5*5))\n",
      "  86 = (55/.5)-(5!/5)\n",
      "  87 = (555-5!)/5\n",
      "  88 = 5*(.55/(.5^5))\n",
      "  89 = 5!+((5!/5)-55)\n",
      "  90 = (55-(5+5))/.5\n",
      "  91 = (5*5)+(5!*.55)\n",
      "  92 = 5+(55+(.5^-5))\n",
      "  93 = .5+(5!-(.5*55))\n",
      "  94 = 5!-((5/5)+(5*5))\n",
      "  95 = (55/.55)-5\n",
      "  96 = 5!+((5/5)-(5*5))\n",
      "  97 = 5!+((.5^-5)-55)\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",
      " 106 = (555/5)-5\n",
      " 107 = 5!+((55-5!)/5)\n",
      " 108 = (55-(5/5))/.5\n",
      " 109 = (55/.5)-(5/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",
      " 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/5)+(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!*5.5))/5\n",
      " 134 = (5!/5)+(55/.5)\n",
      " 135 = (5!+555)/5\n",
      " 136 = 5+(5!+(55/5))\n",
      " 137 = (.5*(5*55))-.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",
      " 144 = ((55/5)-5)!/5\n",
      " 145 = (5*(5+(5*5)))-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+(5*(5+(5*5)))\n",
      " 156 = (5!+(5!*5.5))/5\n",
      " 157 = (.5^-5)+(5*(5*5))\n",
      " 158 = (55+(5!/5))/.5\n",
      " 159 = (5/(.5^5))-(5/5)\n",
      " 160 = (55+(5*5))/.5\n",
      " 161 = (5/5)+(5/(.5^5))\n",
      " 162 = 5+(5+(5!+(.5^-5)))\n",
      " 163 = .5+(5*(.5+(.5^-5)))\n",
      " 164 = 5!+(.5*(5!-(.5^-5)))\n",
      " 165 = 55+(55/.5)\n",
      " 166 = 5!+((5!-5)/(.5*5))\n",
      " 167 = 5!+(((5!/.5)-5)/5)\n",
      " 168 = (5!+(5+(5/5))!)/5\n",
      " 169 = 5!+((5*5)+(5!/5))\n",
      " 170 = 5!+((5*5)+(5*5))\n",
      " 171 = (5.5/(.5^5))-5\n",
      "CPU times: user 7min 28s, sys: 1.75 s, total: 7min 30s\n",
      "Wall time: 9h 7min 36s\n"
     ]
    }
   ],
   "source": [
    "%time show((5, 5, 5, 5, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What's Next?\n",
    "\n",
    "One exercise would be adding even more operators, such as:\n",
    "\n",
    "- **Nth root**: `3√8` = 2\n",
    "- **Percent**: `5%` = 5/100\n",
    "- **Repeating decimal**: `.4...` = .44444444... = 4/9\n",
    "- **Double factorial**: `9!!` = 9 × 7 × 5 × 3 × 1 = 945; not the same as `(9!)!`\n",
    "- **Gamma function**: `Γ(n)` = (n − 1)! and works for non-integers\n",
    "- **Prime counting function**: `π(n)` = number of primes ≲ n; e.g. `π(5)` = 3\n",
    "- **Transcendental functions**: `log`, `sin` `cos`, `tan`, `arcsin`, ... maybe degree symbol: 90°\n",
    "- **Matrix notation**: with determinant symbol to get a number.\n",
    "- **Combinations and Permutations**: `n P k` and `n C k`\n",
    "\n",
    "Another approach would be to look around for related puzzles and solve them. What do you want to do?"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}