Trinity153.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{153.0, 370.0, 371.0, 407.0}\n",
      "The following number converged to 153\n",
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n",
      "30\n",
      "33\n",
      "36\n",
      "39\n",
      "42\n",
      "45\n",
      "48\n",
      "51\n",
      "54\n",
      "57\n",
      "60\n",
      "63\n",
      "66\n",
      "69\n",
      "72\n",
      "75\n",
      "78\n",
      "81\n",
      "84\n",
      "87\n",
      "90\n",
      "93\n",
      "96\n",
      "99\n",
      "The following number converged to 370\n",
      "7\n",
      "19\n",
      "34\n",
      "37\n",
      "43\n",
      "58\n",
      "67\n",
      "70\n",
      "73\n",
      "76\n",
      "85\n",
      "88\n",
      "91\n",
      "The following number converged to 371\n",
      "2\n",
      "5\n",
      "8\n",
      "11\n",
      "14\n",
      "17\n",
      "20\n",
      "23\n",
      "26\n",
      "29\n",
      "32\n",
      "35\n",
      "38\n",
      "41\n",
      "44\n",
      "50\n",
      "53\n",
      "56\n",
      "59\n",
      "62\n",
      "65\n",
      "68\n",
      "71\n",
      "80\n",
      "83\n",
      "86\n",
      "92\n",
      "95\n",
      "The following number converged to 407\n",
      "47\n",
      "74\n",
      "77\n",
      "89\n",
      "98\n",
      "End\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'The smallest number to reach 153 in 16 cycles will be more than \\n1061042524005486968, so not advisable to try it. \\n'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "\n",
    "max_n = 10**5\n",
    "converge_index = np.zeros(max_n) #like 153, 370, 371, 1\n",
    "converge_steps = np.zeros(max_n) #the number of steps to come to the convergence point\n",
    "pwr = 3\n",
    "\n",
    "def PowerUpAllDigits(n):\n",
    "    r = 0\n",
    "    for i in str(n):\n",
    "        # print(\"i=\", i, \"^3=\", Cubic(int(i)))\n",
    "        r += int(i) ** pwr\n",
    "    return (r)\n",
    "\n",
    "def theConverged (seq):\n",
    "    global max_n\n",
    "    converged_set = set()\n",
    "    for i in seq[seq > 1]:\n",
    "        converged_set.add(i)\n",
    "    print(converged_set)\n",
    "\n",
    "    while bool(converged_set):\n",
    "        i = converged_set.pop()\n",
    "        print(\"The following number converged to\",int(i))\n",
    "        for j in range(0, max_n):\n",
    "            if i==seq[j]:\n",
    "                print(j)\n",
    "\n",
    "\n",
    "def convertAllNum(s1, s2, max_steps):\n",
    "    global converge_index\n",
    "    global converge_values\n",
    "    i1 = int(s1)\n",
    "    i2 = int(s2)\n",
    "    for i in range(i1, i2):\n",
    "        steps = 1\n",
    "\n",
    "        j = PowerUpAllDigits(i)\n",
    "        prevj = j\n",
    "\n",
    "        while True:\n",
    "            steps = steps + 1\n",
    "            j = PowerUpAllDigits(j)\n",
    "            #print(\"Steps\", steps, \"=>\", j)\n",
    "            if j == prevj:\n",
    "                converge_index[i] = j\n",
    "                converge_steps[i] = steps-1\n",
    "                break\n",
    "\n",
    "            if steps > max_steps: \n",
    "                converge_steps[i] = 0\n",
    "                break\n",
    "            prevj = j\n",
    "\n",
    "convertAllNum(str(1), str(max_n), 30)\n",
    "\n",
    "theConverged(converge_index)\n",
    "\n",
    "\n",
    "#print(\"index:\", converge_index)\n",
    "#print(\"steps:\", converge_steps)\n",
    "\n",
    "'''Very large numbers\n",
    "main(str(9999**1000),\n",
    "     str(9999**1000)+\"100\",16)\n",
    "'''\n",
    "\n",
    "print(\"End\")\n",
    "\n",
    "'''The smallest number to reach 153 in 16 cycles will be more than \n",
    "1061042524005486968, so not advisable to try it. \n",
    "'''\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "33"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 153].size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 371].size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 370].size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 407].size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 0].size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "converge_index[converge_index == 1].size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Take the sum to show all numbers are counted:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{153.0, 370.0, 371.0, 407.0}\n",
      "There are 33 numbers that converge to 153\n",
      "There are 13 numbers that converge to 370\n",
      "There are 28 numbers that converge to 371\n",
      "There are 5 numbers that converge to 407\n"
     ]
    }
   ],
   "source": [
    "converged_set = set()\n",
    "for i in converge_index[converge_index > 1]:\n",
    "    converged_set.add(i)\n",
    "print(converged_set)\n",
    "for i in converged_set: \n",
    "    print(\"There are\",\n",
    "          converge_index[converge_index == i].size, \n",
    "          \"numbers that converge to\",int(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### %matplotlib inline <= needed because we are doing this in the Jupyter lab, and we want it to display the plot inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "min=0\n",
    "max=max_n\n",
    "x_index = np.full(max-min,range(min,max))\n",
    "y_value = converge_index[min:max]\n",
    "plt.scatter(x_index,y_value,c=\"g\",marker=\".\")\n",
    "plt.xlabel(\"Integer Value\")\n",
    "plt.ylabel(\"Cube each digit and converge\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## When converge_index[i] == 0 means it does not converge, but diverge to infinity (actually we only let it try 30 steps)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}