Coded Correspondence.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Casual Coded Correspondence: The Project\n",
    "\n",
    "In this project, you will be working to code and decode various messages between you and your fictional cryptography enthusiast pen pal Vishal. You and Vishal have been exchanging letters for quite some time now and have started to provide a puzzle in each one of your letters.  Here is his most recent letter:\n",
    "\n",
    "     Hey there! How have you been? I've been great! I just learned about this really cool type of cipher called a  Caesar Cipher. Here's how it works: You take your message, something like \"hello\" and then you shift all of the letters by a certain offset. For example, if I chose an offset of 3 and a message of \"hello\", I would code my message by shifting each letter 3 places to the left (with respect to the alphabet). So \"h\" becomes \"e\", \"e\" becomes, \"b\", \"l\" becomes \"i\", and \"o\" becomes \"l\". Then I have my coded message,\"ebiil\"! Now I can send you my message and the offset and you can decode it. The best thing is that Julius Caesar himself used this cipher, that's why it's called the Caesar Cipher! Isn't that so cool! Okay, now I'm going to send you a longer coded message that you have to decode yourself!\n",
    "    \n",
    "        xuo jxuhu! jxyi yi qd unqcfbu ev q squiqh syfxuh. muhu oek qrbu je tusetu yj? y xefu ie! iudt cu q cuiiqwu rqsa myjx jxu iqcu evviuj!\n",
    "    \n",
    "    This message has an offset of 10. Can you decode it?\n",
    "    \n",
    "\n",
    "#### Step 1: Decode Vishal's Message\n",
    "In the cell below, use your Python skills to decode Vishal's message and print the result. Hint: you can account for shifts that go past the end of the alphabet using the modulus operator, but I'll let you figure out how!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hey there! this is an example of a caesar cipher. were you able to decode it? i hope so! send me a message back with the same offset!\n"
     ]
    }
   ],
   "source": [
    "# Create Two Strings to House All of the Letters and Punctuation that are Used in Vishal's Message\n",
    "alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "punctuation = \"!.?,' \"\n",
    "\n",
    "# Define a Variable that Contains the String Message\n",
    "message = \"xuo jxuhu! jxyi yi qd unqcfbu ev q squiqh syfxuh. muhu oek qrbu je tusetu yj? y xefu ie! iudt cu q cuiiqwu rqsa myjx jxu iqcu evviuj!\"\n",
    "\n",
    "# Create an Empty String to Which the Decoded Message will be A\n",
    "translated_message = \"\"\n",
    "\n",
    "# Use a For Loop to Iterate through Each Letter in Vishal's Message\n",
    "for letter in message:\n",
    "    # If the letter is not a Punctuation Mark\n",
    "    if not letter in punctuation:\n",
    "        # Assign a Numerical Value to the Letter Using the Find Method \n",
    "        letter_position = alphabet.find(letter)\n",
    "        # Using the Plus Equals Operator, Add the Alphabet Letter by Indexing its Position and Adding 10\n",
    "        # If there is a Shift Past the End of the Alphabet, Use the Modulus Operator for 26 to get the Letter\n",
    "        translated_message += alphabet[(letter_position + 10) % 26]\n",
    "    # Using an Else Statement to Add Punctuation Items that are Not Letters to the Translated Message\n",
    "    else:\n",
    "        translated_message += letter\n",
    "print(translated_message)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 2: Send Vishal a Coded Message\n",
    "Great job! Now send Vishal back a message using the same offset. Your message can be anything you want! Remember, coding happens in opposite direction of decoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xy lyixqb! y wej oekh cuiiqwu. jxyi yi q fhujjo seeb mqo je secckdysqju, y tekrj qdoedu sqd jubb mxqj mu'hu iqoydw!\n"
     ]
    }
   ],
   "source": [
    "# Define a Variable that Contains the String Message to Vishal\n",
    "message_to_vishal = \"hi vishal! i got your message. this is a pretty cool way to communicate, i doubt anyone can tell what we're saying!\"\n",
    "\n",
    "# Create an Empty String to Which the Coded Message will be Added\n",
    "translated_message = \"\"\n",
    "\n",
    "# Use a For Loop to Iterate through Each Letter in My Message to Vishal\n",
    "for letter in message_to_vishal:\n",
    "    # If the letter is not a Punctuation Mark\n",
    "    if not letter in punctuation:\n",
    "        # Assign a Numerical Value to the Letter Using the Find Method \n",
    "        letter_position = alphabet.find(letter)\n",
    "        # Using the Plus Equals Operator, Add the Alphabet Letter by Indexing its Position and Subtracting 10\n",
    "        # If there is a Shift Past the End of the Alphabet, Use the Modulus Operator for 26 to get the Letter\n",
    "        translated_message += alphabet[(letter_position - 10) % 26]\n",
    "    # Using an Else Statement to Add Punctuation Items that are Not Letters to My Message to Vishal\n",
    "    else:\n",
    "        translated_message += letter\n",
    "print(translated_message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 3: Make functions for decoding and coding \n",
    "\n",
    "Vishal sent over another reply, this time with two coded messages!\n",
    "    \n",
    "    You're getting the hang of this! Okay here are two more messages, the first one is coded just like before with  an offset of ten, and it contains the hint for decoding the second message!\n",
    "    \n",
    "    First message:\n",
    "    \n",
    "        jxu evviuj veh jxu iusedt cuiiqwu yi vekhjuud.\n",
    "        \n",
    "    Second message:\n",
    "    \n",
    "        bqdradyuzs ygxfubxq omqemd oubtqde fa oapq kagd yqeemsqe ue qhqz yadq eqogdq!\n",
    "    \n",
    "Decode both of these messages. \n",
    "\n",
    "If you haven't already, define two functions `decoder(message, offset)` and `coder(message, offset)` that can be used to quickly decode and code messages given any offset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the offset for the second message is fourteen.\n"
     ]
    }
   ],
   "source": [
    "# Define a Function with 2 Parameters for the Input Message and the Offset Amount\n",
    "def decoder(message, offset):\n",
    "    translated_message = \"\"\n",
    "    # Use a For Loop to Iterate through Each Letter in the Coded Input Message\n",
    "    for letter in message:\n",
    "        # If the letter is not a Punctuation Mark\n",
    "        if not letter in punctuation:\n",
    "            # Assign a Numerical Value to the Letter Using the Find Method \n",
    "            letter_position = alphabet.find(letter)\n",
    "            # Using the Plus Equals Operator, Add the Alphabet Letter by Indexing its Position and Adding 10\n",
    "            # If there is a Shift Past the End of the Alphabet, Use the Modulus Operator for 26 to get the Letter\n",
    "            translated_message += alphabet[(letter_position + offset) % 26]\n",
    "        # Using an Else Statement to Add Punctuation Items that are Not Letters to the Translated Message\n",
    "        else:\n",
    "            translated_message += letter\n",
    "    return translated_message\n",
    "    \n",
    "# Define a Function with 2 Parameters for the Input Message and the Offset Amount    \n",
    "def coder(message, offset):\n",
    "    translated_message = \"\"\n",
    "    # Use a For Loop to Iterate through Each Letter in the Decoded Input Message\n",
    "    for letter in message:\n",
    "        # If the letter is not a Punctuation Mark\n",
    "        if not letter in punctuation:\n",
    "            # Assign a Numerical Value to the Letter Using the Find Method\n",
    "            letter_position = alphabet.find(letter)\n",
    "            # Using the Plus Equals Operator, Add the Alphabet Letter by Indexing its Position and Subtracting 10\n",
    "            # If there is a Shift Past the End of the Alphabet, Use the Modulus Operator for 26 to get the Letter\n",
    "            translated_message += alphabet[(letter_position - offset) % 26]\n",
    "        # Using an Else Statement to Add Punctuation Items that are Not Letters to the Translated Message\n",
    "        else:\n",
    "            translated_message += letter\n",
    "    return translated_message\n",
    "\n",
    "first_message = \"jxu evviuj veh jxu iusedt cuiiqwu yi vekhjuud.\"\n",
    "\n",
    "# Use the Decoder Function to Determine the Message from Vishal with the Offset of 10 Like Before\n",
    "\n",
    "print(decoder(first_message, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "performing multiple caesar ciphers to code your messages is even more secure!\n"
     ]
    }
   ],
   "source": [
    "# Use the Decoded First Message and the New Offset of 14 to determine the Translated Second Message\n",
    "\n",
    "second_message = \"bqdradyuzs ygxfubxq omqemd oubtqde fa oapq kagd yqeemsqe ue qhqz yadq eqogdq!\"\n",
    "print(decoder(second_message, 14))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 4: Solving a Caesar Cipher without knowing the shift value\n",
    "\n",
    "Awesome work! While you were working to decode his last two messages, Vishal sent over another letter! He's really been bitten by the crytpo-bug. Read it and see what interesting task he has lined up for you this time.\n",
    "\n",
    "            Hello again friend! I knew you would love the Caesar Cipher, it's a cool simple way to encrypt messages. Did you know that back in Caesar's time, it was considered a very secure way of communication and it took a lot of effort to crack if you were unaware of the value of the shift? That's all changed with computers! Now we can brute force these kinds of ciphers very quickly, as I'm sure you can imagine.\n",
    "            \n",
    "            To test your cryptography skills, this next coded message is going to be harder than the last couple to crack. It's still going to be coded with a Caesar Cipher but this time I'm not going to tell you the value of   the shift. You'll have to brute force it yourself.\n",
    "            \n",
    "            Here's the coded message:\n",
    "            \n",
    "            vhfinmxkl atox kxgwxkxw tee hy maxlx hew vbiaxkl tl hulhexmx. px'ee atox mh kxteer lmxi ni hnk ztfx by px ptgm mh dxxi hnk fxlltzxl ltyx.\n",
    "            \n",
    "            Good luck!\n",
    "            \n",
    "Decode Vishal's most recent message and see what it says!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "offest = 1\n",
      "\n",
      "wigjonylm bupy lyhxylyx uff iz nbymy ifx wcjbylm um ivmifyny. qy'ff bupy ni lyuffs mnyj oj iol augy cz qy quhn ni eyyj iol gymmuaym muzy.\n",
      "\n",
      "offest = 2\n",
      "\n",
      "xjhkpozmn cvqz mziyzmzy vgg ja ocznz jgy xdkczmn vn jwnjgzoz. rz'gg cvqz oj mzvggt nozk pk jpm bvhz da rz rvio oj fzzk jpm hznnvbzn nvaz.\n",
      "\n",
      "offest = 3\n",
      "\n",
      "ykilqpano dwra najzanaz whh kb pdaoa khz yeldano wo kxokhapa. sa'hh dwra pk nawhhu opal ql kqn cwia eb sa swjp pk gaal kqn iaoowcao owba.\n",
      "\n",
      "offest = 4\n",
      "\n",
      "zljmrqbop exsb obkaboba xii lc qebpb lia zfmebop xp lyplibqb. tb'ii exsb ql obxiiv pqbm rm lro dxjb fc tb txkq ql hbbm lro jbppxdbp pxcb.\n",
      "\n",
      "offest = 5\n",
      "\n",
      "amknsrcpq fytc pclbcpcb yjj md rfcqc mjb agnfcpq yq mzqmjcrc. uc'jj fytc rm pcyjjw qrcn sn msp eykc gd uc uylr rm iccn msp kcqqyecq qydc.\n",
      "\n",
      "offest = 6\n",
      "\n",
      "bnlotsdqr gzud qdmcdqdc zkk ne sgdrd nkc bhogdqr zr narnkdsd. vd'kk gzud sn qdzkkx rsdo to ntq fzld he vd vzms sn jddo ntq ldrrzfdr rzed.\n",
      "\n",
      "offest = 7\n",
      "\n",
      "computers have rendered all of these old ciphers as obsolete. we'll have to really step up our game if we want to keep our messages safe.\n",
      "\n",
      "offest = 8\n",
      "\n",
      "dpnqvufst ibwf sfoefsfe bmm pg uiftf pme djqifst bt pctpmfuf. xf'mm ibwf up sfbmmz tufq vq pvs hbnf jg xf xbou up lffq pvs nfttbhft tbgf.\n",
      "\n",
      "offest = 9\n",
      "\n",
      "eqorwvgtu jcxg tgpfgtgf cnn qh vjgug qnf ekrjgtu cu qduqngvg. yg'nn jcxg vq tgcnna uvgr wr qwt icog kh yg ycpv vq mggr qwt oguucigu uchg.\n",
      "\n",
      "offest = 10\n",
      "\n",
      "frpsxwhuv kdyh uhqghuhg doo ri wkhvh rog flskhuv dv revrohwh. zh'oo kdyh wr uhdoob vwhs xs rxu jdph li zh zdqw wr nhhs rxu phvvdjhv vdih.\n",
      "\n",
      "offest = 11\n",
      "\n",
      "gsqtyxivw lezi virhivih epp sj xliwi sph gmtlivw ew sfwspixi. ai'pp lezi xs vieppc wxit yt syv keqi mj ai aerx xs oiit syv qiwwekiw weji.\n",
      "\n",
      "offest = 12\n",
      "\n",
      "htruzyjwx mfaj wjsijwji fqq tk ymjxj tqi hnumjwx fx tgxtqjyj. bj'qq mfaj yt wjfqqd xyju zu tzw lfrj nk bj bfsy yt pjju tzw rjxxfljx xfkj.\n",
      "\n",
      "offest = 13\n",
      "\n",
      "iusvazkxy ngbk xktjkxkj grr ul znkyk urj iovnkxy gy uhyurkzk. ck'rr ngbk zu xkgrre yzkv av uax mgsk ol ck cgtz zu qkkv uax skyygmky yglk.\n",
      "\n",
      "offest = 14\n",
      "\n",
      "jvtwbalyz ohcl yluklylk hss vm aolzl vsk jpwolyz hz vizvslal. dl'ss ohcl av ylhssf zalw bw vby nhtl pm dl dhua av rllw vby tlzzhnlz zhml.\n",
      "\n",
      "offest = 15\n",
      "\n",
      "kwuxcbmza pidm zmvlmzml itt wn bpmam wtl kqxpmza ia wjawtmbm. em'tt pidm bw zmittg abmx cx wcz oium qn em eivb bw smmx wcz umaaioma ainm.\n",
      "\n",
      "offest = 16\n",
      "\n",
      "lxvydcnab qjen anwmnanm juu xo cqnbn xum lryqnab jb xkbxuncn. fn'uu qjen cx anjuuh bcny dy xda pjvn ro fn fjwc cx tnny xda vnbbjpnb bjon.\n",
      "\n",
      "offest = 17\n",
      "\n",
      "mywzedobc rkfo boxnobon kvv yp droco yvn mszrobc kc ylcyvodo. go'vv rkfo dy bokvvi cdoz ez yeb qkwo sp go gkxd dy uooz yeb wocckqoc ckpo.\n",
      "\n",
      "offest = 18\n",
      "\n",
      "nzxafepcd slgp cpyopcpo lww zq espdp zwo ntaspcd ld zmdzwpep. hp'ww slgp ez cplwwj depa fa zfc rlxp tq hp hlye ez vppa zfc xpddlrpd dlqp.\n",
      "\n",
      "offest = 19\n",
      "\n",
      "oaybgfqde tmhq dqzpqdqp mxx ar ftqeq axp oubtqde me aneaxqfq. iq'xx tmhq fa dqmxxk efqb gb agd smyq ur iq imzf fa wqqb agd yqeemsqe emrq.\n",
      "\n",
      "offest = 20\n",
      "\n",
      "pbzchgref unir eraqrerq nyy bs gurfr byq pvcuref nf bofbyrgr. jr'yy unir gb ernyyl fgrc hc bhe tnzr vs jr jnag gb xrrc bhe zrffntrf fnsr.\n",
      "\n",
      "offest = 21\n",
      "\n",
      "qcadihsfg vojs fsbrsfsr ozz ct hvsgs czr qwdvsfg og cpgczshs. ks'zz vojs hc fsozzm ghsd id cif uoas wt ks kobh hc yssd cif asggousg gots.\n",
      "\n",
      "offest = 22\n",
      "\n",
      "rdbejitgh wpkt gtcstgts paa du iwtht das rxewtgh ph dqhdatit. lt'aa wpkt id gtpaan hite je djg vpbt xu lt lpci id ztte djg bthhpvth hput.\n",
      "\n",
      "offest = 23\n",
      "\n",
      "secfkjuhi xqlu hudtuhut qbb ev jxuiu ebt syfxuhi qi eriebuju. mu'bb xqlu je huqbbo ijuf kf ekh wqcu yv mu mqdj je auuf ekh cuiiqwui iqvu.\n",
      "\n",
      "offest = 24\n",
      "\n",
      "tfdglkvij yrmv iveuvivu rcc fw kyvjv fcu tzgyvij rj fsjfcvkv. nv'cc yrmv kf ivrccp jkvg lg fli xrdv zw nv nrek kf bvvg fli dvjjrxvj jrwv.\n",
      "\n",
      "offest = 25\n",
      "\n",
      "ugehmlwjk zsnw jwfvwjwv sdd gx lzwkw gdv uahzwjk sk gtkgdwlw. ow'dd zsnw lg jwsddq klwh mh gmj ysew ax ow osfl lg cwwh gmj ewkksywk ksxw.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "coded_message = \"vhfinmxkl atox kxgwxkxw tee hy maxlx hew vbiaxkl tl hulhexmx. px'ee atox mh kxteer lmxi ni hnk ztfx by px ptgm mh dxxi hnk fxlltzxl ltyx.\"\n",
    "\n",
    "# To Use Brute Force to Decode the Message Means to Run Through Each Possible Shift and Return the Output Until\n",
    "# There is a Message that is Readable in English. This will Involve Creating a Range and Iterating through\n",
    "# Each Offset Shift in the Range\n",
    "\n",
    "# Create a For Loop to Iterate through All Possible Offesets using a Range Function\n",
    "for i in range(1,26):\n",
    "    # Print Statement to ID which Offset is Being Used, Convert Integer to String\n",
    "    print(\"offest = \" + str(i))\n",
    "    # Print while Using Line Skips to More Easily Read Output\n",
    "    print(\"\\n\" + decoder(coded_message, i) + \"\\n\")\n",
    "    \n",
    " # Offset 7 is Being Used for this Particular Caesar Cipher   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Step 5: The Vigenère Cipher\n",
    "\n",
    "Great work! While you were working on the brute force cracking of the cipher, Vishal sent over another letter. That guy is a letter machine!\n",
    "\n",
    "            Salutations! As you can see, technology has made brute forcing simple ciphers like the Caesar Cipher extremely easy, and us crypto-enthusiasts have had to get more creative and use more complicated ciphers. This next cipher I'm going to teach you is the Vigenère Cipher, invented by an Italian cryptologist named Giovan Battista Bellaso (cool name eh?) in the 16th century, but named after another cryptologist from the 16th century, Blaise de Vigenère.\n",
    "            \n",
    "           The Vigenère Cipher is a polyalphabetic substitution cipher, as opposed to the Caesar Cipher which was a monoalphabetic substitution cipher. What this means is that opposed to having a single shift that is applied to every letter, the Vigenère Cipher has a different shift for each individual letter. The value of the shift for each letter is determined by a given keyword.\n",
    "           \n",
    "           Consider the message\n",
    "           \n",
    "               barry is the spy\n",
    "\n",
    "           If we want to code this message, first we choose a keyword. For this example, we'll use the keyword\n",
    "           \n",
    "               dog\n",
    "               \n",
    "           Now we use the repeat the keyword over and over to generate a _keyword phrase_ that is the same length as the message we want to code. So if we want to code the message \"barry is the spy\" our _keyword phrase_ is \"dogdo gd ogd ogd\". Now we are ready to start coding our message. We shift the each letter of our message by the place value of the corresponding letter in the keyword phrase, assuming that \"a\" has a place value of 0, \"b\" has a place value of 1, and so forth. Remember, we zero-index because this is Python we're talking about!\n",
    "\n",
    "                        message:       b  a  r  r  y    i  s   t  h  e   s  p  y\n",
    "                \n",
    "                 keyword phrase:       d  o  g  d  o    g  d   o  g  d   o  g  d\n",
    "                 \n",
    "          resulting place value:       4  14 15 12 16   24 11  21 25 22  22 17 5\n",
    "      \n",
    "            So we shift \"b\", which has an index of 1, by the index of \"d\", which is 3. This gives us an place value of 4, which is \"e\". Then continue the trend: we shift \"a\" by the place value of \"o\", 14, and get \"o\" again, we shift \"r\" by the place value of \"g\", 15, and get \"x\", shift the next \"r\" by 12 places and \"u\", and so forth. Once we complete all the shifts we end up with our coded message:\n",
    "            \n",
    "                eoxum ov hnh gvb\n",
    "                \n",
    "            As you can imagine, this is a lot harder to crack without knowing the keyword! So now comes the hard part. I'll give you a message and the keyword, and you'll see if you can figure out how to crack it! Ready? Okay here's my message:\n",
    "            \n",
    "                dfc aruw fsti gr vjtwhr wznj? vmph otis! cbx swv jipreneo uhllj kpi rahjib eg fjdkwkedhmp!\n",
    "                \n",
    "            and the keyword to decode my message is \n",
    "            \n",
    "                friends\n",
    "                \n",
    "            Because that's what we are! Good luck friend!\n",
    "           \n",
    "And there it is. Vishal has given you quite the assignment this time! Try to decode his message. It may be helpful to create a function that takes two parameters, the coded message and the keyword and then work towards a solution from there.\n",
    "\n",
    "**NOTE:** Watch out for spaces and punctuation! When there's a space or punctuation mark in the original message, there should be a space/punctuation mark in the corresponding repeated-keyword string as well! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "you were able to decode this? nice work! you are becoming quite the expert at crytography!\n"
     ]
    }
   ],
   "source": [
    "# Define a Function to Accept 2 Parameters, a Coded Message and Keyword that is the Value of the Shift\n",
    "\n",
    "def vigenere_decoder(coded_message, keyword):\n",
    "    # Define 2 Variables, one for the Index of the Letter being Iterated and the Other for the Generated Keyword Phrase\n",
    "    letter_index = 0\n",
    "    keyword_phrase = ''\n",
    "    # Use a For Loop to Iterate the Length of the Coded Message\n",
    "    for i in range(0,len(coded_message)):\n",
    "        # If the Character in the Message is a Punctuation, Add it to the Keyword Phrase using Plus Equals Operator\n",
    "        if coded_message[i] in punctuation:\n",
    "            keyword_phrase += coded_message[i]\n",
    "        # Use an Else Statement if it is Not Punctuation to Add the Indexed Keyword Letter to the Keyword Phrase\n",
    "        else:\n",
    "            keyword_phrase += keyword[letter_index]\n",
    "            # Advance the Letter Index by One Place for Each Iteration, Ensure it Falls in the Range with a Modulus\n",
    "            letter_index = (letter_index+1)%len(keyword)\n",
    "    # Define an Empty Variable to Hold the String of the Translated Message\n",
    "    translated_message = \"\"\n",
    "    \n",
    "    # Use Another For Loop to Now Add to the Translated Message Variable, Iterating the Length of the Input Message\n",
    "    for i in range(0,len(coded_message)):    \n",
    "        # For All Letters that Are Not Punctuation\n",
    "        if coded_message[i] not in punctuation:\n",
    "            # Create a Variable to Hold the Value of the Character in the Coded Message and Subtract the Alphanumeric\n",
    "            # Value of the Keyword Phrase for the Letter Being Iterated\n",
    "            length = alphabet.find(coded_message[i]) - alphabet.find(keyword_phrase[i])\n",
    "            # Add the Decoded Letter to the Translated Message using the Plus Equals Operator at Each Index\n",
    "            translated_message += alphabet[length % 26]\n",
    "        # Use an Else Statement to Otherwise Add Punctuation\n",
    "        else:\n",
    "            translated_message += coded_message[i]\n",
    "    return translated_message\n",
    "\n",
    "message = \"dfc aruw fsti gr vjtwhr wznj? vmph otis! cbx swv jipreneo uhllj kpi rahjib eg fjdkwkedhmp!\"\n",
    "keyword = \"friends\"\n",
    "\n",
    "print(vigenere_decoder(message, keyword))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Step 6: Send a message with the  Vigenère Cipher\n",
    "Great work decoding the message. For your final task, write a function that can encode a message using a given keyword and write out a message to send to Vishal!\n",
    "\n",
    "*As a bonus, try calling your decoder function on the result of your encryption function. You should get the original message back!*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k dogpo loig uehic fsrp hbxi es rb voie atxvbwa yay! elwf kz aiidsar!\n",
      "i would have never been able to do this without you! this is awesome!\n"
     ]
    }
   ],
   "source": [
    "# Running the Coder Function to Create a Message for Vishal using the Vigenère Cipher\n",
    "\n",
    "# Define a Function to Accept 2 Parameters, an Uncoded Message and Keyword that is the Value of the Shift\n",
    "def vigenere_coder(message, keyword):\n",
    "    # Define 2 Variables, one for the Index of the Letter being Iterated and the Other for the Generated Keyword Phrase\n",
    "    letter_index = 0\n",
    "    keyword_phrase = ''\n",
    "    # Use a For Loop to Iterate the Length of the Uncoded Message\n",
    "    for i in range(0,len(message)):\n",
    "        # If the Character in the Message is a Punctuation, Add it to the Keyword Phrase using Plus Equals Operator\n",
    "        if message[i] in punctuation:\n",
    "            keyword_phrase += message[i]\n",
    "        # Use an Else Statement if it is Not Punctuation to Add the Indexed Keyword Letter to the Keyword Phrase\n",
    "        else:\n",
    "            keyword_phrase += keyword[letter_index]\n",
    "            # Advance the Letter Index by One Place for Each Iteration, Ensure it Falls in the Range with a Modulus\n",
    "            letter_index = (letter_index+1)%len(keyword)\n",
    "    # Define an Empty Variable to Hold the String of the Translated Message\n",
    "    translated_message = \"\"\n",
    "    \n",
    "    # Use Another For Loop to Now Add to the Translated Message Variable, Iterating the Length of the Input Message\n",
    "    for i in range(0,len(message)):\n",
    "        # For All Letters that Are Not Punctuation\n",
    "        if message[i] not in punctuation:\n",
    "            # Create a Variable to Hold the Value of the Character in the Uncoded Message and Subtract the Alphanumeric\n",
    "            # Value of the Keyword Phrase for the Letter Being Iterated\n",
    "            length = alphabet.find(message[i]) + alphabet.find(keyword_phrase[i])\n",
    "            # Add the Coded Letter to the Translated Message using the Plus Equals Operator at Each Index\n",
    "            translated_message += alphabet[length % 26]\n",
    "        # Use an Else Statement to Otherwise Add Punctuation\n",
    "        else:\n",
    "            translated_message += message[i]\n",
    "    return translated_message\n",
    "\n",
    "message_for_vishal = \"i would have never been able to do this without you! this is awesome!\"\n",
    "keyword = \"chameleon\"\n",
    "\n",
    "print(vigenere_coder(message_for_vishal, keyword))\n",
    "print(vigenere_decoder(vigenere_coder(message_for_vishal, keyword), keyword))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conclusion\n",
    "Over the course of this project you've learned about two different cipher methods and have used your Python skills to code and decode messages. There are all types of other facinating ciphers out there to explore, and Python is the perfect language to implement them with, so go exploring! "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}