Correction_BattleDev4.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Correction BattleDev4.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPUbqlDRSOUlWDXwVumYOvk",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/GeoLabUniLaSalle/Python/blob/main/Correction_BattleDev4.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGQuPEjWYJBW"
      },
      "source": [
        "# **Battle Dev !**\n",
        "\n",
        "Vous avez 1h30 pour résoudre les 4 problèmes suivants. Bon courage :)\n",
        "\n",
        "## **Exercice 1 : Intrusion à l'usine ★☆☆**\n",
        "\n",
        "**Objectif**\n",
        "\n",
        "L'infame groupe mafieux \"L'Equipe Roquette\" a infiltré une usine de téléphones mobiles dans le but de voler vos secrets et ceux de vos concitoyens.\n",
        "Afin de ne pas éveiller trop de soupçons, seule une ligne de production a été compromise, mais tous les appareils qu'elle produit ont été infectés.\n",
        "Cependant, le système d'exploitation d'un téléphone infecté a un numéro de version légèrement différent de celui des autres.\n",
        "A partir d'un échantillon de téléphones, écrivez un programme qui trouve celui dont le numéro de version est différent des autres.\n",
        "\n",
        "**Format des données**\n",
        "\n",
        "*Entrée*\n",
        "\n",
        "Ligne 1 : un entier N compris entre 3 et 100, le nombre de téléphones de l'échantillon\n",
        "\n",
        "Lignes 2 à N+1 : deux entiers naturels p et v, respectivement le numéro de la ligne de production du téléphone et la version de son OS\n",
        "\n",
        "\n",
        "On vous garantit qu'une seule ligne de production produit des téléphones d'une version différente.\n",
        "\n",
        "\n",
        "*Sortie*\n",
        "\n",
        "Ligne 1: un entier P, le numéro de la ligne de production compromise\n",
        "\n",
        "\n",
        "*Exemple*\n",
        "\n",
        "Pour l'échantillon suivant :\n",
        "\n",
        "5\n",
        "\n",
        "1 13\n",
        "\n",
        "27 13\n",
        "\n",
        "14 13\n",
        "\n",
        "42 14\n",
        "\n",
        "15 13\n",
        "\n",
        "La ligne de production compromise est celle de numéro 42"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ODGfDRPOYGwQ"
      },
      "source": [
        "## **Données**\n",
        "\n",
        "*Accès aux données*"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jlu0JxHXYkaM",
        "outputId": "7104976f-dd7c-4440-c57d-6ba1e610da98"
      },
      "source": [
        "import csv\n",
        "filedir = ('https://cours.unilasalle.fr/courses/SG4007/document/Exercices_Python/Intrusion_a_l_usine/')\n",
        "\n",
        "import ssl\n",
        "ssl._create_default_https_context = ssl._create_unverified_context\n",
        "\n",
        "import urllib.request\n",
        "\n",
        "for x in range(1,3):\n",
        "  f = urllib.request.urlopen(str(filedir+\"input\"+str(x)+\".txt\"))\n",
        "\n",
        "  data=[]\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "      data.append(line)\n",
        "  print('Entrée',x,':',data)\n",
        "\n",
        "  f = urllib.request.urlopen(str(filedir+\"output\"+str(x)+\".txt\"))\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "  print('Sortie',x,':',line,'\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entrée 1 : ['3', '2867 66', '972 70', '6702 70']\n",
            "Sortie 1 : 2867 \n",
            "\n",
            "Entrée 2 : ['5', '6127 46', '2710 23', '2260 46', '8263 46', '7015 46']\n",
            "Sortie 2 : 2710 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ibgG9zWLu4Vg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e682a323-d369-433d-ad99-7ad1cc27b7b2"
      },
      "source": [
        "lines = ['3', '2867 66', '972 70', '6702 70']\n",
        "\n",
        "tel = []\n",
        "num = []\n",
        "for i in lines[1:]:\n",
        "  tel.append(int(i.split()[0]))\n",
        "  num.append(int(i.split()[1]))\n",
        "for i in range(int(lines[0])):\n",
        "  if num.count(num[i])==1:\n",
        "    print(tel[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2867\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6p6eR4lLumXa"
      },
      "source": [
        "## **Exercice 2 : Casser le code ★☆☆**\n",
        "\n",
        "**Objectif**\n",
        "\n",
        "Des messages codés ont été trouvés dans le virus caché sur les téléphones piratés !\n",
        "Après des heures d'analyse, vous pensez avoir trouvé un algorithme (qui dépend d'un nombre N) pour les décoder.\n",
        "Il consiste à faire N groupes de caractères en prenant 1 caractère sur N du message, puis les N qui suivent chacun de ces caractères, et ainsi de suite jusqu'à arriver à la fin du message.\n",
        "En mettant ensuite ces groupes bout-à-bout dans leur ordre d'apparition, on retrouve le message d'origine.\n",
        "Votre mission est donc de créer un programme qui pourra être utilisé pour automatiser cette tâche fastidieuse, et décoder n'importe quel message à partir de ce dernier et d'une valeur de N.\n",
        "\n",
        "\n",
        "**Format des données**\n",
        "\n",
        "*Entrée*\n",
        "\n",
        "Ligne 1 : l'entier N compris entre 2 et 20\n",
        "\n",
        "Ligne 2 : le message à décoder (de taille maximale 500, sans espaces)\n",
        "\n",
        "On vous garantit que la longueur du message à décoder est un multiple de N.\n",
        "\n",
        "*Sortie*\n",
        "\n",
        "Sur une ligne, le message décodé.\n",
        "\n",
        "*Exemple*\n",
        "\n",
        "Pour l'échantillon suivant :\n",
        "\n",
        "3\n",
        "\n",
        "RFsarAbi1Dt4eeh\n",
        "\n",
        "Une fois décodé, le message devient RabDeFritesA14h\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ng3ND4XyrK6W",
        "outputId": "a3087f03-2c89-497c-d87f-8204142ff41d"
      },
      "source": [
        "import csv\n",
        "filedir = ('https://cours.unilasalle.fr/courses/SG4007/document/Exercices_Python/Casser_le_code/')\n",
        "\n",
        "import ssl\n",
        "ssl._create_default_https_context = ssl._create_unverified_context\n",
        "\n",
        "import urllib.request\n",
        "\n",
        "for x in range(1,4):\n",
        "  f = urllib.request.urlopen(str(filedir+\"input\"+str(x)+\".txt\"))\n",
        "\n",
        "  data=[]\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "      data.append(line)\n",
        "  print('Entrée',x,':',data)\n",
        "\n",
        "  f = urllib.request.urlopen(str(filedir+\"output\"+str(x)+\".txt\"))\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "  print('Sortie',x,':',line,'\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entrée 1 : ['5', 'II7eTubnsKxvhkVaaMg0OLBjan1qAzgnWeuxnUiAk9o7fFZ4ZG9ZMVc67QshpRSglhJ9GA6sOsWEmMeHHqHcuyIVszCMREy4wi00xGcPYGOh4cI926lxrSphiVFrRgfwRVkuiNdiaNHURlUt9CsYjXxWw9hziTI9gvUE58UA86PqSl8L51o1Gb5zV8sl6i7fxEwe2nMB7qynrS3rLR9ZM3zjI0i0ZYMF7tvw6l']\n",
            "Sortie 1 : IuxaOngxkF96ph6EHyC4xGIxigkiRCxzg8PLG87e7S9jZtIbvaL1nn9ZZ7RJsmqIMwGO9rVfualsWivUq5bsf2q3ZIYv7nhMBqWUo4MQS9OMHVRich2SFwiNUYwTUAS15lxnyrM0MweskgjAei7ZVsgGsecsE0P46prRNHtj9IE8loz6EMnL3iF6TKV0azuAfGchlAWHuzy0YclhRVdU9Xh95681ViwBrRz07l \n",
            "\n",
            "Entrée 2 : ['20', 'orYfMJmNYE1gEZSyLfUbjw8Wt2tWpfxHnCEnvZBykXB034y4dEF4S9B4Vhpfuzku4nehHMqUUeX2YSBTwnpPP2LLE3ObFnBOTgOYWqoIppAguyUo0nuF9iLk']\n",
            "Sortie 2 : ojkuwWrwXznqY8BkpofW0uPIMt34PpJ24n2pmtyeLANW4hLgYpdHEuEfEM3y1xFqOUgH4UboEnSUF0ZC9ennSEBXBuyn42OFLvVYT9fZhSgiUBpBOLbyfTYk \n",
            "\n",
            "Entrée 3 : ['5', 'hi01HQlVlf8I7fhurIjsFvPdq6XfMVRmtuaUUYwb9l19eHjdXI9LRDnLEVWTvM43yBt0DC6MhlmZBbM5467RBLzeRHy8zzxIu0OI']\n",
            "Sortie 3 : hQ8uF6RU9H9LvB6Z4LyIilIrvXmUljLEMtMB6z8u0V7IPftY1dRV40hb7ez01lfjdMuw9XDW3DlMRRzOHfhsqVabeInTyCm5BHxI \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LHfsjUasvHPH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e35604e3-8ddc-4b8f-9c80-dd6928304c4b"
      },
      "source": [
        "lines = ['5', 'II7eTubnsKxvhkVaaMg0OLBjan1qAzgnWeuxnUiAk9o7fFZ4ZG9ZMVc67QshpRSglhJ9GA6sOsWEmMeHHqHcuyIVszCMREy4wi00xGcPYGOh4cI926lxrSphiVFrRgfwRVkuiNdiaNHURlUt9CsYjXxWw9hziTI9gvUE58UA86PqSl8L51o1Gb5zV8sl6i7fxEwe2nMB7qynrS3rLR9ZM3zjI0i0ZYMF7tvw6l']\n",
        "\n",
        "mot=\"\"\n",
        "pas=int(lines[0])\n",
        "for i in range(pas):\n",
        "  for j in range(len(lines[1])):\n",
        "    if (i+j)%pas==0:\n",
        "      mot+=lines[1][j]\n",
        "print(mot)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "IuxaOngxkF96ph6EHyC4xGIxigkiRCxzg8PLG87e7S9jZtTKV0azuAfGchlAWHuzy0YclhRVdU9Xh95681ViwBrRz07leskgjAei7ZVsgGsecsE0P46prRNHtj9IE8loz6EMnL3iF67nhMBqWUo4MQS9OMHVRich2SFwiNUYwTUAS15lxnyrM0MwIbvaL1nn9ZZ7RJsmqIMwGO9rVfualsWivUq5bsf2q3ZIYv\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AxHjx5XjvMx4"
      },
      "source": [
        "## **Exercice 3 : Fenêtre de tir ★★☆**\n",
        "\n",
        "**Objectif**\n",
        "\n",
        "Félicitations ! Grâce à votre programme, les analystes ont pu identifier plusieurs messages codés cachés dans le virus, y compris l'adresse du quartier général de l'Equipe Roquette.\n",
        "Après plusieurs jours à surveiller les allers et venues aux abords du bâtiment, vos collègues ont pu établir le planning de chacun des ingénieurs qui surveillent le trafic réseau de l'organisation.\n",
        "Votre mission est maintenant de créer un programme qui identifie - si il existe - le créneau le plus long pendant lequel aucun d'entre eux n'est présent dans le bâtiment.\n",
        "Vous devez considérer que le planning donné est valable tous les jours, et que ce créneau peut se trouver pendant la nuit (de 23 heures à 2 heures du matin par exemple)\n",
        "\n",
        "**Format des données**\n",
        "\n",
        "*Entrée*\n",
        "\n",
        "Ligne 1 : un entier N le nombre d'ingénieurs (compris entre 1 et 20)\n",
        "\n",
        "Lignes 2 à N+1 : les horaires de chaque ingénieur au format hh:mm-hh:mm (chaque borne est incluse, c'est-à-dire que si un ingénieur part à 13h59 et un autre arrive à 14h00, le bureau n'est jamais vide)\n",
        "\n",
        "*Sortie*\n",
        "\n",
        "Sur une ligne, la plus grande plage horaire sans ingénieur, au format hh:mm-hh:mm (avec les zéros non-significatifs des heures et des minutes), ou le message IMPOSSIBLE si quelqu'un est toujours présent.\n",
        "\n",
        "En cas d'égalité, vous devrez renvoyer la plage horaire qui se termine le plus tôt dans la journée.\n",
        "\n",
        "*Exemple*\n",
        "\n",
        "Pour le planning suivant :\n",
        "\n",
        "3\n",
        "\n",
        "07:00-14:00\n",
        "\n",
        "09:00-16:00\n",
        "\n",
        "14:00-23:00\n",
        "\n",
        "\n",
        "La plus grande fenêtre de tir se situe sur la plage : 23:01-06:59"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z9dHS08ivKWc",
        "outputId": "66bb1c08-d730-4ada-f854-2049a4dbd97b"
      },
      "source": [
        "import csv\n",
        "filedir = ('https://cours.unilasalle.fr/courses/SG4007/document/Exercices_Python/Fenetre_de_tir/')\n",
        "\n",
        "import ssl\n",
        "ssl._create_default_https_context = ssl._create_unverified_context\n",
        "\n",
        "import urllib.request\n",
        "\n",
        "for x in range(1,3):\n",
        "  f = urllib.request.urlopen(str(filedir+\"input\"+str(x)+\".txt\"))\n",
        "\n",
        "  data=[]\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "      data.append(line)\n",
        "  print('Entrée',x,':',data)\n",
        "\n",
        "  f = urllib.request.urlopen(str(filedir+\"output\"+str(x)+\".txt\"))\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "  print('Sortie',x,':',line,'\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entrée 1 : ['9', '22:26-23:17', '06:23-06:39', '03:47-05:03', '05:14-05:31', '02:16-04:41', '15:28-16:27', '15:07-17:39', '21:01-23:32', '18:15-20:42']\n",
            "Sortie 1 : 06:40-15:06 \n",
            "\n",
            "Entrée 2 : ['19', '00:28-01:06', '03:45-03:59', '21:23-22:33', '04:35-05:42', '10:57-11:54', '14:14-15:21', '22:20-22:51', '00:07-00:13', '05:07-05:58', '08:20-09:00', '06:24-07:20', '23:02-23:37', '01:37-02:36', '21:59-22:01', '09:14-09:21', '23:34-00:07', '10:12-10:46', '15:40-15:59', '19:33-20:33']\n",
            "Sortie 2 : 16:00-19:32 \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4You-yNQvrva",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e73ea456-cc55-4210-eb64-2bbbdf2a3188"
      },
      "source": [
        "lines = ['19', '00:28-01:06', '03:45-03:59', '21:23-22:33', '04:35-05:42', '10:57-11:54', '14:14-15:21', '22:20-22:51', '00:07-00:13', '05:07-05:58', '08:20-09:00', '06:24-07:20', '23:02-23:37', '01:37-02:36', '21:59-22:01', '09:14-09:21', '23:34-00:07', '10:12-10:46', '15:40-15:59', '19:33-20:33']\n",
        "\n",
        "N = int(lines[0])\n",
        "\n",
        "def conversion(x):\n",
        "  return int(x[:2])*60+int(x[3:])\n",
        "\n",
        "def debut(x):\n",
        "  return x[:5]\n",
        "\n",
        "def fin(x):\n",
        "  return x[6:]\n",
        "\n",
        "def difference(x,y):\n",
        "  if y>x:\n",
        "    return y-x\n",
        "  else:\n",
        "    return 0\n",
        "\n",
        "def heure(x):\n",
        "  if(x//60>=10):\n",
        "    if(x%60>=10):\n",
        "      return str(x//60)+':'+str(x%60)\n",
        "    else:\n",
        "      return str(x//60)+':0'+str(x%60)\n",
        "  else:\n",
        "    if(x%60>10):\n",
        "      return '0'+str(x//60)+':'+str(x%60)\n",
        "    else:\n",
        "      return '0'+str(x//60)+':0'+str(x%60)\n",
        "\n",
        "l=[]\n",
        "for i in lines[1:]:\n",
        "  l.append([conversion(debut(i)),conversion(fin(i))])\n",
        "\n",
        "maxi=difference(l[-1][1],l[0][0])\n",
        "d=heure(l[-1][1]+1) + \"-\" + heure(l[0][0]-1)\n",
        "l.sort()\n",
        "\n",
        "for i in range(len(l)-1):\n",
        "  if difference(l[i][1],l[i+1][0])>maxi:\n",
        "    maxi=difference(l[i][1],l[i+1][0])\n",
        "    d=heure(l[i][1]+1) + \"-\" + heure(l[i+1][0]-1)\n",
        "\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16:00-19:32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qMjdTd2-UNd"
      },
      "source": [
        "## **Exercice 4 : La clé secrète ★★☆**\n",
        "\n",
        "**Objectif**\n",
        "\n",
        "Grâce à votre travail, il a été possible d'infiltrer le réseau et d'extraire des informations de la machine d'un des ingénieurs.\n",
        "Une partie de ces informations est cependant protégée par un système un peu particulier : en partant d'une suite de lettres donnée, vous ne pouvez qu'effectuer deux opérations pour entrer la clé secrète.\n",
        "Ces opérations sont :\n",
        "- Décaler toutes les lettres de la suite de la même valeur dans l'alphabet (par exemple, ABC -> BCD)\n",
        "- Décaler toutes les lettres de la suite vers la gauche (par exemple, ABC -> BCA)\n",
        "Connaissant une approximation de la clé secrète, vous voulez ainsi trouver la combinaison que l'on peut obtenir de cette manière qui a le plus de lettres en commun (et bien placées) avec cette dernière.\n",
        "\n",
        "**Format des données**\n",
        "\n",
        "*Entrée*\n",
        "\n",
        "Ligne 1 : un entier N représentant la taille des deux suites de lettres (compris entre 1 et 50)\n",
        "\n",
        "Ligne 2 : la valeur initiale de la suite de lettres\n",
        "\n",
        "Ligne 3 : la valeur de la suite à approcher\n",
        "\n",
        "Les suites de lettres seront toujours données en minuscules.\n",
        "\n",
        "*Sortie*\n",
        "\n",
        "Sur une ligne, la suite de lettres la plus proche possible de la suite à approcher, à partir de la suite initiale et à l'aide des transformations décrites ci-dessus.\n",
        "\n",
        "*Exemple*\n",
        "\n",
        "Pour les suites de lettres suivantes :\n",
        "\n",
        "9\n",
        "\n",
        "cyxcrclqj\n",
        "\n",
        "petitchat\n",
        "\n",
        "La séquence la plus proche que l'on peut générer est : potitchat.\n",
        "\n",
        "Pour cela, on décale toutes les lettres d'un cran vers la gauche pour obtenir yxcrclqjc, puis on décale toutes les lettres de 9 places en arrière dans l'alphabet pour obtenir potitchat, avec une correspondance de 9 lettres sur 10.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02b2068b-40ee-44ba-ed15-76ebd763c2ba",
        "id": "8z7dCaYC-mvD"
      },
      "source": [
        "import csv\n",
        "filedir = ('https://cours.unilasalle.fr/courses/SG4007/document/Exercices_Python/La_cle_secrete/')\n",
        "\n",
        "import ssl\n",
        "ssl._create_default_https_context = ssl._create_unverified_context\n",
        "\n",
        "import urllib.request\n",
        "\n",
        "for x in range(1,3):\n",
        "  f = urllib.request.urlopen(str(filedir+\"input\"+str(x)+\".txt\"))\n",
        "\n",
        "  data=[]\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "      data.append(line)\n",
        "  print('Entrée',x,':',data)\n",
        "\n",
        "  f = urllib.request.urlopen(str(filedir+\"output\"+str(x)+\".txt\"))\n",
        "  for i in f:\n",
        "      line=i.decode('utf-8').strip()\n",
        "  print('Sortie',x,':',line,'\\n')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Entrée 1 : ['3', 'uev', 'tlu']\n",
            "Sortie 1 : tdu \n",
            "\n",
            "Entrée 2 : ['6', 'vwnjkf', 'hqhdez']\n",
            "Sortie 2 : pqhdez \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lines = ['6', 'vwnjkf', 'hqhdez']\n",
        "\n",
        "def ajout(x):\n",
        "    '''\n",
        "    Retourne le message x en ajoutant 1 à chaque lettre du message\n",
        "    '''\n",
        "    code=[]\n",
        "    for i in x:\n",
        "        if i=='z':\n",
        "            code.append('a')\n",
        "        else:\n",
        "            code.append(chr(ord(i)+1))\n",
        "    return code\n",
        "\n",
        "def rotation(x):\n",
        "    '''\n",
        "    Retourne le message x en appliquant une rotation de 1\n",
        "    '''\n",
        "    return x[-1:] + x[:-1]\n",
        "\n",
        "def score(x,y):\n",
        "  '''\n",
        "  Retourne le nombre de lettres identiques entre deux mots x et y\n",
        "  '''\n",
        "  s=0\n",
        "  for i in range(len(x)):\n",
        "    if x[i]==y[i]:\n",
        "      s+=1\n",
        "  return s\n",
        "\n",
        "maxi=0\n",
        "N=int(lines[0])\n",
        "l=list(lines[1])\n",
        "M=list(lines[2])\n",
        "for i in range(N):\n",
        "  for j in range(26):\n",
        "    if score(l,M)>maxi:\n",
        "      maxi=score(l,M)\n",
        "      res=l\n",
        "    l=ajout(l) \n",
        "  l=rotation(l)\n",
        "\n",
        "print(\"\".join(res))"
      ],
      "metadata": {
        "id": "cJNkkzCH-p2m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "836423c3-0812-4127-cc65-215015f0292b"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pqhdez\n"
          ]
        }
      ]
    }
  ]
}