lafrite/2022-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Feat(NSI): exercices sur les dictionnaires
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Bertrand Benjamin 2023-03-26 16:40:46 +02:00
parent 9ba0b57e51
commit 90558ac36b
12 changed files with 1326 additions and 775 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
1NSI/09_Recherche_par_dichotomie_et_complexite/Complexite_recherche_dichotomie.ipynb Normal file
View File

File diff suppressed because one or more lines are too long

771
1NSI/09_Recherche_par_dichotomie_et_complexite/Temps d'exécution.ipynb
View File

@ -1,771 +0,0 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "6e073068",
"metadata": {},
"source": [
"# Temps d'exécution et complexité\n",
"\n",
"Dans ce TP, vous allez chercher à évaluer la rapidité d'exécution de différents programmes.\n",
"\n",
"## Recherche d'élément\n",
"\n",
"1. Programmer et tester la fonction `chercher` qui prend en argument une liste de nombres et un nombre et qui renvoie si ce nombre est dans la liste"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3a77b4e6",
"metadata": {},
"outputs": [],
"source": [
"# Tests"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "50901256",
"metadata": {},
"outputs": [],
"source": [
"# Fonction\n",
"def chercher(liste, nombre):\n",
" pass"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf3ab537",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "40a8b167",
"metadata": {},
"source": [
"On voudra tester votre fonction sur des grandes listes de nombre construites aléatoirements avec le module `random`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e6e62eb",
"metadata": {},
"outputs": [],
"source": [
"from random import randint\n",
"# import de la fonction randint dans le module random"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e64bfac",
"metadata": {},
"outputs": [],
"source": [
"print(randint(1, 10))"
]
},
{
"cell_type": "markdown",
"id": "28f0fdac",
"metadata": {},
"source": [
"Le résultat est un nombre aléatoire entre 1 et 10.\n",
"\n",
"Les listes seront construites de la manière suivante"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "58200552",
"metadata": {},
"outputs": [],
"source": [
"liste_aleatoire = [randint(0, 200) for i in range(1000)]\n",
"print(liste_aleatoire)"
]
},
{
"cell_type": "markdown",
"id": "fc9b3bf3",
"metadata": {},
"source": [
"2. Vérifier que votre fonction `chercher` fonctionne avec des listes aléatoires à 10, 100, 1000 et 1000 nombres entre 0 et 100."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ebf2bbc5",
"metadata": {},
"outputs": [],
"source": [
"# 10 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1b3b40c9",
"metadata": {},
"outputs": [],
"source": [
"# 100 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1c5b634f",
"metadata": {},
"outputs": [],
"source": [
"# 1000 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e2ad8221",
"metadata": {},
"outputs": [],
"source": [
"# 10000 nombres"
]
},
{
"cell_type": "markdown",
"id": "26a61e11",
"metadata": {},
"source": [
"On cherche maintenant à évaluer la rapidité d'exécution de votre fonction. Pour cela on utilisera le module `time` qui permet d'accéder au temps."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bb9f1569",
"metadata": {},
"outputs": [],
"source": [
"from time import time\n",
"# import de la fonction time dans le module time"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6502ae21",
"metadata": {},
"outputs": [],
"source": [
"print(time())"
]
},
{
"cell_type": "markdown",
"id": "8d97d48f",
"metadata": {},
"source": [
"le résultat est le nombre de secondes écoulée depuis le 1 janvier 1970.\n",
"\n",
"3. Pour mesurer le temps d'exécution, on enregistre le temps avant l'exécution de la fonction puis on faire la différente avec le temps après l'exécution.\n",
"\n",
"Combien de temps prend la commande `cherche([1, 7, 8, 3, 9, 3], 9)` à s'exécuter?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eab8639d",
"metadata": {},
"outputs": [],
"source": [
"t = time()\n",
"chercher([1, 7, 8, 3, 9, 3], 9)\n",
"print(time() - t)"
]
},
{
"cell_type": "markdown",
"id": "a053fc3b",
"metadata": {},
"source": [
"4. Combien de temps met votre fonction pour chercher un nombre dans une liste de 10 nombres? 100 nombres? 1000nombres? 10 000 nombres?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "17f17db3",
"metadata": {},
"outputs": [],
"source": [
"# 10 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "98444ddb",
"metadata": {},
"outputs": [],
"source": [
"# 100 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "be9d12d2",
"metadata": {},
"outputs": [],
"source": [
"# 1000 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b9621131",
"metadata": {},
"outputs": [],
"source": [
"# 10000 nombres"
]
},
{
"cell_type": "markdown",
"id": "57840abf",
"metadata": {},
"source": [
"5. Le soucis de cette méthode est que l'on est pas à l'abris d'une liste \"facile\". Vous devez faire la même chose en calculant 5 fois le temps pour 5 listes différentes puis faire la moyenne des temps d'exécution. *(je vous encourage à programmer une fonction `moyenne` pour calculer cette moyenne)*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b67b8fea",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "531e00f3",
"metadata": {},
"outputs": [],
"source": [
"# 10 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "16502cac",
"metadata": {},
"outputs": [],
"source": [
"# 100 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e2ea7281",
"metadata": {},
"outputs": [],
"source": [
"# 1000 nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "370f6d59",
"metadata": {},
"outputs": [],
"source": [
"# 10000 nombres"
]
},
{
"cell_type": "markdown",
"id": "6c13e06b",
"metadata": {},
"source": [
"On va maintenant tracer le temps d'exécution en fonction de la taille de la liste.\n",
"\n",
"Pour cela, vous allez utiliser la librairy graphique `matplotlib`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "10e8f28a",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4318058e",
"metadata": {},
"outputs": [],
"source": [
"# taille des listes\n",
"x = [10, 100, 1000, 10000]\n",
"# Temps\n",
"t = [1, 2, 3, 4]\n",
"# le graphique\n",
"fig, ax = plt.subplots()\n",
"ax.plot(x, t)"
]
},
{
"cell_type": "markdown",
"id": "7818c04e",
"metadata": {},
"source": [
"6. Tracer le graphique des temps d'exécution de votre fonction `chercher`. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a312000a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "846b0e02",
"metadata": {},
"source": [
"7. Comparer les temps "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0bc4af7b",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "4e3e4ace",
"metadata": {},
"source": [
"## Fonction max\n",
"\n",
"On souhaite étudier le temps d'exécution d'une fonction `maximum`.\n",
"\n",
"1. Progammer et tester la fonction `maximum` qui prend en argument une liste de liste de nombres et qui renvoie le plus grand élément parmi toutes les listes."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0e5424b5",
"metadata": {},
"outputs": [],
"source": [
"# Tests\n",
"assert maximum([[1, 2, 3], [7, 3, 1]]) == 7"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a0562579",
"metadata": {},
"outputs": [],
"source": [
"# Fonction"
]
},
{
"cell_type": "markdown",
"id": "fee2f5da",
"metadata": {},
"source": [
"2. Mesurer le temps d'exécution de votre fonction sur des listes avec 10, 100, 1000, 10000 et 100000 nombres."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9004c51c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "3d16cef9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f1914122",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "91d57e06",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "b83b39b1",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "4e4324ba",
"metadata": {},
"source": [
"3. Reprendre la question précédente en faisant la moyenne des temps d'exécution sur 5 listes pour chaque taille."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "30d640cd",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "bb771796",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "3a36f920",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "79e54764",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "530204ee",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "ef7c19a2",
"metadata": {},
"source": [
"4. Tracer le graphique de la moyenne de temps d'exécution en fonction de la taille des listes."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fff676a4",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "deb97308",
"metadata": {},
"source": [
"## Recherche par dichotomie.\n",
"\n",
"La recherche par dichotomie permet de grandement améliorer la vitesse de recherche d'un élément dans un liste. **À condition que cette liste soit triée en ordre croissant**.\n",
"\n",
"1. Chercher et expliquer la meilleur stratégie pour gagner [au jeu du plus ou moins](https://raw.opytex.org/1NSI/09_Recherche_par_dichotomie_et_complexite/plus_moins/plus_moins.html)"
]
},
{
"cell_type": "raw",
"id": "c78246e0",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "65cf15cd",
"metadata": {},
"source": [
"La résolution du jeux précédent est très similaire à la situation de recherche par dichotomie.\n",
"\n",
"2. Pour vous entrainé à la recherche par dichotomie, établir un algorithme qui permet de trouver en le moins de coup possible (en moyenne) un élément dans une liste triée. Pour tester votre stratégie vous pouvez utiliser [ce jeu]()."
]
},
{
"cell_type": "markdown",
"id": "a8b722a9",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "73ccf876",
"metadata": {},
"source": [
"3. On suppose maintenant que la liste `L = [x0, x1, . . . , x]` est triée en ordre croissant, c'est\n",
"à dire :\n",
" \n",
" x0 ⩽ x1 ⩽ · · · ⩽ xn\n",
" \n",
"On cherche parmi les éléments de `L` l'élément x.\n",
" \n",
"On désigne par `L[i..j]` les éléments de L dont les indices sont compris entre i (inclu) et j\n",
"(inclu). \n",
"\n",
"On suppose que parmi les éléments de `L[g..d]`, il y a un élément x. Et on considère un\n",
"indice m tel que g ⩽ m ⩽ d.\n",
"\n",
"Si L[m]<x, dans quelle nouvelle zone est-on sûr que x se trouve ?"
]
},
{
"cell_type": "raw",
"id": "bf3961fa",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "645c4300",
"metadata": {},
"source": [
"Si L[m]>x, dans quelle nouvelle zone est-on sûr que x se trouve ?"
]
},
{
"cell_type": "raw",
"id": "fb42b270",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "7c6f53e5",
"metadata": {},
"source": [
"Que peut-on affirmer si aucune des deux conditions précédentes n'est valide ?"
]
},
{
"cell_type": "raw",
"id": "d8cf7292",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "6d046b52",
"metadata": {},
"source": [
"4. Compléter le fonction suivante en respectant la spécification de la docstring"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "0afedcb2",
"metadata": {},
"outputs": [],
"source": [
"def dichotomie(L, x):\n",
" \"\"\" Renvoie un indice de l'élément x dans L si x est dedans, et renvoie None sinon\n",
" \n",
" On supposera que la liste L est triée en ordre croissant.\n",
" \"\"\"\n",
" g = 0\n",
" d = len(L)-1\n",
" while g <= l:\n",
" m = (g + d) // 2\n",
" if L[m] < x:\n",
" ...\n",
" elif L[m] > x:\n",
" ...\n",
" else:\n",
" ...\n",
" return None"
]
},
{
"cell_type": "markdown",
"id": "5e3bde1e",
"metadata": {},
"source": [
"5. Mesurer le temps d'exécution de votre fonction sur des listes avec 10, 100, 1000, 10000 et 100000 nombres."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "603757b0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "6959bcfb",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "9a834ec6",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "f3e9a104",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "6093b13a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "db5d9f35",
"metadata": {},
"source": [
"6. Reprendre la question précédente en faisant la moyenne des temps d'exécution sur 5 listes pour chaque taille."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "906ce312",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "69213d32",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "51e69361",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "d8d068cb",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "b3628a5f",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "a6966564",
"metadata": {},
"source": [
"7. Tracer le graphique de la moyenne de temps d'exécution en fonction de la taille des listes."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "96687215",
"metadata": {},
"outputs": [],
"source": []
}
],
"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.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

2
1NSI/09_Recherche_par_dichotomie_et_complexite/plus_moins/plus_moins.html
View File

@ -25,7 +25,7 @@
const maximum = parseInt(document.getElementById("max").value) const maximum = parseInt(document.getElementById("max").value)
randomNumber = Math.floor(Math.random() * maximum) + 1; randomNumber = Math.floor(Math.random() * maximum) + 1;
tries = 0 tries = 0
document.getElementById("game").innerHTML = "<h2> Trouve un nombre entre 0 et " + maximum + "</h2>"+ document.getElementById("game").innerHTML = "<h2> J'ai choisi un nombre, il est entre 0 et " + maximum + ". Trouve le!</h2>"+
"<input type='text' id='guess'>" + "<input type='text' id='guess'>" +
`<button id="subbutton" type='button' onclick='guessNumber()'>Je tente !</button>` + `<button id="subbutton" type='button' onclick='guessNumber()'>Je tente !</button>` +
"<p id='result'></p>" "<p id='result'></p>"

622
1NSI/10_Dictionnaire/1E_dictionnaire.ipynb Normal file
View File

@ -0,0 +1,622 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "3a9c129c",
"metadata": {},
"source": [
"# Dictionnaire en Python\n",
"\n",
"## Construction d'un mémo sur les dictionnaires\n",
"\n",
"Cette partie à pour but de vous faire découvrir les dictionnaires. Vous devez vous constituer un mémo des commandes pour les manipuler.\n",
"\n",
"On a déjà vu que l'on pouvait stocker plusieurs informations dans une `list` ou un `tuple`."
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "d76bb1c8",
"metadata": {},
"outputs": [],
"source": [
"info_perso = (\"Bob\", \n",
" \"Lacanaille\",\n",
" 2, \n",
" \"0637382716\",\n",
" \"1 rue de la boutifaille\",\n",
" \"01000\",\n",
" )"
]
},
{
"cell_type": "markdown",
"id": "f801055d",
"metadata": {},
"source": [
"Pour accéder au nom de cette personne, on peut alors faire"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "8521c91b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Lacanaille'"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"info_perso[1]"
]
},
{
"cell_type": "markdown",
"id": "80409f49",
"metadata": {},
"source": [
"Ça marche mais ce n'est pas très explicite. Ce n'est pas très clair quelle élément est le nom, le prénom, si le 2 est l'age ou autre chose.\n",
"\n",
"Il existe une stucture de données appellée `tuple nommé` dans laquelle les clés ne sont pas des nombres (0 à 5 ici) mais des chaines de caractères ou d'autres types. En python, ces tuples nommés sont appellé `dictionnaires`.\n",
"\n",
"1. Compléter le dictionnaire ci-dessous pour ajouter les informations sur Bob Lacanaille."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ab63d16c",
"metadata": {},
"outputs": [],
"source": [
"info_perso = {\n",
" \"prenom\": \"Bob\", \n",
" \"nom\": \"Lacanaille\",\n",
" \"age\": 2,\n",
" \n",
"}"
]
},
{
"cell_type": "markdown",
"id": "043de027",
"metadata": {},
"source": [
"`info_perso` est bien un dictionnaire"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "970c028a",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(info_perso)"
]
},
{
"cell_type": "markdown",
"id": "de3f48c3",
"metadata": {},
"source": [
"Pour accéder aux valeurs, il faut maintenant indiqué la clé de l'information recherchée"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "00b292e8",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Lacanaille'"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"info_perso[\"nom\"]"
]
},
{
"cell_type": "markdown",
"id": "88acf0ee",
"metadata": {},
"source": [
"2. Quelles sont les clés du dictionnaire `info_perso`?"
]
},
{
"cell_type": "raw",
"id": "c29b2e1a",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "d310f5ba",
"metadata": {},
"source": [
"3. Comment accéder à l'age? Au code postal."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f9799858",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "6f975598",
"metadata": {},
"source": [
"Les dictionnaires sont dits `mutables` c'est à dire que l'on peut les modifier.\n",
"\n",
"On peut modifier les valeurs associées aux clés"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "a40058b0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'prenom': 'Bob', 'nom': 'Lessage', 'age': 10}\n"
]
}
],
"source": [
"info_perso[\"nom\"] = \"Lessage\"\n",
"info_perso[\"age\"] = 10\n",
"print(info_perso)"
]
},
{
"cell_type": "markdown",
"id": "037e117b",
"metadata": {},
"source": [
"Ou ajouter des nouvelles clés"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "694daacb",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'prenom': 'Bob', 'nom': 'Lessage', 'age': 10, 'yeux': 'bleu', 'lieu de naissance': 'Ile perdue'}\n"
]
}
],
"source": [
"info_perso[\"yeux\"] = \"bleu\"\n",
"info_perso[\"lieu de naissance\"] = \"Ile perdue\"\n",
"print(info_perso)"
]
},
{
"cell_type": "markdown",
"id": "ad8d985c",
"metadata": {},
"source": [
"4. Construire un dictionnaire sur le contenu d'un panier que l'on stockera dans la variable `panier`.\n",
"\n",
"| Contenu | Quantité |\n",
"|-----------|----------|\n",
"| Poires | 20 |\n",
"| Pommes | 10 |\n",
"| Orange | 12 |\n",
"| Mots doux | 2 |\n",
"| Gateaux | 0 |"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "efd7013c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "fe33e112",
"metadata": {},
"source": [
"5. Ajouter dans ce panier 5 champignons et 2 épis de maïs."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "76f4d571",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "4407a25c",
"metadata": {},
"source": [
"`len` permet d'avoir le nombre d'éléments dans un dictionnaire.\n",
"\n",
"6. Calculer la longueur des dictionnaires `info_perso` et `panier`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5148ffb2",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "e7bf0d24",
"metadata": {},
"source": [
"Il y a plusieurs façon de faire des boucles sur les dictionnaires"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "47568544",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"----\n",
"prenom\n",
"Bob\n",
"----\n",
"nom\n",
"Lessage\n",
"----\n",
"age\n",
"10\n",
"----\n",
"yeux\n",
"bleu\n",
"----\n",
"lieu de naissance\n",
"Ile perdue\n"
]
}
],
"source": [
"for cle in info_perso:\n",
" print(\"----\")\n",
" print(cle)\n",
" print(info_perso[cle])"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "5df06b20",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"----\n",
"prenom\n",
"Bob\n",
"----\n",
"nom\n",
"Lessage\n",
"----\n",
"age\n",
"10\n",
"----\n",
"yeux\n",
"bleu\n",
"----\n",
"lieu de naissance\n",
"Ile perdue\n"
]
}
],
"source": [
"for cle, valeur in info_perso.items():\n",
" print(\"----\")\n",
" print(cle)\n",
" print(valeur)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "7be1fbef",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bob\n",
"Lessage\n",
"10\n",
"bleu\n",
"Ile perdue\n"
]
}
],
"source": [
"for valeur in info_perso.values():\n",
" print(valeur)"
]
},
{
"cell_type": "markdown",
"id": "2bf475ba",
"metadata": {},
"source": [
"7. Faire une boucle sur `panier` pour afficher un texte du type\n",
"\n",
" Dans mon panier, il y 4 carrotes\n",
" \n",
"pour tout ce qui se trouve dans le panier."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0895e2e9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "6cb53a9f",
"metadata": {},
"source": [
"Voici les prix à l'unité des aliments qui ont été mis dans le panier.\n",
"\n",
"| Contenu | Prix |\n",
"|-----------|------|\n",
"| Poires | 2 |\n",
"| Pommes | 1 |\n",
"| Orange | 5 |\n",
"| Mots doux | 0 |\n",
"| Gateaux | 10 |\n",
"| Champignons | 1 |\n",
"| Mais | 15 |\n",
"\n",
"8. Mettre les prix dans un dictionnaire puis calculer le prix de mon panier."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5d2c3b52",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "6f0a1e25",
"metadata": {},
"source": [
"## Temps d'accès à un élément\n",
"\n",
"Dans cette partie, on compare le temps d'accès à un élément entre une `liste` et un `dictionnaire`."
]
},
{
"cell_type": "markdown",
"id": "2edee797",
"metadata": {},
"source": [
"1. On construit 5 dictionnaires avec 10, 100, 1000, 10000 et 100000 clés"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "5d889ef3",
"metadata": {},
"outputs": [],
"source": [
"tailles = [10, 100, 1000, 10000, 100000]\n",
"dictionnaires = {}\n",
"for taille in tailles:\n",
" dictionnaires[taille] = {i: i for i in range(taille)}"
]
},
{
"cell_type": "markdown",
"id": "755895e1",
"metadata": {},
"source": [
"2. On va calculer le temps pour accéder à un élément aléatoirement dans chaque liste."
]
},
{
"cell_type": "code",
"execution_count": 30,
"id": "98870503",
"metadata": {},
"outputs": [],
"source": [
"from time import time\n",
"from random import randint"
]
},
{
"cell_type": "code",
"execution_count": 31,
"id": "8cd70e84",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[9.059906005859375e-07, 7.62939453125e-07, 1.1920928955078125e-06, 1.3828277587890625e-06, 1.52587890625e-06]\n"
]
}
],
"source": [
"moyennes = []\n",
"nb_essais = 5\n",
"for taille in tailles:\n",
" le_dictionnaire = dictionnaires[taille]\n",
" temps = []\n",
" for i in range(nb_essais):\n",
" pos = randint(0, taille-1)\n",
" start = time()\n",
" le_dictionnaire[pos]\n",
" end = time()\n",
" temps.append(end-start)\n",
" moyennes.append(sum(temps)/nb_essais)\n",
"print(moyennes)"
]
},
{
"cell_type": "markdown",
"id": "be8d6144",
"metadata": {},
"source": [
"3. Que peut-on dire sur le temps d'accès à un élément d'un dictionnaire?"
]
},
{
"cell_type": "raw",
"id": "7c3b0bac",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "79d9d967",
"metadata": {},
"source": [
"4. Faire la même chose pour des listes de taille 10 à 10000 éléments"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "685baf07",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ba70d29f",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "748a5a0a",
"metadata": {},
"source": [
"5. Que peut-on dire sur le temps d'accès à un élément d'une liste"
]
},
{
"cell_type": "raw",
"id": "4356fba7",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "5c7b15dc",
"metadata": {},
"source": [
"## Jeu du scabble\n",
"\n",
"Dans cette partie, vous allez programmer des fonctions necessaires pour calculer les points au jeu du scrabble.\n",
"\n",
"Pour cela, vous devez compléter le fichier `scrabble.py`."
]
},
{
"cell_type": "markdown",
"id": "56b04766",
"metadata": {},
"source": [
"## Casser le chiffrement de César\n",
"\n",
"Dans un précédent exercice, vous avez programmer des fonctions qui permettait de chiffrer avec la méthode de César (décalage de l'alphabet).\n",
"\n",
"En partant du principe que dans un texte le caractère le plus courant est l'espace, vous aller pouvoir casser ce chiffrement.\n",
"\n",
"Pour cela, vous devez compléter le fichier `cesar.py`"
]
}
],
"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.10.10"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

534
1NSI/10_Dictionnaire/2E_exif_folium.ipynb Normal file
View File

@ -0,0 +1,534 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "437fa01c",
"metadata": {},
"source": [
"# Métadonnées d'une image\n",
"\n",
"Dans ce TP, vous allez manipuler les métadonnées d'images pour ensuite les placer sur une carte.\n",
"\n",
"## Extraction des métadonnées\n",
"\n",
"Pour manipuler les images, on a besoin d'une librairie de manipulation d'images."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5c9c7e32",
"metadata": {},
"outputs": [],
"source": [
"from PIL import Image, ExifTags"
]
},
{
"cell_type": "markdown",
"id": "960941d7",
"metadata": {},
"source": [
"Vous venez d'importer deux modules qui vous permettrons de manipuler des images et les metadonnées (les tags exifs).\n",
"\n",
"### Image\n",
"\n",
"Pour importer une image"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cc05608c",
"metadata": {},
"outputs": [],
"source": [
"image1 = Image.open(\"image1.jpg\")\n",
"image1"
]
},
{
"cell_type": "markdown",
"id": "28e7d3fe",
"metadata": {},
"source": [
"Pour obtenir les données exifs on pourra utiliser la méthode `._getexif()` sur l'image."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "75ad9d0a",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"image1._getexif()"
]
},
{
"cell_type": "markdown",
"id": "8bddb206",
"metadata": {},
"source": [
"Quel type de données est utilisé pour stocker les données exifs?"
]
},
{
"cell_type": "raw",
"id": "7fb64ce8",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "4b9c1b9e",
"metadata": {},
"source": [
"Quelles sont les informations que l'on peut trouver dans les métadonnées d'une image?"
]
},
{
"cell_type": "raw",
"id": "7211efe2",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "f6496594",
"metadata": {},
"source": [
"Quels problèmes a-t-on pour comprendre ce dictionnaire?"
]
},
{
"cell_type": "raw",
"id": "c1ea645c",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "356814cc",
"metadata": {},
"source": [
"### Comprendre les données exifs\n",
"\n",
"Pour donner un sens aux clés du dictionnaire des données exifs, le module `ExifTags` a un attribut `.TAGS`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "04a8f787",
"metadata": {},
"outputs": [],
"source": [
"ExifTags.TAGS"
]
},
{
"cell_type": "markdown",
"id": "545f1db5",
"metadata": {},
"source": [
"Quel est ce type de données?"
]
},
{
"cell_type": "raw",
"id": "d5ede170",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "a7564aaa",
"metadata": {},
"source": [
"À quelle caractéristique correspond la clé `34853`?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "00d8d07d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "9b695442",
"metadata": {},
"source": [
"À quelle caractéristique correspond la clé `272`?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c3d05add",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "1eb8842b",
"metadata": {},
"source": [
"À quelle caractéristique correspond la clé `306`?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0ff2023d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "b14e7a73",
"metadata": {},
"source": [
"Faire une boucle sur les données exifs de l'`image1` en affichant la description de la donnée et la donnée. "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "99f357bc",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "95afa782",
"metadata": {},
"source": [
"Ecrire une fonction `extrait_exit` qui prend en argument une image et qui renvoie un dictionaire contenant les données exifs (avec le clés qui doivent être la description de la donnée)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ce958419",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "96fb0759",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "3b677187",
"metadata": {},
"source": [
"### Données GPS\n",
"\n",
"On s'interesse plus précisement aux données GPS de l'image.\n",
"\n",
"Afficher les données `'GPSInfo'` de l'`image1`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5b901411",
"metadata": {},
"outputs": [],
"source": [
"image1._getexif()[34853]"
]
},
{
"cell_type": "markdown",
"id": "033a1730",
"metadata": {},
"source": [
"Quel type est utilisé pour stocker les données GPS?"
]
},
{
"cell_type": "raw",
"id": "086ee50f",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "322a9278",
"metadata": {},
"source": [
"Quel est le type des clés?"
]
},
{
"cell_type": "raw",
"id": "a140e2fd",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "f4f06f4c",
"metadata": {},
"source": [
"Pour donner un sens à ces clés, le module `ExifTags` a un attibut `GPSTAGS` pour leur donner un sens."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e13b29a0",
"metadata": {},
"outputs": [],
"source": [
"ExifTags.GPSTAGS"
]
},
{
"cell_type": "markdown",
"id": "732ece8c",
"metadata": {},
"source": [
"Ecrire une fonction `extrait_gps` qui prend en argument une image et qui renvoie un dicitonnaire avec les données GPS (avec des clés compréhensibles)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dbd0945a",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "7a282a17",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "77ecc152",
"metadata": {},
"source": [
"La longitude et la latitude sont données sous forme de tuple (degré, minute, secondes).\n",
"\n",
"Pour les transformer en forme décimale, vous pouvez utiliser la fonction suivante"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c0d9ca0f",
"metadata": {},
"outputs": [],
"source": [
"def gps_to_degre(gps:tuple) -> float:\n",
" \"\"\"Converti des données GPS en notation décimale\n",
" \n",
" :param gps: tuple de données GPS (degré, minute, secondes)\n",
" :return: gps en décimal\n",
" \n",
" :example:\n",
" >>> gps_to_degre((48.0, 50.0, 44.85))\n",
" 48.84579166666667\n",
" \n",
" \"\"\"\n",
" return gps[0] + gps[1]/60 + gps[2]/3600"
]
},
{
"cell_type": "markdown",
"id": "1d3726cd",
"metadata": {},
"source": [
"Ecrire une fonction `ajoute_degre` qui prend en argument un dictionnaire contenant toutes les données gps et qui renvoie ces données où l'on a ajouté les clés `degreLattitude` et `degreLongitude` (calculés avec la fonction `gps_to_degre`)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d3e048d8",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "02fc0400",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "bbe16539",
"metadata": {},
"source": [
"Extraire les données GPS des images \n",
"\n",
"- `image2.jpg`\n",
"- `image3.jpg`\n",
"- `image4.jpg`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8e6348e6",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "ccb0bb48",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "27e2647c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "66c525f8",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "2b0004af",
"metadata": {},
"source": [
"## Folium\n",
"\n",
"Folium est une librairie qui permet de manipuler des cartes."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b4e23b6c",
"metadata": {},
"outputs": [],
"source": [
"from folium import Map, Marker"
]
},
{
"cell_type": "markdown",
"id": "ad5694a8",
"metadata": {},
"source": [
"Créer une carte"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a5822416",
"metadata": {},
"outputs": [],
"source": [
"carte = Map(location=[45.5236, -122.6750])\n",
"marqueur = Marker(location=[45.5236, -122.6750])\n",
"marqueur.add_to(carte)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7ce827c7",
"metadata": {},
"outputs": [],
"source": [
"carte"
]
},
{
"cell_type": "markdown",
"id": "e8ca713b",
"metadata": {},
"source": [
"À quoi correspond la liste de nombres passés en argument de la fonction `Map` ou de `Marker`?"
]
},
{
"cell_type": "raw",
"id": "281f1e36",
"metadata": {},
"source": [
" "
]
},
{
"cell_type": "markdown",
"id": "21c54fff",
"metadata": {},
"source": [
"À vous de géolocaliser les images suivantes:\n",
"\n",
"- `image1.jpg`\n",
"- `image2.jpg`\n",
"- `image3.jpg`\n",
"- `image4.jpg`"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ae1323d6",
"metadata": {},
"outputs": [],
"source": []
}
],
"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.10.10"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

BIN
1NSI/10_Dictionnaire/image1.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 264 KiB

BIN
1NSI/10_Dictionnaire/image2.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 252 KiB

BIN
1NSI/10_Dictionnaire/image3.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 286 KiB

BIN
1NSI/10_Dictionnaire/image4.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 486 KiB

12
1NSI/10_Dictionnaire/index.rst
View File

@ -2,7 +2,7 @@ Dictionnaire
############ ############
:date: 2023-03-17 :date: 2023-03-17
:modified: 2023-03-17 :modified: 2023-03-26
:authors: Benjamin Bertrand :authors: Benjamin Bertrand
:tags: Python :tags: Python
:category: 1NSI :category: 1NSI
@ -27,6 +27,12 @@ Dictionnaire
Progression Progression
=========== ===========
- Construction d'un mémo sur les dictionnaires. - Construction d'un mémo sur les dictionnaires (`notebook découverte des dictionnaires <./1E_dictionnaire.ipynb>`_)
- Exercices de construction de fonctions de manipulation de dictionnaires - Exercices de construction de fonctions de manipulation de dictionnaires
- Manipulation des données Exif
- `Compter les points au scrabble <./scripts/scrabble.py>`_
- `Casser le chiffrement de Cesar <./scripts/cesar.py>`_
- Manipulation des données Exif et géo-localisation sur une carte (`notebook sur les données exifs <./2E_exif_folium.ipynb>`_)

61
1NSI/10_Dictionnaire/scripts/cesar.py Normal file
View File

@ -0,0 +1,61 @@
def chiffre_cesar(message:str, cle:int)->str:
"""
Chiffre un message avec le chiffrement par décalage sur les caractères imprimables ASCII.
:param message: le message à chiffrer
:param cle: décalage à appliquer
:return: le message chiffré
"""
message_chiffre = ""
for caractere in message:
caractere_chiffre = chr((ord(caractere) - 32 + cle) % 95 + 32)
message_chiffre += caractere_chiffre
return message_chiffre
def dechffre_cesar(message_chiffre:str, cle:int) -> str:
""" Déchiffre un message chiffré avec la méthode César"""
return chiffre_cesar(message_chiffre, -cle)
# On souhaite casser ce chiffrement c'est à dire trouver la clé de chiffrement
def signature(message: str) -> dict:
""" Compte le nombre d'occurrences de chaque caractère"""
# à compléter
pass
# Tests à ajouter
def caractere_plus_courant(message:str) -> str:
""" Donne le caractère le plus présent du message
En cas d'égalité, on renverra un des plus présent
"""
assert len(message) > 0
# à compléter
pass
# Ajouter deux tests
assert caractere_plus_courant("uiopyyy") == "y"
def decalage(caractere:str) -> int:
""" En supposant que caractere soit le caractère le plus présent du message, c'est certainement le caractère correspondant à l'espace. On peut donc calculer la clé"""
# à compléter
pass
# Tests (ajouter deux tests)
assert decalage("#") == 3
assert decalage("~") == 94
def trouve_cle(message_chiffre:str) -> int:
""" À partir d'un message chiffré, retrouve la clé"""
# à compléter
pass
def casse_cesar(message_chiffre:str) -> str:
""" À partir d'un message chiffré, déchiffre le message"""
# à compléter
pass
message = "Au théâtre, Victor Hugo s'est imposé comme un des chefs de file du romantisme français en présentant sa conception du drame romantique dans les préfaces qui introduisent Cromwell en 1827, puis Hernani en 1830, qui sont de véritables manifestes, puis par ses autres œuvres dramatiques, en particulier Lucrèce Borgia en 1833 et Ruy Blas en 1838."
# Dans la suite, chiffrer ce message puis essayer de casser le chiffrement avec votre fonction.

98
1NSI/10_Dictionnaire/scripts/scrabble.py Normal file
View File

@ -0,0 +1,98 @@
valeur_lettres = {
"a": 1,
"e": 1,
"i": 1,
"o": 1,
"n": 1,
"r": 1,
"t": 1,
"l": 1,
"s": 1,
"u": 1,
"d": 2,
"g": 2,
"b": 3,
"c": 3,
"m": 3,
"p": 3,
"f": 4,
"h": 4,
"v": 4,
"w": 4,
"y": 4,
"k": 5,
"j": 8,
"x": 8,
"q": 10,
"z": 10,
}
## Signature d'un mot
def signature(mot:str) -> dict:
"""Fonction qui compte le nombre de fois que chaque lettre apparait dans le mot
:param mot: le mot à étudier
:return: dictionnaire avec en clé les lettres et en valeur le nombre de fois qu'elles apparaissent
"""
# à compléter
pass
# Ajouter deux tests en plus
assert signature("coucou") == {'c': 2, 'o': 2, 'u': 2}
assert signature("") == {}
## Score d'un mot
def score(mot: str, valeurs: dict) -> int:
""" Calcul le score que fait un mot
:param mot: le mot à étudier
:param valeurs: dictionnaire avec les valeurs de chaque lettre
:return: le score du mot
"""
# à compléter
pass
# Ajouter deux tests en plus
assert score("coucou", valeur_lettres) == 10
assert score("", valeur_lettres) == 0
## Meilleur score
def meilleur_score(mots_possibles:list, valeurs:dict) -> str:
""" Renvoie le mot qui fait le plus de points dans la liste des mots possibles"""
# à compléter
pass
assert meilleur_score(["coucou", "hop"], valeur_lettres) == "coucou"
autres_valeurs_lettres = {
"a": 1,
"e": 1,
"i": 1,
"o": 1,
"n": 1,
"r": 1,
"t": 1,
"l": 1,
"s": 1,
"u": 1,
"d": 2,
"g": 2,
"b": 3,
"c": 3,
"m": 3,
"p": 3,
"f": 4,
"h": 100,
"v": 4,
"w": 4,
"y": 4,
"k": 5,
"j": 8,
"x": 8,
"q": 10,
"z": 10,
}
assert meilleur_score(["coucou", "hop"], autres_valeurs_lettres) == "hop"