TP_scrabble_CORR.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP Dictionnaire : Scrabble - CORRECTION"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Initialisation d'un dictionnaire des valeurs des lettres minuscules au scrabble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "scrabble = {\n",
    "    'a' : 1,'e' : 1,'i' : 1,'o' : 1,'u' : 1,\n",
    "    'n' : 1,'r' : 1,'t' : 1,'l' : 1,'s' : 1,\n",
    "    'd' : 2,'g' : 2,\n",
    "    'b' : 3, 'c' : 3, 'm' : 3, 'p' : 3,\n",
    "    'f' : 4, 'h' : 4, 'v' : 4, 'w' : 4, 'y' : 4,\n",
    "    'k' : 5, \n",
    "    'j' : 8, 'x' : 8,\n",
    "    'q' : 10, 'z' : 10}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Créer une fonction `signature` chargée de renvoyer un dictionnaire des occurences des lettres d'un mot. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def signature(mot):\n",
    "    \"\"\" La fonction prend en entrée la chaine de caractères mot \n",
    "    et renvoie un dictionnaire lettre_mot représentant le nombre d'occurences\n",
    "    de chaque lettre minuscule présente dans mot\"\"\" \n",
    "    dico  = {}  \n",
    "    for lettre in mot:\n",
    "        \"votre code ici\"\n",
    "        if lettre in dico:\n",
    "            dico[lettre] += 1\n",
    "        else:\n",
    "            dico[lettre] = 1\n",
    "    return dico\n",
    "\n",
    "#Tests unitaires de la fonction signature\n",
    "assert signature(\"\") == {}\n",
    "assert signature(\"ananas\") == {'a': 3, 'n': 2, 's': 1}\n",
    "assert signature(\"abcd\") == {'a': 1, 'b': 1, 'c': 1, 'd': 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d': 1, 'i': 3, 'c': 1, 't': 1, 'o': 1, 'n': 2, 'a': 1, 'r': 1, 'e': 1}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "signature(\"dictionnaire\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Créer une fonction `score_mot` chargée de calculer le total des points d'un mot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def score_mot(mot):\n",
    "    \"\"\"Paramètre : mot de type str, \n",
    "    valeur de type dict associe à chaque lettre minuscule sa valeur au scrabble\n",
    "    Valeur renvoyée : score du mot au scrabble\"\"\" \n",
    "    s = 0\n",
    "    \"à compléter\"\n",
    "    sig=signature(mot)\n",
    "    for lettre,eff in sig.items():\n",
    "        s += eff*scrabble[lettre]\n",
    "    return s\n",
    "\n",
    "#Tests unitaires de la fonction signature\n",
    "assert score_mot(\"\") == 0\n",
    "assert score_mot(\"zazou\") == 23\n",
    "assert score_mot(\"ananas\") == 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(score_mot(\"encodage\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Créer une fonction `mot_possible` chargée de vérifier si un mot peut être obtenu à partir des lettres disponibles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mot_possible(mot, sig_lettres):\n",
    "    \"\"\"Paramètre : mot de type str\n",
    "    lettres_dispos de type dict représente la signature des lettres disponibles\n",
    "    Valeur renvoyée : un booléen indiquant si sig_mot compatible avec  sig_lettres\n",
    "    et donc si le mot peut être composé avec les lettres fournies\"\"\"\n",
    "    sig_mot = signature(mot)\n",
    "    for lettre,eff in sig_mot.items():\n",
    "        if lettre not in sig_lettres or eff>sig_lettres[lettre]:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "\n",
    "#Tests unitaires de la fonction mot_possible\n",
    "assert mot_possible(\"zazou\", {\"a\" : 1, \"b\" : 1, \"o\" : 2, \"u\" : 1, \"z\" : 2}) == True\n",
    "assert mot_possible(\"zazou\", {\"b\" : 1, \"o\" : 1, \"u\" : 1, \"z\" : 2}) == False\n",
    "assert mot_possible(\"zazou\", {\"a\" : 1, \"o\" : 2, \"u\" : 3, \"z\" : 1}) == False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Poser 'encodage' avec le jeu1 : True\n",
      "Poser 'encodage' avec le jeu2 : False\n"
     ]
    }
   ],
   "source": [
    "jeu1 = {\"a\" : 1,\"e\" : 2, \"o\" : 1, \"c\" : 1 , \"g\" : 1, \"d\" : 1, \"n\" : 1 }\n",
    "jeu2 = {\"a\" : 2,\"e\" : 1, \"o\" : 1, \"c\" : 1 , \"g\" : 1, \"d\" : 1, \"n\" : 1 }\n",
    "print(\"Poser 'encodage' avec le jeu1 :\",mot_possible(\"encodage\",jeu1))\n",
    "print(\"Poser 'encodage' avec le jeu2 :\",mot_possible(\"encodage\",jeu2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Compléter le code du programme principal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre de mots : 3\n",
      "coder\n",
      "codage\n",
      "codez\n",
      "Vos lettres : odaceegz\n",
      "Meilleur mot : codez  -  Points : 17\n"
     ]
    }
   ],
   "source": [
    "# Saisie du nombre de mots du dictionnaire\n",
    "n = int(input('Nombre de mots : '))\n",
    "\n",
    "# Saisie des mots du dictionnaire dans une liste\n",
    "candidats = []\n",
    "for i in range(n):\n",
    "    essai = input()\n",
    "    candidats.append(essai)\n",
    "lettres = input('Vos lettres : ').rstrip()\n",
    "jeu = signature(lettres)\n",
    "smax = 0\n",
    "mot_max = \"\"\n",
    "\n",
    "# Boucle sur les mots du dictionnaire\n",
    "for mot in candidats:\n",
    "    \"à compléter\"\n",
    "    if mot_possible(mot,jeu):\n",
    "        if score_mot(mot)>smax:\n",
    "            mot_max = mot\n",
    "            smax = score_mot(mot)\n",
    "\n",
    "# Exécution du programme \n",
    "print('Meilleur mot :', mot_max,' -  Points :',smax)"
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}