{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chiffrage de César\n",
    "\n",
    "## 1- Présentation\n",
    "\n",
    "Le **chiffrage de César** : c'est une technique de chiffrement pour (tenter de) rendre un texte incompréhensible pour toute personne n'ayant pas la *clé de déchiffrement*. Cette technique a été utilisée par Jules César pour éviter que des information secrètes transmises par courrier ne tombe aux mains des ennemis... Le texte obtenu n'est pas très compliqué à déchiffrer car il fonctionne simplement par décalage de lettres (comme indiqué dans cette image tirée de wikipedia):\n",
    "\n",
    "  ![image : 320px-Caesar3.png](images/320px-Caesar3.png)\n",
    "  \n",
    "  \n",
    "Pour éviter le problème des caractères particuliers (é, è, ï, ç ...) **on ne travaillera que sur des textes écrits en lettres capitales**\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2- Travail préparatoire :\n",
    "\n",
    "On définit ci-dessous une chaîne de caractères représentant l'alphabet complet en lettres majuscules.\n",
    "Une chaîne de caractères est une séquence : chaque élément qui la compose a donc un index lié à sa position :\n",
    " - 0 pour A\n",
    " - 1 pour B\n",
    " ...\n",
    " - 25 pour Z (... la 26ème lettre)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
    "\n",
    "# on peut obtenir le caractère ayant l'index i avec  alphabet[i] comme par exemple :\n",
    "i = 5\n",
    "alphabet[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compléter le code de la fonction rang_lettre(carac) qui permet de récupérer le rang (= l'index) auquel se trouve une des lettres de l'alphabet.\n",
    "\n",
    "Par exemple **rang_lettre('F')** doit renvoyer la valeur **5** (le rang démarre à 0 avec la lettre 'A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rang_lettre(carac):\n",
    "    \"\"\"\" fonction qui renvoie le rang du caractère 'carac' dans alphabet\n",
    "    :param carac: (str) un caractère\n",
    "    :return: (int) le rang du caractère dans l'alphabet ;si non trouvé : -1\n",
    "    Exemples :\n",
    "    >>> rang_lettre('A')\n",
    "    0\n",
    "    >>> rang_lettre('Z')\n",
    "    25\n",
    "    \"\"\"\n",
    "    for i in range(26):\n",
    "        if carac ==  ???\n",
    "            return ???\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de la fonction rang_lettre(carac) :\n",
    "rang_lettre('Z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais on peut aussi vouloir faire la transformation inverse : on donne le rang et on récupère le caractère.\n",
    "\n",
    "Ecrire le code de la fonction suivante qui renvoie la lettre correspondant au rang donné en argument :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lettre_rang(rang):\n",
    "    \"\"\"\" fonction qui renvoie la lettre de l'alphabet correspondant à son rang\n",
    "    :param rang: (int) le rang de la lettre\n",
    "    :return: (str) la lettre majuscule associée à rang\n",
    "    Exemple :\n",
    "    >>> lettre_rang(0)\n",
    "    'A'\n",
    "    >>> lettre_rang(4)\n",
    "    'E'\n",
    "    \"\"\"\n",
    "    # Code à écrire :\n",
    "    ???\n",
    "    ...\n",
    "    ???\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test de la fonction lettre_rang(rang) :\n",
    "lettre_rang(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Munis de ces fonctions rang_lettre() et lettre_rang(), on va pouvoir écrire le code de la fonction decal_lettre(carac, dec). \n",
    "\n",
    "*Elle vous est donnée ci-dessous et son fonctionnement sera expliqué en classe.*\n",
    "\n",
    "Vérifier dans la cellule suivante qu'elle donne bien les résultats donnés en exemple dans la docstring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decal_lettre(carac, dec):\n",
    "    \"\"\" fonction qui produit une lettre décalée de 'dec' par rapport \n",
    "    à la lettre de départ 'carac'\n",
    "    :param carac: (str) la lettre à décaler\n",
    "    :param dec: (int) le décalage à réaliser\n",
    "    :return: (str) la lettre décalée ; si le caractère initial n'est pas une lettre\n",
    "    il est renvoyé tel quel\n",
    "    Exemple :\n",
    "    >>> decal_lettre('A', 3)\n",
    "    'D'\n",
    "    >>> decal_lettre('Y', 3)\n",
    "    'B'\n",
    "    >>> decal_lettre('!', 5)\n",
    "    '!'\n",
    "    \"\"\"\n",
    "    if carac in alphabet:\n",
    "        return lettre_rang((rang_lettre(carac) + dec)%26)\n",
    "    else:\n",
    "        return carac\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de la fonction decal_lettre(carac, dec) :\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut alors réaliser le chiffrage d'un texte complet :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chiffrage_cesar(texte, decalage):\n",
    "    \"\"\"\" fonction qui réalise le chiffrage de César d'un texte.\n",
    "    :param texte: (str) le texte (en majuscules) à coder\n",
    "    :param decalage: (int) le decalage à appliquer pour réaliser le chiffrement\n",
    "    \"\"\"\n",
    "    texte_chiffre = ''     # on déclare une variable de type str mais initialement vide\n",
    "                           # et que l'on va compléter lettre par lettre pour former le texte chiffré complet\n",
    "    \n",
    "    # votre code à écrire ici !\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de la fonction chiffrage_cesar(texte, decalage):\n",
    "chiffrage_cesar('VOICI LE TEXTE A CHIFFRER !', 3)"
   ]
  },
  {
   "source": [
    "## 4- Déchiffrer un texte\n",
    "\n",
    "La personne qui reçoit le texte chiffré doit **disposer par avance de la clé de déchiffrement** pour pouvoir récupérer le texte \"en clair\".\n",
    "\n",
    "Ainsi, si le décalage utilisé pour chiffrer le texte vaut 3, alors à la réception il faut décaler là aussi de 3 lettres mais en sens inverse :\n",
    "\n",
    "![image : dechiffrement_cesar.png](images/dechiffrement_cesar.png)\n",
    "\n",
    "Ecrire la fonction **dechiffre_cesar(texte_chiffre, cle)** dans laquelle le paramètre **cle** est le décalage utilisé lors du chiffrement :\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decrypter_cesar(texte):\n",
    "    \"\"\" DOCSTRING A COMPLETER\n",
    "    \n",
    "    \"\"\"\n",
    "    # code de la fonction :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test de la fonction decrypter_cesar(texte) sur le texte mystere :\n",
    "mystere = 'YRLFL OH WHAWH D FKLIIUHU !'"
   ]
  },
  {
   "source": [
    "## 5- Décrypter un texte\n",
    "\n",
    "On a un texte incompréhensible :\n",
    "\n",
    "incomprehensible = **\"KMBBM IKBQDQBM VWCA I XMZUQA LM DWQZ CV MFMUXTM LM KPQNNZMUMVB\"**\n",
    "\n",
    "et on suppose qu'il est chiffré avec le code de César. Pourrait-on essayer de le décrypter ?\n",
    "\n",
    "(**décrypter** = réussir par différentes techniques à obtenir l'information compréhensible, sans posséder la clé de chiffrement )\n",
    "\n",
    "Ecrire un programme qui vous permet de décrypter le texte *incomprehensible* et de récupérer la *clé de chiffrement* utilisée.\n",
    "\n",
    "Vérifier ensuite que le texte : **\"JZIDW ! DWCA IDMH BZWCDM TI KTM : PCQB\"** est chiffré avec la même clé."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "incomprehensible = \"KMBBM IKBQDQBM VWCA I XMZUQA LM DWQZ CV MFMUXTM LM KPQNNZMUMVB\"\n",
    "\n",
    "# votre code de décryptage :\n"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}