main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Kaprekar's routine, constants and carpets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dattatreya Ramachandra Kaprekar\n",
    "\n",
    "![D. R. Kaprekar](kaprekar.gif)\n",
    "\n",
    "Dattatreya Ramachandra Kaprekar (Dahanu, Maharastra, January 17, 1905 - Deolali, Nashik District, Maharastra, June 1, 1986, Kerala, India) was an indian mathematician whose name is associated with multiple concepts in number theory. He described the Kaprekar, harshad, self and other several of classes of natural numbers, and is also known for discovering the Kaprekar's constant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaprekar's routine\n",
    "\n",
    "It is an iterative algorithm consisting of the following steps:\n",
    "\n",
    "  1. Choose any natural number $n$ in a given number base $b$.\n",
    "  2. Create a new number $\\alpha$ by sorting the digits of $n$ in descending order.\n",
    "  3. Create a new number $\\beta$ by sorting the digits of $n$ in ascending order.\n",
    "  4. Substract $\\alpha - \\beta$ to produce the next $n$ number.\n",
    "  5. Repeat from step 2 with the new $n$ number.\n",
    "\n",
    "When the $\\alpha$ and $\\beta$ numbers are created may have leading zeros, wich could be discarted or preserved."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kaprekar(n, pad=None):\n",
    "    \"\"\"\n",
    "    Base 10 Kaprekar's mapping for the given number\n",
    "    \"\"\"\n",
    "    d = str(n)\n",
    "    s = sorted(d.ljust(pad, \"0\") if pad and pad > len(d) else d)\n",
    "    return int(\"\".join(reversed(s))) - int(\"\".join(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaprekar's constants\n",
    "\n",
    "The consecutive application of the Kaprekar's routine may result on repeating cicles or reach fixing points. These fixing points are called Kaprekar's constants."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6174\n",
    "\n",
    "The 6174 number is the most famous Kaprekar's constant. It is obtained by applying at most seven iterations of the Kaprepar's routine for any base 10 four-digits number, not repdigit and preserving the leading zeros."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 495\n",
    "\n",
    "The second most famous Kaprekar's constant is 495. It is obtained similarly as the 6174 constant but using three-digits numbers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kaprekar's carpets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the Kaprekar's routine with base 10 numbers when the leading zeros are preserved, Kaprekar's carpets can be built for the four-digits and three-digits cases.\n",
    "\n",
    "The carpet is a matrix of $10^{d}$ entries, where $d$ is the number of digits for the case. Each entry represents a number in the range $[0, 10^{d} - 1]$, contains the number of iterations needed to reach the Kaprekar's constant and are arranged so that the columns represent the two least significant digits of the number, while the rows represent the two most significant digits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "from PIL import Image\n",
    "\n",
    "class Carpet():\n",
    "    \"\"\"\n",
    "    Base 10 Kaprekar's carpet for four or three digits\n",
    "    \"\"\"\n",
    "    \n",
    "    _rgb_palette = {\n",
    "        \"none\": (0x00, 0x00, 0x00),\n",
    "        \"border\": (0x00, 0x00, 0x00),\n",
    "        0: (0xFF, 0xFF, 0xFF),\n",
    "        1: (0xFF, 0xDB, 0x01),\n",
    "        2: (0x47, 0xFF, 0x01),\n",
    "        3: (0x01, 0xFE, 0x91),\n",
    "        4: (0x00, 0x91, 0xFE),\n",
    "        5: (0x48, 0x01, 0xFF),\n",
    "        6: (0xFE, 0x00, 0xDA),\n",
    "        7: (0xFE, 0x00, 0x00)\n",
    "    }\n",
    "    \n",
    "    _bw_palette = {\n",
    "        \"none\": (0x00, 0x00, 0x00),\n",
    "        \"border\": (0x00, 0x00, 0x00),\n",
    "        0: (0x1F, 0x1F, 0x1F),\n",
    "        1: (0x3F, 0x3F, 0x3F),\n",
    "        2: (0x5F, 0x5F, 0x5F),\n",
    "        3: (0x7F, 0x7F, 0x7F),\n",
    "        4: (0x9F, 0x9F, 0x9F),\n",
    "        5: (0xBF, 0xBF, 0xBF),\n",
    "        6: (0xDF, 0xDF, 0xDF),\n",
    "        7: (0xFF, 0xFF, 0xFF)\n",
    "\n",
    "    }\n",
    "    \n",
    "    \n",
    "    @staticmethod\n",
    "    def known_palette(name):\n",
    "        if name == \"rgb\":\n",
    "            return deepcopy(Carpet._rgb_palette)\n",
    "        if name == \"bw\":\n",
    "            return deepcopy(Carpet._bw_palette)\n",
    "        raise ValueError(\"unknown palette\")\n",
    "    \n",
    "    @staticmethod\n",
    "    def kaprekar(n, pad=None):\n",
    "        \"\"\"\n",
    "        Kaprekar's mapping for the given number\n",
    "        \"\"\"\n",
    "        d = str(n)\n",
    "        s = sorted(d.ljust(pad, \"0\") if pad and pad > len(d) else d)\n",
    "        return int(\"\".join(reversed(s))) - int(\"\".join(s))\n",
    "    \n",
    "    \n",
    "    def __init__(self, digits=4, cell_size=5, border_size=1, palette=\"rgb\"):\n",
    "        \"\"\"\n",
    "        Constructor\n",
    "        \"\"\"\n",
    "        self.digits = digits\n",
    "        self.cell_size = cell_size\n",
    "        self.border_size = border_size\n",
    "        self.palette = palette\n",
    "    \n",
    "    \n",
    "    def _coord(self, x, y):\n",
    "        \"\"\"\n",
    "        Get the coordinate of the upper left pixel for the given cell\n",
    "        \"\"\"\n",
    "        scale = self._cell_size + self._border_size\n",
    "        return (x * scale + self._border_size, y * scale + self._border_size)\n",
    "    \n",
    "    @property\n",
    "    def digits(self):\n",
    "        \"\"\"\n",
    "        Get the number of digits\n",
    "        \"\"\"\n",
    "        return self._n\n",
    "    \n",
    "    @property\n",
    "    def cell_size(self):\n",
    "        \"\"\"\n",
    "        Get the cell size\n",
    "        \"\"\"\n",
    "        return self._cell_size\n",
    "    \n",
    "    @property\n",
    "    def border_size(self):\n",
    "        \"\"\"\n",
    "        Get the border size\n",
    "        \"\"\"\n",
    "        return self._border_size\n",
    "    \n",
    "    @property\n",
    "    def palette(self):\n",
    "        \"\"\"\n",
    "        Get the palette\n",
    "        \"\"\"\n",
    "        return deepcopy(self._palette)\n",
    "    \n",
    "    @property\n",
    "    def image(self):\n",
    "        \"\"\"\n",
    "        Get the carpet image\n",
    "        \"\"\"\n",
    "        self.build()\n",
    "        return self._img.copy()\n",
    "    \n",
    "    \n",
    "    @digits.setter\n",
    "    def digits(self, digits):\n",
    "        \"\"\"\n",
    "        Set the number of digits\n",
    "        \"\"\"\n",
    "        if digits != 3 and digits != 4:\n",
    "            raise ValueError(\"only 3 and 4 are valid for the digits argument\")\n",
    "        \n",
    "        self._n = digits\n",
    "        self._modified = True\n",
    "    \n",
    "    @cell_size.setter\n",
    "    def cell_size(self, cell_size):\n",
    "        \"\"\"\n",
    "        Set the cell size\n",
    "        \"\"\"\n",
    "        if cell_size < 1:\n",
    "            raise ValueError(\"the cell size must be greater than zero\")\n",
    "        \n",
    "        self._cell_size = cell_size\n",
    "        self._modified = True\n",
    "    \n",
    "    @border_size.setter\n",
    "    def border_size(self, border_size):\n",
    "        \"\"\"\n",
    "        Set the cell border size\n",
    "        \"\"\"\n",
    "        if border_size < 0:\n",
    "            raise ValueError(\"the border size cannot be negative\")\n",
    "        \n",
    "        self._border_size = border_size\n",
    "        self._modified = True\n",
    "    \n",
    "    @palette.setter\n",
    "    def palette(self, palette):\n",
    "        \"\"\"\n",
    "        Set the carpet palette\n",
    "        \"\"\"\n",
    "        if isinstance(palette, str):\n",
    "            self._palette = Carpet.known_palette(palette)\n",
    "        elif palette:\n",
    "            palette = deepcopy(palette)\n",
    "            for prop in [ \"none\", \"border\" ]:\n",
    "                if not prop in palette:\n",
    "                    palette[prop] = Carpet._bw_palette[prop]\n",
    "            self._palette = palette\n",
    "        self._modified = True\n",
    "    \n",
    "    def build(self):\n",
    "        \"\"\"\n",
    "        Build the Kaprekar's carpet\n",
    "        \"\"\"\n",
    "        if not self._modified:\n",
    "            return\n",
    "        \n",
    "        zeros, fit = divmod(self._n, 2)\n",
    "        rows = 10 ** zeros\n",
    "        cols = 10 ** (zeros + fit)\n",
    "        \n",
    "        self._img = Image.new(mode=\"RGB\", size=self._coord(cols, rows), color=self._palette[\"border\"])\n",
    "        pixel = self._img.load()\n",
    "        \n",
    "        for n in range(10 ** self._n):\n",
    "            row, col = divmod(n, cols)\n",
    "\n",
    "            k_0 = n\n",
    "            k_1 = Carpet.kaprekar(k_0, self._n)\n",
    "            color = None\n",
    "\n",
    "            if k_1:\n",
    "                i = 0\n",
    "                while k_1 != k_0:\n",
    "                    k_0 = k_1\n",
    "                    k_1 = Carpet.kaprekar(k_0, self._n)\n",
    "                    i += 1\n",
    "                color = self._palette[i] if i in self._palette else 3 * (i,)\n",
    "            else:\n",
    "                color = self._palette[\"none\"]\n",
    "\n",
    "            x, y = self._coord(col, row)\n",
    "            for l in range(x, x + self._cell_size):\n",
    "                for m in range(y, y + self._cell_size):\n",
    "                    pixel[l, m] = color\n",
    "        \n",
    "        self._modified = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display\n",
    "\n",
    "# Carpet and BW palette with red constant\n",
    "carpet = Carpet()\n",
    "bw = Carpet.known_palette(\"bw\")\n",
    "bw[0] = (0xFF, 0x00, 0x00)\n",
    "\n",
    "def saveAndDisplay(img, name):\n",
    "    \"\"\"\n",
    "    Save and display the given image\n",
    "    \"\"\"\n",
    "    img.save(name)\n",
    "    display(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Four-digits carpet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=601x601 at 0x7FDD18528430>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=601x601 at 0x7FDD18528430>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# RGB carpet\n",
    "saveAndDisplay(carpet.image, \"carpet4_rgb.png\")\n",
    "\n",
    "# BW carpet\n",
    "carpet.palette = bw\n",
    "saveAndDisplay(carpet.image, \"carpet4_bw.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Three-digits carpet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAA9CAIAAAARYOt1AAADEElEQVR4nO3d0W0bMQwGYMq7tKu022SWbNOu0u6S66sNBcZB1Ul0+H1vIeIzlZxN4PBDigCA2tqn1Y/4c//jLb7/bMd95dfR4v3j4TVvt/bxfl84bm/H34frt2/Hj+Oh8rsd/av6K/fv3neYv+exyt6e+98Zq6zsuX/VrMp1PfdXvq4yq+f+Oisr2e6NscrKz+B1lVnfdXsrtwCA2sxCAKozCwGoziwEAACorcVnqdH8mcy+w25p0rATep6VGVvZ89i69qZh++vkT8P2r8qfhu1/J38a9swqpGH/v+IZKQDVmYUAVGcWAlCdWQgAAFBbi4j8ycAz/eTPZErDrun5ut1ir+v5TI40Wxr2TI40Wxp2bBXSsM8rfT9jn529Fc9IAajOLASgOrMQgOrMQgAAgNpaRGTLp43tbpctGTi2t2e2TKY07Jqex3Kke+/5WauQhn3e81iOdG8aduyu25uG9YwUgOrMQgCqMwsBqM4sBAAAqK1FRLY9A8/k5fLn08bOW8+Whn3FTOYrpmFn5UilYZ/3PCtHuvLbZlaOdOX3/Kwc6SeflOPhyq21WWlYz0gBqM4sBKA6sxCA6sxCAACA2lpE5D/HuU8lZdsz8MwqsuXTrjtvfW8a9hUzmdf1HJ1Zq3jFv/zKVcy651f+L2Z926y8o5xrDwBzmIUAVGcWAlCdWQgAAFBbi4i9pwmPZbSyneN8ZhXZ9gy87tTvvWnY/MnAr5GGXdlzdF5xFWM9713F2D2/938xVvGMFIDqzEIAqjMLAajOLAQAAKitxZXn2o9Vxs61z5+GHTzHeWsaNtuegV81DZs/Gbh3b09p2DyrONNztlWcqXhGCkB1ZiEA1ZmFAFRnFgIAANTWImJWXu66yqyc29407FiSShr2eaV/9/wnaPfvlX+3xr3nrc9Kw75iJjNbz9F5xVX0Fc9IAajOLASgOrMQgOrMQgAAgNpaRIxltLJVsmVfv0YadlYebGXlugzbdZWVubts98bKNGy2fON1u8VKwz7vOTqekQJQnVkIQHVmIQDVmYUAAAC1/QP/LYbxhnRbcwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=601x61 at 0x7FDD03D0F700>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlkAAAA9CAIAAAARYOt1AAADGElEQVR4nO3d7UkkQRAG4JrLxEjESMRIxEjESMRIDOXu7x59LENff9RYz/PPYne2WsctGF66IwCgtuOf1e/v79sfHx4ePj8/bytPT0/v7++3lZeXl9fX19vK29vb4+PjbeXr6+v5+fm28vHx0b6rvXL76W2H+Xvuq+ztuX1NX2Vlz+27RlXm9dxeeV5lVM/tdVZWst0bfZWV/4PzKqO+6/ZWfgUA1GYWAlCdWQhAdWYhAABAbUf8KzWaP5PZdtiu7YqryNbzqMzYyp771rU3DdteJ38atn1X/jRs+5r8adgzq5CG/f+KZ6QAVGcWAlCdWQhAdWYhAABAbUdE5E8GnuknfyZTGnZNz/N2i53X85kcabY07JkcabY0bN8qpGHvV9p++v539lY8IwWgOrMQgOrMQgCqMwsBAABqOyIiWz6tb3e7bMnAvr09s2UypWHX9NyXI917z49ahTTs/Z77cqR707B9d93eNKxnpABUZxYCUJ1ZCEB1ZiEAAEBtR0Rk2zPwTF4ufz6t77z1bGnYK2Yyr5iGHZUjlYa93/OoHOnKb5tROdKV3/OjcqTtlX/HX46IUWlYz0gBqM4sBKA6sxCA6sxCAACA2o4Yl8OZd45zm0rKtmfgmVVky6fNO299bxr2ipnMeT1HY9QqrvibX7mKUff8yr/FqG+blXeUc+0BYAyzEIDqzEIAqjMLAQAAajsiYu9pwn0ZrWznOJ9ZRbY9A+ed+r03DZs/Gfgz0rAre47GFVfR1/PeVfTd83v/Fn0Vz0gBqM4sBKA6sxCA6sxCAACA2uaea99X6TvXPn8ati83tTcNm23PwJ+ahs2fDNy7t6c0bJ5VnOk52yrOVDwjBaA6sxCA6sxCAKozCwEAAGo7ImJUXm5eZVTObW8ati9JJQ17v9J+ev4TtNvPyr9b497z1kelYa+YyczWczSuuIq24hkpANWZhQBUZxYCUJ1ZCAAAUNsREX0ZrWyVbNnXn5GGHZUHW1mZl2GbV1mZu8t2b6xMw2bLN87bLVYa9n7P0fCMFIDqzEIAqjMLAajOLAQAAKjtD4L2mQCdV3QJAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=601x61 at 0x7FDD18528580>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# RGB carpet\n",
    "carpet.digits = 3\n",
    "carpet.palette = \"rgb\"\n",
    "saveAndDisplay(carpet.image, \"carpet3_rgb.png\")\n",
    "\n",
    "# BW carpet\n",
    "carpet.palette = bw\n",
    "saveAndDisplay(carpet.image, \"carpet3_bw.png\")"
   ]
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}