Basic DeNico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Best Solution on CodeWars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def de_nico(key, msg):\n",
    "    code = tuple(sorted(key).index(k) + 1 for k in key)\n",
    "    code_cycle = cycle(code)\n",
    "    key_cycle = cycle(range(1, len(key) + 1))\n",
    "    msg_encrypted = [(k, next(key_cycle)) for k in msg]\n",
    "    result = []\n",
    "    while msg_encrypted:\n",
    "        try:\n",
    "            index = next(code_cycle)\n",
    "            found = next(p for p in msg_encrypted if p[1] == index)\n",
    "            msg_encrypted.remove(found)\n",
    "            result.append(found[0])\n",
    "        except StopIteration:\n",
    "            pass\n",
    "    return ''.join(result).strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "1\n",
      "2\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "#There are several things to learn in this answer.\n",
    "#The first one is cycle and next\n",
    "from itertools import cycle\n",
    "cyc = cycle([1, 2, 3])\n",
    "print(next(cyc))\n",
    "print(next(cyc))\n",
    "print(next(cyc))\n",
    "print(next(cyc))\n",
    "print(next(cyc))\n",
    "print(next(cyc))\n",
    "print(next(cyc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://discordapp.com/channels/267624335836053506/303906576991780866/644753068298076160"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'p'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(p for p in 'post')\n",
    "next(p for p in 'post')\n",
    "next(p for p in 'post')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('s', 2)\n",
      "('e', 3)\n",
      "('c', 1)\n",
      "('r', 5)\n",
      "('e', 4)\n",
      "('t', 2)\n",
      "('i', 3)\n",
      "('n', 1)\n",
      "('f', 5)\n",
      "('o', 4)\n",
      "('r', 2)\n",
      "('m', 3)\n",
      "('a', 1)\n",
      "('t', 5)\n",
      "('i', 4)\n",
      "('o', 2)\n",
      "('n', 3)\n",
      "(' ', 1)\n",
      "(' ', 5)\n",
      "(' ', 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['s',\n",
       " 'e',\n",
       " 'c',\n",
       " 'r',\n",
       " 'e',\n",
       " 't',\n",
       " 'i',\n",
       " 'n',\n",
       " 'f',\n",
       " 'o',\n",
       " 'r',\n",
       " 'm',\n",
       " 'a',\n",
       " 't',\n",
       " 'i',\n",
       " 'o',\n",
       " 'n',\n",
       " ' ',\n",
       " ' ',\n",
       " ' ']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n"
     ]
    }
   ],
   "source": [
    "from itertools import cycle\n",
    "key = 'crazy'\n",
    "msg = 'cseerntiofarmit on  '\n",
    "result = []\n",
    "\n",
    "code = tuple(sorted(key).index(k) + 1 for k in key)\n",
    "code_cycle = cycle(code)\n",
    "key_cycle = cycle(range(1, len(key)+1))\n",
    "msg_encrypted = [(k, next(key_cycle)) for k in msg]\n",
    "\n",
    "while msg_encrypted:\n",
    "    try:\n",
    "        index = next(code_cycle)\n",
    "        found = next(p for p in msg_encrypted if p[1] == index)\n",
    "        print(found)\n",
    "        #The step above is genius. It calls index with every step. Index will change in every step.\n",
    "        #Important note. Found has to use next as well.\n",
    "        msg_encrypted.remove(found)\n",
    "        result.append(found[0])\n",
    "        \n",
    "    except StopIteration:\n",
    "        pass\n",
    "result\n",
    "    \n",
    "print(msg_encrypted)\n",
    "#Remember that we have a code of (2, 3, 1, 5, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('L', 1), ('e', 2), ('a', 3), ('r', 4), ('n', 5), ('i', 1), ('n', 2), ('g', 3), ('C', 4), ('y', 5), ('c', 1), ('l', 2), ('e', 3)]\n",
      "[('L', 1), ('e', 1), ('a', 1), ('r', 1), ('n', 1), ('i', 1), ('n', 1), ('g', 1), ('C', 1), ('y', 1), ('c', 1), ('l', 1), ('e', 1)]\n"
     ]
    }
   ],
   "source": [
    "#See how cycle and next work together\n",
    "\n",
    "text1 = 'LearningCycle'\n",
    "lea_cycle = cycle(range(1, 6))\n",
    "print([(t, next(lea_cycle)) for t in text1])\n",
    "\n",
    "text2 = 'LearningCycle'\n",
    "print([(t, next(cycle(range(1, 6)))) for t in text1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 9 1 25 16\n"
     ]
    }
   ],
   "source": [
    "print(*map(lambda x: x**2, code))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'c') (1, 'r') (2, 'a') (3, 'z') (4, 'y')\n"
     ]
    }
   ],
   "source": [
    "key = 'crazy'\n",
    "print(*enumerate(key))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('c', 1), ('s', 2), ('e', 3), ('e', 4), ('r', 5), ('n', 1), ('t', 2), ('i', 3), ('o', 4), ('f', 5), ('a', 1), ('r', 2), ('m', 3), ('i', 4), ('t', 5), (' ', 1), ('o', 2), ('n', 3), (' ', 4), (' ', 5)]\n"
     ]
    }
   ],
   "source": [
    "msg = 'cseerntiofarmit on  '\n",
    "key_cycle = cycle(range(1, 6))\n",
    "msg_encrypted = [(k, next(key_cycle)) for k in msg]\n",
    "print(msg_encrypted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "(3, 6)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-f593e95e4fbf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "#Thoughts about iterators\n",
    "l = zip([1,2,3], [4,5,6])\n",
    "next(l)\n",
    "next(l)\n",
    "next(l)\n",
    "next(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Apparently zip, map and enumerate will return iterators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# My Working Progress"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "d = {'b': [1, 3, 5], 'a': [2, 4, 6]}\n",
    "for i in d.keys():\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = ['1', [2, 3], [4, 5, 6], [7], [8, 9]]\n",
    "[e for i in l for e in i ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'c': ['c', 'n', 'a', ' '],\n",
       " 'r': ['s', 't', 'r', 'o'],\n",
       " 'a': ['e', 'i', 'm', 'n'],\n",
       " 'z': ['e', 'o', 'i', ' '],\n",
       " 'y': ['r', 'f', 't', ' ']}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {}\n",
    "kp = 'crazy'\n",
    "mp = \"cseerntiofarmit on  \"\n",
    "for i in kp:\n",
    "    d[i] = []\n",
    "for n in range(len(mp)):\n",
    "    d[kp[n%(len(kp))]].append(mp[n])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['c', 'n', 'a', ' ', 'o'],\n",
       " 'c': ['s', 't', 'r', 'o', 'n'],\n",
       " 'r': ['e', 'i', 'm', 'n'],\n",
       " 'y': ['e', 'o', 'i', ' '],\n",
       " 'z': ['r', 'f', 't', ' ']}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Due to the lack of clarity of the kata author, I have to reorganize the code.\n",
    "\n",
    "d = {}\n",
    "kp = 'crazy'\n",
    "new_k = sorted(kp)\n",
    "mp = \"cseerntiofarmit on  on\"\n",
    "for i in new_k:\n",
    "    d[i] = []\n",
    "for n in range(len(mp)):\n",
    "    d[new_k[n%(len(kp))]].append(mp[n])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'message'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'key'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#We can write the first part of the function\n",
    "def de_nico(key,msg):\n",
    "    d = {}\n",
    "    res_l, new_res, new_k = [], [], sorted(key)\n",
    "    '''Create a dict with each character in the argument key as dict key'''\n",
    "    for i in new_k:\n",
    "        d[i] = []\n",
    "    '''Assign the str in msg to sorted dict keys based on location'''\n",
    "    for n in range(len(msg)):\n",
    "        d[new_k[n%(len(key))]].append(msg[n])\n",
    "    '''Rearrange the order of the values and put them together in one list'''\n",
    "    for i in key:\n",
    "        res_l.append(d[i])\n",
    "    for i in range(len(max(res_l, key=len))):\n",
    "        for j in range(len(res_l)):\n",
    "            try:\n",
    "                new_res.append(res_l[j][i])\n",
    "            except:\n",
    "                new_res.append('')\n",
    "    res= ''.join(new_res)\n",
    "    return res.rstrip()\n",
    "de_nico(\"a\",\"message\")\n",
    "de_nico(\"key\",\"eky\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'c', 'r', 'y', 'z']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(d.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['c', 'n', 'a', ' '],\n",
       " 'c': ['s', 't', 'r', 'o'],\n",
       " 'r': ['e', 'i', 'm', 'n'],\n",
       " 'y': ['e', 'o', 'i', ' '],\n",
       " 'z': ['r', 'f', 't', ' ']}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['s', 't', 'r', 'o', 'n'],\n",
       " ['e', 'i', 'm', 'n'],\n",
       " ['c', 'n', 'a', ' ', 'o'],\n",
       " ['r', 'f', 't', ' '],\n",
       " ['e', 'o', 'i', ' ']]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_l = []\n",
    "for i in kp:\n",
    "    res_l.append(d[i])\n",
    "res_l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'secretinformation   no'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(res_l)\n",
    "res_l[0][0]\n",
    "res_l[1][0]\n",
    "new_res = []\n",
    "\n",
    "for i in range(len(max(res_l, key=len))):\n",
    "    for j in range(len(res_l)):\n",
    "        try:\n",
    "            new_res.append(res_l[j][i])\n",
    "        except:\n",
    "            new_res.append('')\n",
    "''.join(new_res)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'no'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "try:\n",
    "    res_l[1][4]\n",
    "except:\n",
    "    'no'"
   ]
  }
 ],
 "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": 2
}