exe5.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OftgJNvO2LbQ",
        "outputId": "b0fab291-02ad-4d1c-e8cb-9be6a783b4a9"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Length:  0; Size in bytes:  72\n",
            "Length:  1; Size in bytes: 104\n",
            "Length:  2; Size in bytes: 104\n",
            "Length:  3; Size in bytes: 104\n",
            "Length:  4; Size in bytes: 104\n",
            "Length:  5; Size in bytes: 136\n",
            "Length:  6; Size in bytes: 136\n",
            "Length:  7; Size in bytes: 136\n",
            "Length:  8; Size in bytes: 136\n",
            "Length:  9; Size in bytes: 200\n"
          ]
        }
      ],
      "source": [
        "# 5.1\n",
        "'Example 5.1'\n",
        "import sys\n",
        "data = []\n",
        "n=10\n",
        "for k in range(n): \n",
        "    a = len(data)\n",
        "    b = sys.getsizeof(data)\n",
        "    print('Length:{0:3d}; Size in bytes:{1:4d}'.format(a,b))\n",
        "    data.append(None)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JqG1TkSe3YlQ",
        "outputId": "9ee3e60f-084b-4dc1-a9fc-0698fab2aa66"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Length:  1; Size in bytes: 104\n",
            "Length:  5; Size in bytes: 136\n",
            "Length:  9; Size in bytes: 200\n"
          ]
        }
      ],
      "source": [
        "# 5.2\n",
        "max=0\n",
        "data = []\n",
        "n=10\n",
        "for k in range(n): \n",
        "    a = len(data)\n",
        "    b = sys.getsizeof(data)\n",
        "    if max == 0:\n",
        "      max=b\n",
        "    if b>max:\n",
        "      print('Length:{0:3d}; Size in bytes:{1:4d}'.format(a,b))\n",
        "      max=b\n",
        "    data.append(None)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KIbsv9dgZuFI",
        "outputId": "077b50ec-bd0d-4923-e0e0-78935f536200"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Length: 20; Size in bytes: 232\n",
            "Length: 19; Size in bytes: 232\n",
            "Length: 18; Size in bytes: 232\n",
            "Length: 17; Size in bytes: 232\n",
            "Length: 16; Size in bytes: 232\n",
            "Length: 15; Size in bytes: 232\n",
            "Length: 14; Size in bytes: 232\n",
            "Length: 13; Size in bytes: 232\n",
            "Length: 12; Size in bytes: 232\n",
            "Length: 11; Size in bytes: 232\n",
            "Length: 10; Size in bytes: 232\n",
            "Length:  9; Size in bytes: 200\n",
            "Length:  8; Size in bytes: 200\n",
            "Length:  7; Size in bytes: 152\n",
            "Length:  6; Size in bytes: 152\n",
            "Length:  5; Size in bytes: 152\n",
            "Length:  4; Size in bytes: 128\n",
            "Length:  3; Size in bytes: 128\n",
            "Length:  2; Size in bytes: 112\n",
            "Length:  1; Size in bytes: 104\n"
          ]
        }
      ],
      "source": [
        "# 5.3\n",
        "import sys\n",
        "n=20\n",
        "data = [None]*n\n",
        "for k in range(n): \n",
        "    a = len(data)\n",
        "    b = sys.getsizeof(data)\n",
        "    print('Length:{0:3d}; Size in bytes:{1:4d}'.format(a,b))\n",
        "    data.pop()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "id": "Gj5TpmD3EZS6"
      },
      "outputs": [],
      "source": [
        "# 5.4, 5.5 skipped\n",
        "import ctypes\n",
        "\n",
        "class DynamicArray:\n",
        "  \"\"\"A dynamic array class akin to a simplified Python list\"\"\"\n",
        "\n",
        "  def __init__(self):\n",
        "    \"\"\"Create an empty array.\"\"\"\n",
        "    self._n = 0\n",
        "    self._capacity = 1\n",
        "    self._A = self._make_array(self._capacity)\n",
        "\n",
        "  def __len__(self):\n",
        "    \"\"\"return number of elements stored in the array\"\"\"\n",
        "    return self._n\n",
        "  \n",
        "  def __getitem__(self,k):\n",
        "    \"\"\"Return element at index k which support negative indices\"\"\"\n",
        "    if not 0 <= k < self._n and not 0 <= (self._n + k) < self._n:\n",
        "      raise IndexError('invalid index')\n",
        "\n",
        "    return self._A[k] if k>=0 else self._A[k+self._n]\n",
        "\n",
        "  def __repr__(self) -> str:\n",
        "    return (str(self._A[:self._n]))\n",
        "  \n",
        "  def append(self, obj):\n",
        "    \"\"\"add object to end of the array\"\"\"\n",
        "    if self._n == self._capacity:\n",
        "      self._resize(2*self._capacity)\n",
        "    self._A[self._n]=obj\n",
        "    self._n += 1\n",
        "  \n",
        "  def insert(self, k, value):\n",
        "    if self._n == self._capacity:\n",
        "      print('expand capacity')\n",
        "      self._resize(2*self._capacity, k)\n",
        "    else:\n",
        "      for j in range(self._n, k, -1):\n",
        "        self._A[j] = self._A[j-1]\n",
        "    self._A[k] = value\n",
        "    self._n += 1\n",
        "\n",
        "  def _resize(self, c):\n",
        "    \"\"\"resize internay array to capacity c\"\"\"\n",
        "    B = self._make_array(c)\n",
        "    for k in range(self._n):\n",
        "      B[k] = self._A[k]\n",
        "    self._A = B\n",
        "    self._capacity = c\n",
        "\n",
        "  def _make_array(self, c):\n",
        "    \"\"\"return new array with capacity c\"\"\"\n",
        "    return (c*ctypes.py_object)()\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 5.6\n",
        "class DAInsert(DynamicArray):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "  \n",
        "  def insert(self, k, value):\n",
        "    if self._n == self._capacity:\n",
        "      print('expand capacity')\n",
        "      B = self._make_array(2*self._capacity)\n",
        "      B[:k]=self._A[:k]\n",
        "      B[k+1:]=self._A[k:]\n",
        "      B[k]=value\n",
        "    for j in range(self._n, k, -1):\n",
        "      self._A[j] = self._A[j-1]\n",
        "    self._A[k] = value\n",
        "    self._n += 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "20\n",
            "9,2000,10\n",
            "21\n",
            "20\n",
            "9,2000,10\n",
            "21\n",
            "time1:0.000150, time2:0.000117\n"
          ]
        }
      ],
      "source": [
        "import time\n",
        "\n",
        "example=[i for i in range(20)]\n",
        "index=10\n",
        "insertvalue=2000\n",
        "\n",
        "arr1=DynamicArray()\n",
        "for i in range(len(example)):\n",
        "    arr1.append(example[i])\n",
        "print(arr1.__len__())\n",
        "start1=time.time()\n",
        "arr1.insert(index,insertvalue)\n",
        "time1=time.time()-start1\n",
        "print('{0},{1},{2}'.format(arr1[index-1],arr1[index],arr1[index+1]))\n",
        "print(arr1.__len__())\n",
        "\n",
        "arr2=DAInsert()\n",
        "for i in range(len(example)):\n",
        "    arr2.append(example[i])\n",
        "print(arr2.__len__())\n",
        "start2=time.time()\n",
        "arr2.insert(index,insertvalue)\n",
        "time2=time.time()-start2\n",
        "print('{0},{1},{2}'.format(arr2[index-1],arr2[index],arr2[index+1]))\n",
        "print(arr2.__len__())\n",
        "\n",
        "print('time1:{0:8f}, time2:{1:8f}'.format(time1,time2))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
            "[10, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "execution_count": 79,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 5.7\n",
        "def find_dup(S):\n",
        "    n = len(S)\n",
        "    check=[0]*n\n",
        "\n",
        "    for i in range(n):\n",
        "        if check[S[i]-1]: return S[i]\n",
        "        else: check[S[i]-1]=1\n",
        "    return ('No duplicate')\n",
        "\n",
        "arr = [i for i in range(1,11)]\n",
        "print(arr)\n",
        "find_dup(arr)\n",
        "arr[0]=10\n",
        "print(arr)\n",
        "find_dup(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "message: THE EAGLE IS IN PLAY\n",
            "coded: WKH HDJOH LV LQ SODB\n",
            "answer:THE EAGLE IS IN PLAY\n",
            "message: tHE EAGLE IS IN PLaY\n",
            "coded: WKH HDJOH LV LQ SODB\n",
            "answer:THE EAGLE IS IN PLAY\n"
          ]
        }
      ],
      "source": [
        "# 5.8, 5.9 skipped\n",
        "\n",
        "class CaesarCipher:\n",
        "    def __init__(self, shift):\n",
        "        encoder = [chr((k+shift)%26+ord('A')) for k in range(26)]\n",
        "        decoder = [chr((k-shift)%26+ord('A')) for k in range(26)]\n",
        "        self._forward = ''.join(encoder)\n",
        "        self._backward = ''.join(decoder)\n",
        "\n",
        "    def encrypt(self, message):\n",
        "        return self._transform(message, self._forward)\n",
        "\n",
        "    def decrypt(self, secret):\n",
        "        return self._transform(secret, self._backward)\n",
        "\n",
        "    def _transform(self, original, code):\n",
        "        msg = list(original)\n",
        "        for k in range(len(msg)):\n",
        "            if msg[k].islower():\n",
        "                msg[k]=msg[k].upper()\n",
        "            \n",
        "            if msg[k].isupper():\n",
        "                j=ord(msg[k])-ord('A')\n",
        "                msg[k]=code[j]\n",
        "        return ''.join(msg)\n",
        "\n",
        "cipher = CaesarCipher(3)\n",
        "message1 = 'THE EAGLE IS IN PLAY'\n",
        "message2 = \"tHE EAGLE IS IN PLaY\"\n",
        "coded1 = cipher.encrypt(message1)\n",
        "coded2 = cipher.encrypt(message2)\n",
        "answer1 = cipher.decrypt(coded1)\n",
        "answer2 = cipher.decrypt(coded2)\n",
        "print(f'message: {message1}\\ncoded: {coded1}\\nanswer:{answer1}')\n",
        "print(f'message: {message2}\\ncoded: {coded2}\\nanswer:{answer2}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]\n",
            "30\n",
            "30\n"
          ]
        }
      ],
      "source": [
        "# 5.11\n",
        "a = [[i for i in range(5)] for j in range(3)]\n",
        "print(a)\n",
        "\n",
        "def array_sum(arr):\n",
        "    total=0\n",
        "    for i in range(len(arr)):\n",
        "        for j in range(len(arr[i])):\n",
        "            total+=j\n",
        "    return total\n",
        "    \n",
        "print(array_sum(a))\n",
        "\n",
        "# 5.12\n",
        "def builtin_sum(arr):\n",
        "    return sum([sum(i) for i in arr])\n",
        "\n",
        "print(builtin_sum(a))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[2, 9, 3, 5, 7, 4, 0, 8, 1, 6]\n"
          ]
        }
      ],
      "source": [
        "# 5.13 skipped\n",
        "# 5.14\n",
        "import random\n",
        "\n",
        "def customshuffle(arr):\n",
        "    for i in range(len(arr)):\n",
        "        index=random.randrange(len(arr))\n",
        "        arr[i],arr[index]=arr[index],arr[i]\n",
        "    return arr\n",
        "\n",
        "a = [i for i in range(10)]\n",
        "print(a)\n",
        "shuffled = customshuffle(a)\n",
        "print(shuffled)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 5.15 skipped\n",
        "# 5.16\n",
        "\n",
        "class DAPop(DynamicArray):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "    \n",
        "    def pop(self):\n",
        "        print(f'Before: length/n={self._n}, capacity={self._capacity}')\n",
        "        value = self._A[self._n-1]\n",
        "        self._A[self._n-1]=None\n",
        "        self._n-=1\n",
        "        if self._n <= self._capacity//4:\n",
        "            self._resize(self._capacity//2)\n",
        "        \n",
        "        print(f'After: length/n={self._n}, capacity={self._capacity}\\n')\n",
        "        return value"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Before: length/n=20, capacity=32\n",
            "After: length/n=19, capacity=32\n",
            "\n",
            "Before: length/n=19, capacity=32\n",
            "After: length/n=18, capacity=32\n",
            "\n",
            "Before: length/n=18, capacity=32\n",
            "After: length/n=17, capacity=32\n",
            "\n",
            "Before: length/n=17, capacity=32\n",
            "After: length/n=16, capacity=32\n",
            "\n",
            "Before: length/n=16, capacity=32\n",
            "After: length/n=15, capacity=32\n",
            "\n",
            "Before: length/n=15, capacity=32\n",
            "After: length/n=14, capacity=32\n",
            "\n",
            "Before: length/n=14, capacity=32\n",
            "After: length/n=13, capacity=32\n",
            "\n",
            "Before: length/n=13, capacity=32\n",
            "After: length/n=12, capacity=32\n",
            "\n",
            "Before: length/n=12, capacity=32\n",
            "After: length/n=11, capacity=32\n",
            "\n",
            "Before: length/n=11, capacity=32\n",
            "After: length/n=10, capacity=32\n",
            "\n",
            "Before: length/n=10, capacity=32\n",
            "After: length/n=9, capacity=32\n",
            "\n",
            "Before: length/n=9, capacity=32\n",
            "After: length/n=8, capacity=16\n",
            "\n",
            "Before: length/n=8, capacity=16\n",
            "After: length/n=7, capacity=16\n",
            "\n",
            "Before: length/n=7, capacity=16\n",
            "After: length/n=6, capacity=16\n",
            "\n",
            "Before: length/n=6, capacity=16\n",
            "After: length/n=5, capacity=16\n",
            "\n"
          ]
        }
      ],
      "source": [
        "example=[i for i in range(20)]\n",
        "\n",
        "arr=DAPop()\n",
        "for i in range(len(example)):\n",
        "    arr.append(example[i])\n",
        "    \n",
        "for i in range(15):\n",
        "    arr.pop()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 5.17 - 5.24 skipped\n",
        "# 5.25, referred\n",
        "class DARemoveAll(DynamicArray):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "\n",
        "    def remove_all(self, value):\n",
        "        num_removed = 0\n",
        "        for i in range(self._n):\n",
        "            if self._A[i] == value:\n",
        "                num_removed += 1 \n",
        "            self._A[i-num_removed] = self._A[i]\n",
        "                \n",
        "        self._n -= num_removed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 5, 6, 7, 8, 8, 8, 6, 10]\n",
            "[1, 2, 3, 5, 6, 7, 8, 8, 8, 6, 10]\n"
          ]
        }
      ],
      "source": [
        "arr=DARemoveAll()\n",
        "a=[1,2,3,4,5,5,6,7,8,8,8,6,10]\n",
        "for i in a:\n",
        "    arr.append(i)\n",
        "print(arr)\n",
        "arr.remove_all(value=5)\n",
        "print(arr)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0, 1, 2], [0, 1, 2], [0, 1, 2]]\n",
            "9\n"
          ]
        }
      ],
      "source": [
        "# 5.26 - 5.30 skipped\n",
        "# 5.31\n",
        "def sum(s):\n",
        "    total = 0\n",
        "    if not isinstance(s, list):\n",
        "        return s\n",
        "    else:\n",
        "        for i in s: total+= sum(i)\n",
        "    return total\n",
        "\n",
        "def sum_arr(arr):\n",
        "    total = sum(arr)\n",
        "    return total\n",
        "\n",
        "a = [[i for i in range(3)] for i in range(3)]\n",
        "print(a)\n",
        "totala=sum_arr(a)\n",
        "print(totala)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 5.34\n",
        "class CaesarCipherAll(CaesarCipher):\n",
        "    def __init__(self, shift):\n",
        "        super().__init__(shift)\n",
        "\n",
        "    def _transform(self, original, code):\n",
        "        msg = list(original)\n",
        "        lowercase=[]\n",
        "        for k in range(len(msg)):\n",
        "            if msg[k].islower():\n",
        "                lowercase.append(k)\n",
        "                msg[k]=msg[k].upper()\n",
        "            \n",
        "            if msg[k].isupper():\n",
        "                j=ord(msg[k])-ord('A')\n",
        "                msg[k]=code[j]\n",
        "\n",
        "        if len(lowercase)>0:\n",
        "            for i in lowercase:\n",
        "                msg[i]=msg[i].lower()\n",
        "\n",
        "        return ''.join(msg)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "message: Boikot CCP\n",
            "coded: Fsmosx GGT\n",
            "answer:Boikot CCP\n",
            "message: PUTIN Najis\n",
            "coded: TYXMR Renmw\n",
            "answer:PUTIN Najis\n"
          ]
        }
      ],
      "source": [
        "cipher = CaesarCipherAll(4)\n",
        "message1 = \"Boikot CCP\"\n",
        "message2 = \"PUTIN Najis\"\n",
        "coded1 = cipher.encrypt(message1)\n",
        "coded2 = cipher.encrypt(message2)\n",
        "answer1 = cipher.decrypt(coded1)\n",
        "answer2 = cipher.decrypt(coded2)\n",
        "print(f'message: {message1}\\ncoded: {coded1}\\nanswer:{answer1}')\n",
        "print(f'message: {message2}\\ncoded: {coded2}\\nanswer:{answer2}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {},
      "outputs": [],
      "source": [
        "# 5.35, assuming arbitrary order is the randomized alphabetical order for encryption, no shifting will be required.\n",
        "# my understanding of question 5.35 is similar to 5.37.\n",
        "class SubstitutionCipher:\n",
        "    def __init__(self, code:list):\n",
        "        self._forward = code\n",
        "        self._backward=[None]*26\n",
        "        for i in range(len(code)):\n",
        "            self._backward[ord(code[i])-ord('A')]=chr(ord('A')+i)\n",
        "    \n",
        "    def encrypt(self, message):\n",
        "        return self._transform(message, self._forward)\n",
        "\n",
        "    def decrypt(self, secret):\n",
        "        return self._transform(secret, self._backward)\n",
        "\n",
        "    def _transform(self, text, cipher):\n",
        "        result=[]\n",
        "        for i in range(len(text)):\n",
        "            if text[i].isupper():\n",
        "                j=ord(text[i])-ord('A')\n",
        "                result.append(cipher[j])\n",
        "            elif text[i].islower():\n",
        "                j=ord(text[i].upper())-ord('A')\n",
        "                result.append(cipher[j].lower())\n",
        "            else: result.append(text[i])\n",
        "        return ''.join(i for i in result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']\n",
            "['M', 'K', 'E', 'J', 'G', 'B', 'Q', 'F', 'S', 'W', 'X', 'T', 'O', 'V', 'I', 'Z', 'R', 'L', 'C', 'A', 'N', 'Y', 'U', 'D', 'H', 'P']\n",
            "Cfgltiex, afg Gmca Usvj sc eiosvq\n",
            "Sherlock, the East Wind is coming\n"
          ]
        }
      ],
      "source": [
        "order = [chr(i+ord('A')) for i in range(26)]\n",
        "code = order.copy()\n",
        "random.shuffle(code)\n",
        "print(order)\n",
        "print(code)\n",
        "\n",
        "sc = SubstitutionCipher(code)\n",
        "secret = sc.encrypt(\"Sherlock, the East Wind is coming\")\n",
        "print(secret)\n",
        "message = sc.decrypt(secret)\n",
        "print(message)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "['D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C']\n",
            "Vkhuorfn, wkh Hdvw Zlqg lv frplqj\n",
            "Sherlock, the East Wind is coming\n"
          ]
        }
      ],
      "source": [
        "# 5.36\n",
        "class RedesignCaeserCipher(SubstitutionCipher):\n",
        "    def __init__(self, shift):\n",
        "        self._shift = shift\n",
        "        code = [chr((i + self._shift)%26 + ord('A')) for i in range(26)]\n",
        "        print(code)\n",
        "        super().__init__(code)\n",
        "        \n",
        "sc = RedesignCaeserCipher(3)\n",
        "secret = sc.encrypt(\"Sherlock, the East Wind is coming\")\n",
        "print(secret)\n",
        "message = sc.decrypt(secret)\n",
        "print(message)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.7.13 ('deepcv')",
      "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.13"
    },
    "vscode": {
      "interpreter": {
        "hash": "ff9b3526de0a2ac64bc349bab9f7012e1185506914020ad8fc9dce0e6b353e35"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}