diff --git a/2A/BDD/tp/s1/requetesTP4-5-6.sql b/2A/BDD/tp/s1/requetesTP4-5-6.sql
new file mode 100644
index 0000000..5534e31
--- /dev/null
+++ b/2A/BDD/tp/s1/requetesTP4-5-6.sql
@@ -0,0 +1,172 @@
+-- ? 1 - Écrire une fonction qui pour un match donné calcule le nombre de rebonds 
+-- ? pris par les joueurs qui n’ont pas débuté la rencontre. Proposez deux versions, 
+-- ? une utilisant les fonctions d’agrégation et une autre utilisant un curseur mais aucune fonction d’agrégation.
+
+CREATE OR REPLACE FUNCTION calcul_rebonds(match Game.id%TYPE) RETURNS integer AS $$
+DECLARE
+    sumRebounds integer;
+BEGIN
+    SELECT sum(gd.rebounds) INTO sumRebounds
+    FROM GameDetail gd, Game g
+    WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NULL;
+
+    RETURN sumRebounds;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT calcul_rebonds('22100979');
+
+-- CREATE FUNCTION
+--  calcul_rebonds 
+-- ----------------
+--              32
+-- (1 row)
+
+CREATE OR REPLACE FUNCTION calcul_rebonds_curs(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
+DECLARE
+    sumRebounds GameDetail.rebounds%TYPE := 0;
+    rbs GameDetail.rebounds%TYPE := 0;
+    curs cursor FOR SELECT rebounds
+                    FROM GameDetail 
+                    WHERE idGame = match AND startPosition is NULL AND rebounds is NOT NULL;
+BEGIN
+    OPEN curs;
+    FETCH curs INTO rbs;
+
+    WHILE FOUND LOOP
+        sumRebounds = sumRebounds + rbs;
+        FETCH curs INTO rbs;
+    END LOOP;
+    
+    CLOSE curs;
+
+    RETURN sumRebounds;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT calcul_rebonds_curs('22100979');
+
+-- CREATE FUNCTION
+--  calcul_rebonds_curs 
+-- ---------------------
+--                   32
+-- (1 row)
+
+
+
+-- ? 2 - Vérifier que vos deux versions retournent les mêmes résultats en affichant le nombre total de rebonds 
+-- ? pris par les joueurs n’ayant pas débuté la rencontre pour tous les matchs ayant eu lieu le 12 mars 2022.
+
+SELECT calcul_rebonds(id)
+FROM Game
+WHERE dateGame = '2022-03-12';
+
+--  calcul_rebonds 
+-- ----------------
+--              39
+--              20
+--              43
+--              40
+--              41
+--              25
+--              24
+-- (7 rows)
+
+SELECT calcul_rebonds_curs(id)
+FROM Game
+WHERE dateGame = '2022-03-12';
+
+--  calcul_rebonds_curs 
+-- ---------------------
+--                   39
+--                   20
+--                   43
+--                   40
+--                   41
+--                   25
+--                   24
+-- (7 rows)
+
+
+-- ? 3 - Écrire une fonction qui calcule la même chose mais pour les joueurs ayant débuté la rencontre, 
+-- ? autrement dit qui calcule, pour un match donné, le nombre de rebonds pris par les joueurs ayant débuté la rencontre.
+
+CREATE OR REPLACE FUNCTION calcul_rebonds_t(match Game.id%TYPE) RETURNS integer AS $$
+DECLARE
+    sumRebounds integer;
+BEGIN
+    SELECT sum(gd.rebounds) INTO sumRebounds
+    FROM GameDetail gd, Game g
+    WHERE g.id = match AND gd.idGame = g.id AND gd.startPosition is NOT NULL;
+
+    IF sumRebounds is NULL THEN 
+        RETURN 0;
+    END IF;
+
+    RETURN sumRebounds;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT calcul_rebonds_t('22100979');
+
+-- CREATE FUNCTION
+--  calcul_rebonds_t 
+-- ------------------
+--                57
+-- (1 row)
+
+CREATE OR REPLACE FUNCTION calcul_rebonds_curs_t(match Game.id%TYPE) RETURNS GameDetail.rebounds%TYPE AS $$
+DECLARE
+    sumRebounds GameDetail.rebounds%TYPE := 0;
+    rbs GameDetail.rebounds%TYPE := 0;
+    curs cursor FOR SELECT rebounds
+                    FROM GameDetail 
+                    WHERE idGame = match AND startPosition is NOT NULL AND rebounds is NOT NULL;
+BEGIN
+    OPEN curs;
+    FETCH curs INTO rbs;
+
+    WHILE FOUND LOOP
+        sumRebounds = sumRebounds + rbs;
+        FETCH curs INTO rbs;
+    END LOOP;
+    
+    CLOSE curs;
+
+    RETURN sumRebounds;
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT calcul_rebonds_curs_t('22100979');
+
+-- CREATE FUNCTION
+--  calcul_rebonds_curs_t 
+-- -----------------------
+--                     57
+-- (1 row)
+
+SELECT calcul_rebonds_t('10300004');
+SELECT calcul_rebonds_curs_t('10300004');
+
+
+-- ? 4 - Trouver le match (abréviation des équipes et date) pendant lequel les joueurs 
+-- ? ayant débuté la rencontre ont réalisé le plus de rebonds.
+
+SELECT t1.abbreviation, t2.abbreviation, g.dateGame, calcul_rebonds_t(g.id)
+FROM Game g, Team t1, Team t2
+WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
+                                                                                    FROM Game);
+
+--  abbreviation | abbreviation |  dategame  | calcul_rebonds_t 
+-- --------------+--------------+------------+------------------
+--  POR          | DEN          | 2019-05-03 |              101
+-- (1 row)
+
+
+-- ? 5 - Y a t’il des matchs pour lesquels les données sur les rebonds sont incohérentes? 
+-- ? Vérifier en comparant les valeurs obtenus grâce aux fonctions précédentes avec les valeurs contenues dans la table Game.
+
+-- ! SELECT t1.abbreviation, t2.abbreviation, g.dateGame, (calcul_rebonds_t(g.id) + calcul_rebonds(g.id)) as fct, g.reboundsHome, g.reboundsAway
+-- ! FROM Game g, Team t1, Team t2
+-- ! WHERE g.idHomeTeam = t1.id AND g.idVisitorTeam = t2.id AND calcul_rebonds_t(g.id) = (SELECT max(calcul_rebonds_t(id))
+-- !                                                                                   FROM Game);
\ No newline at end of file
diff --git a/2A/BDD/tp/s1/tp04_05_06.pdf b/2A/BDD/tp/s1/tp04_05_06.pdf
new file mode 100644
index 0000000..218e90a
Binary files /dev/null and b/2A/BDD/tp/s1/tp04_05_06.pdf differ
diff --git a/2A/Droit/TD/G7_NOA-DAVID-GWENAEL-ANTOINE_PE.docx b/2A/Droit/TD/G7_NOA-DAVID-GWENAEL-ANTOINE_PE.docx
new file mode 100644
index 0000000..532fa3b
Binary files /dev/null and b/2A/Droit/TD/G7_NOA-DAVID-GWENAEL-ANTOINE_PE.docx differ
diff --git a/2A/Innovation/Cours/Contract Clause.pptx b/2A/Innovation/Cours/Contract Clause.pptx
new file mode 100644
index 0000000..f8213d0
Binary files /dev/null and b/2A/Innovation/Cours/Contract Clause.pptx differ
diff --git a/2A/Maths/tp/projet/.ipynb_checkpoints/Intro-checkpoint.ipynb b/2A/Maths/tp/projet/.ipynb_checkpoints/Intro-checkpoint.ipynb
new file mode 100644
index 0000000..d8ed277
--- /dev/null
+++ b/2A/Maths/tp/projet/.ipynb_checkpoints/Intro-checkpoint.ipynb
@@ -0,0 +1,287 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a35eeb9f-df70-4ab1-a243-2d2025888eb0",
+   "metadata": {},
+   "source": [
+    "# Exercice 1\n",
+    "1) Combien y a t'il de dominos dans un jeu classique ?  \n",
+    "Un jeu de dominos classique est composé de 28 pièces dont chaque moitié comporte un certain nombre de petits points allant de 0 à 6, sans doublons, ce qui donne 7 * 4 = 28 pièces.\n",
+    "\n",
+    "2) Pourquoi est-il possible que le jeu s'arrête sans avoir posé tous les dominos ?  \n",
+    "Il est possible que le jeu s'arrete avant d'avoir posé tout les dominos car chaque moitié comporte un certain nombre de petits points allant de 0 à 6. Si les combinaisons de dominos disponibles dans la pioche ne sont pas compatibles avec les extrémités de la chaîne déjà construite, le jeu peut se terminer sans avoir posé tous les dominos. Cela dépend de la chance et de l'ordre dans lequel les dominos sont tirés.\n",
+    "\n",
+    "3) Pourquoi X et Y sont des variables aléatoires ?  \n",
+    "X et Y sont des variables aléatoires car leur valeur dépend du hasard et des choix effectués tout au long du jeu. La variable aléatoire X représente le nombre de dominos posés dans la chaîne, et elle dépend du nombre de dominos tirés et de la possibilité de les placer à chaque étape. De même, la variable aléatoire Y représente le nombre de points restants dans la pioche, ce qui dépend également de la manière dont les dominos sont tirés et placés. En raison de la nature aléatoire du jeu, X et Y prennent des valeurs différentes à chaque partie, d'où leur caractère aléatoire. Pour comprendre leur comportement, il est nécessaire d'étudier leur distribution de probabilité."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f8b9e53-7277-4663-ad35-0db9e824d45f",
+   "metadata": {},
+   "source": [
+    "- Quelle structure de données pour représenter la pioche de dominos restants ?\n",
+    "    - La structure nécéssaire est une file car on insere en queue mais on supprime en tete\n",
+    "- Quelle structure de données pour représenter la chaîne de dominos déjà construite? (Sachant qu'il suffit de considérer l'information pertinente pour le déroulement du jeu.)\n",
+    "    - Une liste car c'est une fassons simple de stocker les dominos mis en place sur le tapis\n",
+    "- Comment savoir si le jeu est \u001c",
+    "fini ?\n",
+    "    - si on ne peut plus inserer en tete ou en queue les dominos de la pioche.\n",
+    "- Est-il éventuellement utile d'écrire certaines sous-fonctions, afin de clarifier le code ?  \n",
+    "Ca peut être plus simple à comprendre le code, notamment pour le comptage de Y."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "060f3b6e-ed57-4ecc-9338-f2491f54bd74",
+   "metadata": {},
+   "source": [
+    "exemple de file en python :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "bee8d798-d9bb-464c-9b66-329678fa2fda",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "[2, 3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "queue = []                 # la file est vide\n",
+    "\n",
+    "queue.append(1)            # la file contient [1]\n",
+    "queue.append(2)            # la file contient [1, 2]\n",
+    "queue.append(3)            # la file contient [1, 2, 3]\n",
+    "\n",
+    "result = queue.pop(0)      # la file contient [2, 3]\n",
+    "\n",
+    "print(result)\n",
+    "print(queue)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fabca55-4ebf-4499-b652-86844be439e5",
+   "metadata": {},
+   "source": [
+    "**Initialisation et affichage de la pioche**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "fe55883a-6887-43dd-9498-5333a51799e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 1]\n",
+      "[1, 2]\n",
+      "[1, 3]\n",
+      "[1, 4]\n",
+      "[1, 5]\n",
+      "[1, 6]\n",
+      "[2, 2]\n",
+      "[2, 3]\n",
+      "[2, 4]\n",
+      "[2, 5]\n",
+      "[2, 6]\n",
+      "[3, 3]\n",
+      "[3, 4]\n",
+      "[3, 5]\n",
+      "[3, 6]\n",
+      "[4, 4]\n",
+      "[4, 5]\n",
+      "[4, 6]\n",
+      "[5, 5]\n",
+      "[5, 6]\n",
+      "[6, 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "# initialisation de la pioche contenant 28 pièces\n",
+    "pioche = [[i, j] for i in range(1,7) for j in range(i, 7)]\n",
+    "\n",
+    "# Exemple d'utilisation : affichez la file de dominos\n",
+    "for domino in pioche:\n",
+    "    print(domino)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 67,
+   "id": "09689b16-24dc-4025-bad9-90d0fe385b6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def comptePoints(P):\n",
+    "    # Initialise un compteur pour les points\n",
+    "    nb = 0\n",
+    "    \n",
+    "    # Parcours tous les dominos de la liste\n",
+    "    for domino in P:\n",
+    "        # Ajoute les points des deux moitiés du domino\n",
+    "        nb += sum(domino)\n",
+    "    \n",
+    "    return nb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 433,
+   "id": "f62cffa4-8e44-4b62-a49a-c3b4c9c50964",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X = 20, Y = 10\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fonction pour simuler une partie du jeu de dominos\n",
+    "def une_chaine_domino():\n",
+    "    # Liste représentant les dominos sur le jeu\n",
+    "    tapis = []\n",
+    "\n",
+    "    #initialisation d'une variable pour compter le nombre de pioche dans la pioche\n",
+    "    cpt = 0\n",
+    "    \n",
+    "    # Liste représentant la pioche de dominos restants\n",
+    "    pioche = [(i, j) for i in range(1, 7) for j in range(i, 7)]\n",
+    "\n",
+    "    # Tant que la pioche n'est pas vide et qu'on peut poser des dominos\n",
+    "    while pioche:\n",
+    "        domino = random.choice(pioche)  # Tirer un domino au hasard\n",
+    "        pioche.remove(domino)  # Retirer le domino de la pioche\n",
+    "\n",
+    "        if not tapis:  # Si c'est le premier domino, ajoutez-le directement\n",
+    "            tapis.append(domino)\n",
+    "        else:\n",
+    "            # Vérifiez si le domino peut être placé à l'une des extrémités de la chaîne\n",
+    "            if domino[0] == tapis[0][0] or domino[1] == tapis[0][0]:\n",
+    "                tapis.insert(0, domino)  # Placez-le au début de la chaîne\n",
+    "                cpt = 0;\n",
+    "            elif domino[0] == tapis[0][1] or domino[1] == tapis[0][1]: # On regarde le second argument du premier couple du tapis\n",
+    "                tapis.append(domino)  # Placez-le à la fin de la chaîne\n",
+    "                cpt = 0;\n",
+    "            else:\n",
+    "                pioche.append(domino)\n",
+    "                cpt = cpt + 1;\n",
+    "                if(cpt > len(pioche)):\n",
+    "                    break  # Si après un tour entier de la pioche est éfféctué sans pour voir placer un domino\n",
+    "\n",
+    "    # Valeur de X : nombre de dominos posés dans la chaîne\n",
+    "    X = len(tapis)\n",
+    "\n",
+    "    # Valeur de Y : nombre de points restants dans la pioche\n",
+    "    Y = comptePoints(pioche)\n",
+    "\n",
+    "    return X, Y\n",
+    "\n",
+    "# Utilisation de la fonction\n",
+    "X, Y = une_chaine_domino()\n",
+    "print(f\"X = {X}, Y = {Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e26c4cc-b76f-40b6-9146-ee2ffb396909",
+   "metadata": {},
+   "source": [
+    "# Exercice 3 (Analyse probabiliste).  \n",
+    "Simulez un grand nombre de réalisations du jeu (au moins 10000).  \n",
+    "Puis, à l'aide des méthodes déjà vues en cours et en TP :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 442,
+   "id": "c86fee95-c245-407b-b93b-4c53661b08a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moyenne de X : 14.8719\n",
+      "Moyenne de Y : 48.1079\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Nombre de réalisations du jeu\n",
+    "nombre_de_realisations = 10000\n",
+    "\n",
+    "# Liste pour stocker les résultats des n réalisations\n",
+    "resultats = []\n",
+    "\n",
+    "# Simulez le jeu un grand nombre de fois et stockez les résultats\n",
+    "for _ in range(nombre_de_realisations):\n",
+    "    X, Y = une_chaine_domino()\n",
+    "    resultats.append((X, Y))\n",
+    "\n",
+    "# Vous pouvez maintenant analyser les résultats pour obtenir des statistiques\n",
+    "# Par exemple, vous pouvez calculer la moyenne et l'écart-type pour X et Y.\n",
+    "moyenne_X = sum(X for X, Y in resultats) / nombre_de_realisations\n",
+    "moyenne_Y = sum(Y for X, Y in resultats) / nombre_de_realisations\n",
+    "\n",
+    "# Affichez les résultats statistiques\n",
+    "print(f\"Moyenne de X : {moyenne_X}\")\n",
+    "print(f\"Moyenne de Y : {moyenne_Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "111760f4-ecc7-4a97-84bc-de48314e0eb0",
+   "metadata": {},
+   "source": [
+    "1. Estimer et représenter la loi de probabilité de la variable X.\n",
+    "2. Calculer et tracer la fonction de répartition de X.\n",
+    "3. Estimer l'espérance de X.\n",
+    "4. Estimer la variance de X.\n",
+    "5. Mêmes questions pour la variable Y .\n",
+    "6. Estimer la probabilité de succès au jeu, c'est-à-dire, la probabilité de parvenir à placer tous\n",
+    "les dominos dans la chaine.\n",
+    "7. Estimer le nombre médian de points restants dans la pioche."
+   ]
+  }
+ ],
+ "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2A/Maths/tp/projet/.ipynb_checkpoints/projet-checkpoint.ipynb b/2A/Maths/tp/projet/.ipynb_checkpoints/projet-checkpoint.ipynb
new file mode 100644
index 0000000..d8699fc
--- /dev/null
+++ b/2A/Maths/tp/projet/.ipynb_checkpoints/projet-checkpoint.ipynb
@@ -0,0 +1,523 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a35eeb9f-df70-4ab1-a243-2d2025888eb0",
+   "metadata": {},
+   "source": [
+    "# Exercice 1\n",
+    "1) Combien y a t'il de dominos dans un jeu classique ?  \n",
+    "Un jeu de dominos classique est composé de 28 pièces dont chaque moitié comporte un certain nombre de petits points allant de 0 à 6, sans doublons, ce qui donne 7 * 4 = 28 pièces.\n",
+    "\n",
+    "2) Pourquoi est-il possible que le jeu s'arrête sans avoir posé tous les dominos ?  \n",
+    "Il est possible que le jeu s'arrete avant d'avoir posé tout les dominos car chaque moitié comporte un certain nombre de petits points allant de 0 à 6. Si les combinaisons de dominos disponibles dans la pioche ne sont pas compatibles avec les extrémités de la chaîne déjà construite, le jeu peut se terminer sans avoir posé tous les dominos. Cela dépend de la chance et de l'ordre dans lequel les dominos sont tirés.\n",
+    "\n",
+    "3) Pourquoi X et Y sont des variables aléatoires ?  \n",
+    "X et Y sont des variables aléatoires car leur valeur dépend du hasard et des choix effectués tout au long du jeu. La variable aléatoire X représente le nombre de dominos posés dans la chaîne, et elle dépend du nombre de dominos tirés et de la possibilité de les placer à chaque étape. De même, la variable aléatoire Y représente le nombre de points restants dans la pioche, ce qui dépend également de la manière dont les dominos sont tirés et placés. En raison de la nature aléatoire du jeu, X et Y prennent des valeurs différentes à chaque partie, d'où leur caractère aléatoire. Pour comprendre leur comportement, il est nécessaire d'étudier leur distribution de probabilité."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f8b9e53-7277-4663-ad35-0db9e824d45f",
+   "metadata": {},
+   "source": [
+    "- Quelle structure de données pour représenter la pioche de dominos restants ?\n",
+    "    - La structure nécéssaire est une file car on insere en queue mais on supprime en tete\n",
+    "- Quelle structure de données pour représenter la chaîne de dominos déjà construite? (Sachant qu'il suffit de considérer l'information pertinente pour le déroulement du jeu.)\n",
+    "    - Une liste car c'est une fassons simple de stocker les dominos mis en place sur le tapis\n",
+    "- Comment savoir si le jeu est \u001c",
+    "fini ?\n",
+    "    - si on ne peut plus inserer en tete ou en queue les dominos de la pioche.\n",
+    "- Est-il éventuellement utile d'écrire certaines sous-fonctions, afin de clarifier le code ?  \n",
+    "Ca peut être plus simple à comprendre le code, notamment pour le comptage de Y."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "060f3b6e-ed57-4ecc-9338-f2491f54bd74",
+   "metadata": {},
+   "source": [
+    "exemple de file en python :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "bee8d798-d9bb-464c-9b66-329678fa2fda",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "[2, 3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "queue = []                 # la file est vide\n",
+    "\n",
+    "queue.append(1)            # la file contient [1]\n",
+    "queue.append(2)            # la file contient [1, 2]\n",
+    "queue.append(3)            # la file contient [1, 2, 3]\n",
+    "\n",
+    "result = queue.pop(0)      # la file contient [2, 3]\n",
+    "\n",
+    "print(result)\n",
+    "print(queue)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fabca55-4ebf-4499-b652-86844be439e5",
+   "metadata": {},
+   "source": [
+    "**Initialisation et affichage de la pioche**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fe55883a-6887-43dd-9498-5333a51799e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 1]\n",
+      "[1, 2]\n",
+      "[1, 3]\n",
+      "[1, 4]\n",
+      "[1, 5]\n",
+      "[1, 6]\n",
+      "[2, 2]\n",
+      "[2, 3]\n",
+      "[2, 4]\n",
+      "[2, 5]\n",
+      "[2, 6]\n",
+      "[3, 3]\n",
+      "[3, 4]\n",
+      "[3, 5]\n",
+      "[3, 6]\n",
+      "[4, 4]\n",
+      "[4, 5]\n",
+      "[4, 6]\n",
+      "[5, 5]\n",
+      "[5, 6]\n",
+      "[6, 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "# initialisation de la pioche contenant 28 pièces\n",
+    "pioche = [[i, j] for i in range(1,7) for j in range(i, 7)]\n",
+    "\n",
+    "# Exemple d'utilisation : affichez la file de dominos\n",
+    "for domino in pioche:\n",
+    "    print(domino)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "09689b16-24dc-4025-bad9-90d0fe385b6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def comptePoints(P):\n",
+    "    # Initialise un compteur pour les points\n",
+    "    nb = 0\n",
+    "    \n",
+    "    # Parcours tous les dominos de la liste\n",
+    "    for domino in P:\n",
+    "        # Ajoute les points des deux moitiés du domino\n",
+    "        nb += sum(domino)\n",
+    "    \n",
+    "    return nb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f62cffa4-8e44-4b62-a49a-c3b4c9c50964",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X = 13, Y = 70\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fonction pour simuler une partie du jeu de dominos\n",
+    "def une_chaine_domino():\n",
+    "    # Liste représentant les dominos sur le jeu\n",
+    "    tapis = []\n",
+    "\n",
+    "    #initialisation d'une variable pour compter le nombre de pioche dans la pioche\n",
+    "    cpt = 0\n",
+    "    \n",
+    "    # Liste représentant la pioche de dominos restants\n",
+    "    pioche = [(i, j) for i in range(1, 7) for j in range(i, 7)]\n",
+    "\n",
+    "    # Tant que la pioche n'est pas vide et qu'on peut poser des dominos\n",
+    "    while pioche:\n",
+    "        domino = random.choice(pioche)  # Tirer un domino au hasard\n",
+    "        pioche.remove(domino)  # Retirer le domino de la pioche\n",
+    "\n",
+    "        if not tapis:  # Si c'est le premier domino, ajoutez-le directement\n",
+    "            tapis.append(domino)\n",
+    "        else:\n",
+    "            # Vérifiez si le domino peut être placé à l'une des extrémités de la chaîne\n",
+    "            if domino[0] == tapis[0][0] or domino[1] == tapis[0][0]:\n",
+    "                tapis.insert(0, domino)  # Placez-le au début de la chaîne\n",
+    "                cpt = 0;\n",
+    "            elif domino[0] == tapis[0][1] or domino[1] == tapis[0][1]: # On regarde le second argument du premier couple du tapis\n",
+    "                tapis.append(domino)  # Placez-le à la fin de la chaîne\n",
+    "                cpt = 0;\n",
+    "            else:\n",
+    "                pioche.append(domino)\n",
+    "                cpt = cpt + 1;\n",
+    "                if(cpt > len(pioche)):\n",
+    "                    break  # Si après un tour entier de la pioche est éfféctué sans pour voir placer un domino\n",
+    "\n",
+    "    # Valeur de X : nombre de dominos posés dans la chaîne\n",
+    "    X = len(tapis)\n",
+    "\n",
+    "    # Valeur de Y : nombre de points restants dans la pioche\n",
+    "    Y = comptePoints(pioche)\n",
+    "\n",
+    "    return X, Y\n",
+    "\n",
+    "# Utilisation de la fonction\n",
+    "X, Y = une_chaine_domino()\n",
+    "print(f\"X = {X}, Y = {Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e26c4cc-b76f-40b6-9146-ee2ffb396909",
+   "metadata": {},
+   "source": [
+    "# Exercice 3 (Analyse probabiliste).  \n",
+    "Simulez un grand nombre de réalisations du jeu (au moins 10000).  \n",
+    "Puis, à l'aide des méthodes déjà vues en cours et en TP :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "c86fee95-c245-407b-b93b-4c53661b08a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moyenne de X : 14.9434\n",
+      "Moyenne de Y : 47.56\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Nombre de réalisations du jeu\n",
+    "nombre_de_realisations = 10000\n",
+    "\n",
+    "# Liste pour stocker les résultats des n réalisations\n",
+    "resultats = []\n",
+    "\n",
+    "# Simulez le jeu un grand nombre de fois et stockez les résultats\n",
+    "for _ in range(nombre_de_realisations):\n",
+    "    X, Y = une_chaine_domino()\n",
+    "    resultats.append((X, Y))\n",
+    "\n",
+    "# Vous pouvez maintenant analyser les résultats pour obtenir des statistiques\n",
+    "# Par exemple, vous pouvez calculer la moyenne et l'écart-type pour X et Y.\n",
+    "moyenne_X = sum(X for X, Y in resultats) / nombre_de_realisations\n",
+    "moyenne_Y = sum(Y for X, Y in resultats) / nombre_de_realisations\n",
+    "\n",
+    "# Affichez les résultats statistiques\n",
+    "print(f\"Moyenne de X : {moyenne_X}\")\n",
+    "print(f\"Moyenne de Y : {moyenne_Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "111760f4-ecc7-4a97-84bc-de48314e0eb0",
+   "metadata": {},
+   "source": [
+    "1. Estimer et représenter la loi de probabilité de la variable X.\n",
+    "2. Calculer et tracer la fonction de répartition de X.\n",
+    "3. Estimer l'espérance de X.\n",
+    "4. Estimer la variance de X.\n",
+    "5. Mêmes questions pour la variable Y .\n",
+    "6. Estimer la probabilité de succès au jeu, c'est-à-dire, la probabilité de parvenir à placer tous\n",
+    "les dominos dans la chaine.\n",
+    "7. Estimer le nombre médian de points restants dans la pioche."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "559e0d36-2c7d-4242-a626-3a300ac4f731",
+   "metadata": {},
+   "source": [
+    "Pour répondre à ces questions, vous pouvez utiliser les résultats de votre simulation du jeu de dominos pour estimer les propriétés des variables aléatoires X et Y. Voici comment vous pouvez procéder pour chaque question :\n",
+    "\n",
+    "1. Estimer et représenter la loi de probabilité de la variable X :\n",
+    "   Pour estimer la loi de probabilité de X, comptez le nombre de fois où chaque valeur de X apparaît dans vos résultats et divisez-le par le nombre total de réalisations. Vous pouvez ensuite représenter cette distribution de probabilité sous forme d'histogramme.\n",
+    "\n",
+    "2. Calculer et tracer la fonction de répartition de X :\n",
+    "   Pour calculer la fonction de répartition (CDF) de X, triez d'abord les valeurs de X dans l'ordre croissant, puis calculez la proportion de réalisations avec des valeurs de X inférieures ou égales à chaque valeur donnée.\n",
+    "\n",
+    "3. Estimer l'espérance de X :\n",
+    "   L'espérance de X (la moyenne) peut être estimée en calculant la moyenne des valeurs de X dans vos résultats.\n",
+    "\n",
+    "4. Estimer la variance de X :\n",
+    "   Pour estimer la variance de X, calculez la variance des valeurs de X dans vos résultats. Vous pouvez également estimer l'écart-type en prenant la racine carrée de la variance.\n",
+    "\n",
+    "5. Mêmes questions pour la variable Y :\n",
+    "   Utilisez la même approche que pour X pour estimer et représenter la loi de probabilité de Y, calculer et tracer la fonction de répartition de Y, estimer l'espérance de Y et la variance de Y.\n",
+    "\n",
+    "6. Estimer la probabilité de succès au jeu :\n",
+    "   La probabilité de succès au jeu est le rapport du nombre de réalisations où X est égal au nombre total de dominos dans un jeu (28) par le nombre total de réalisations.\n",
+    "\n",
+    "7. Estimer le nombre médian de points restants dans la pioche :\n",
+    "   Pour estimer le nombre médian de points restants dans la pioche, triez d'abord les valeurs de Y dans l'ordre croissant et trouvez la médiane."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bf0079e-641d-499e-82fa-7a5f39194498",
+   "metadata": {},
+   "source": [
+    "# Exercice 4 (Covariance et corrélation) :\n",
+    "\n",
+    "1. Pour effectuer 200 réalisations du jeu, vous pouvez utiliser votre fonction `une_chaine_domino` pour obtenir les valeurs de X et Y. Ensuite, vous pouvez représenter ces valeurs sous la forme d'un nuage de points en utilisant la bibliothèque Matplotlib. Voici comment vous pouvez le faire :\n",
+    "\n",
+    "   ```python\n",
+    "   import matplotlib.pyplot as plt\n",
+    "\n",
+    "   # Effectuer 200 réalisations du jeu\n",
+    "   nombre_de_realisations = 200\n",
+    "   resultats = [une_chaine_domino() for _ in range(nombre_de_realisations)]\n",
+    "\n",
+    "   # Extraire les valeurs de X et Y dans des listes distinctes\n",
+    "   X_valeurs = [X for X, Y in resultats]\n",
+    "   Y_valeurs = [Y for X, Y in resultats]\n",
+    "\n",
+    "   # Créer un nuage de points\n",
+    "   plt.figure(figsize=(8, 6))\n",
+    "   plt.scatter(X_valeurs, Y_valeurs, alpha=0.5)\n",
+    "   plt.title('Nuage de points de X et Y')\n",
+    "   plt.xlabel('Valeurs de X')\n",
+    "   plt.ylabel('Valeurs de Y')\n",
+    "   plt.grid(True)\n",
+    "   plt.show()\n",
+    "   ```\n",
+    "\n",
+    "   L'interprétation du nuage de points peut vous permettre de visualiser s'il existe une relation entre les valeurs de X et Y.\n",
+    "\n",
+    "2. Le nombre Z = X * Y est une variable aléatoire car il dépend des variables aléatoires X et Y. Tant que X et Y sont des variables aléatoires, toute combinaison linéaire de celles-ci est également une variable aléatoire.\n",
+    "\n",
+    "3. Pour estimer l'espérance de X, Y et Z, vous pouvez calculer la moyenne des valeurs observées dans vos réalisations. Pour vérifier l'indépendance de X et Y, vous pouvez calculer la covariance de X et Y. Si la covariance est proche de zéro, cela suggère que X et Y sont indépendants. Pour le calcul de la covariance, vous pouvez utiliser la fonction `np.cov` de NumPy.\n",
+    "\n",
+    "   ```python\n",
+    "   esperance_X = np.mean(X_valeurs)\n",
+    "   esperance_Y = np.mean(Y_valeurs)\n",
+    "\n",
+    "   # Calcul de Z = X * Y pour chaque réalisation\n",
+    "   Z_valeurs = [X * Y for X, Y in resultats]\n",
+    "   esperance_Z = np.mean(Z_valeurs)\n",
+    "\n",
+    "   # Calcul de la covariance entre X et Y\n",
+    "   covariance_XY = np.cov(X_valeurs, Y_valeurs)[0, 1]\n",
+    "\n",
+    "   # Vérification d'indépendance\n",
+    "   independants = abs(covariance_XY) < 1e-10\n",
+    "   ```\n",
+    "\n",
+    "4. Pour estimer la covariance des variables X et Y, vous pouvez utiliser la valeur `covariance_XY` calculée précédemment. Pour le coefficient de corrélation, vous pouvez diviser la covariance par le produit des écarts-types de X et Y. Le coefficient de corrélation mesure la force et la direction de la relation linéaire entre les variables. Un coefficient de corrélation proche de 1 ou -1 indique une forte corrélation, tandis qu'un coefficient proche de 0 indique une faible corrélation.\n",
+    "\n",
+    "   ```python\n",
+    "   ecart_type_X = np.std(X_valeurs)\n",
+    "   ecart_type_Y = np.std(Y_valeurs)\n",
+    "   coefficient_correlation = covariance_XY / (ecart_type_X * ecart_type_Y)\n",
+    "   ```\n",
+    "\n",
+    "   Vous pouvez commenter sur la signification du coefficient de corrélation : s'il est proche de 1 ou -1, cela indique une forte corrélation linéaire entre X et Y, tandis qu'un coefficient proche de 0 indique une faible corrélation.\n",
+    "\n",
+    "Ces étapes vous permettront d'explorer la relation entre les variables X, Y et Z, d'estimer leurs espérances, de vérifier l'indépendance de X et Y, et de calculer la covariance et le coefficient de corrélation entre X et Y."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b52ef252-f23b-4087-8158-052dc6de28dc",
+   "metadata": {},
+   "source": [
+    "1) Effectuer 200 réalisations du jeu et représenter les valeurs correspondantes de X et Y sous la forme d'un nuage de points (avec un point (x,y) pour chaque réalisation de X et Y observée). Interprétez le résultat."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "c66c8f57-b527-4d67-b184-2b16e764d744",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# ... (votre code pour obtenir X_valeurs et Y_valeurs)\n",
+    "# Effectuer 200 réalisations du jeu\n",
+    "nombre_de_realisations = 200\n",
+    "resultats = [une_chaine_domino() for _ in range(nombre_de_realisations)]\n",
+    "\n",
+    "# Extraire les valeurs de X et Y dans des listes distinctes\n",
+    "X_valeurs = [X for X, Y in resultats]\n",
+    "Y_valeurs = [Y for X, Y in resultats]\n",
+    "\n",
+    "# Ajuster une régression linéaire aux points\n",
+    "coefficients = np.polyfit(X_valeurs, Y_valeurs, 1)\n",
+    "slope, intercept = coefficients\n",
+    "\n",
+    "# Créer un nuage de points\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.scatter(X_valeurs, Y_valeurs, alpha=0.5)\n",
+    "\n",
+    "# Tracer la droite de régression linéaire\n",
+    "x_range = np.linspace(min(X_valeurs), max(X_valeurs), 100)\n",
+    "y_fit = slope * x_range + intercept\n",
+    "plt.plot(x_range, y_fit, color='red', label=f'Régression Linéaire')\n",
+    "\n",
+    "plt.title('Nuage de points de X et Y avec Régression Linéaire et Médiane de Y')\n",
+    "plt.xlabel('Valeurs de X')\n",
+    "plt.ylabel('Valeurs de Y')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e625af4f-7df2-4f31-8f55-d7b9e2b96d78",
+   "metadata": {},
+   "source": [
+    "2) On définit le nombre Z = X × Y comme le produit entre X et Y . Expliquer pourquoi Z est une variable aléatoire."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78884a6a-548d-4f24-af2c-e0c2220d4e53",
+   "metadata": {},
+   "source": [
+    "Z est une variable aléatoire car c'est un produit de variables àléatoires"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "fa92c9dc-cd8f-45b4-8b33-8e98c333c419",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "esperance de X :  14.61\n",
+      "esperance de Y :  50.45\n",
+      "esperance de Z :  675.645\n",
+      "covariance de X et Y :  -61.73819095477388\n",
+      "X et Y indépendants ? :  False\n"
+     ]
+    }
+   ],
+   "source": [
+    "esperance_X = np.mean(X_valeurs)\n",
+    "esperance_Y = np.mean(Y_valeurs)\n",
+    "\n",
+    "# Calcul de Z = X * Y pour chaque réalisation\n",
+    "Z_valeurs = [X * Y for X, Y in resultats]\n",
+    "esperance_Z = np.mean(Z_valeurs)\n",
+    "\n",
+    "# Calcul de la covariance entre X et Y\n",
+    "covariance_XY = np.cov(X_valeurs, Y_valeurs)[0, 1]\n",
+    "\n",
+    "# Vérification d'indépendance\n",
+    "independants = abs(covariance_XY) < 1e-10\n",
+    "\n",
+    "print(\"esperance de X : \", esperance_X)\n",
+    "print(\"esperance de Y : \", esperance_Y)\n",
+    "\n",
+    "print(\"esperance de Z : \", esperance_Z)\n",
+    "\n",
+    "print(\"covariance de X et Y : \", covariance_XY)\n",
+    "\n",
+    "print(\"X et Y indépendants ? : \", independants)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "7fec6ae6-4157-4742-90fc-9f6e569c8446",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ecart tyope de X :  2.8527004749885676\n",
+      "ecart tyope de Y :  22.241121824224606\n",
+      "coefficient de correlation :  -0.9730631729407484\n"
+     ]
+    }
+   ],
+   "source": [
+    "ecart_type_X = np.std(X_valeurs)\n",
+    "ecart_type_Y = np.std(Y_valeurs)\n",
+    "coefficient_correlation = covariance_XY / (ecart_type_X * ecart_type_Y)\n",
+    "\n",
+    "print(\"ecart tyope de X : \", ecart_type_X)\n",
+    "print(\"ecart tyope de Y : \", ecart_type_Y)\n",
+    "print(\"coefficient de correlation : \", coefficient_correlation)"
+   ]
+  }
+ ],
+ "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2A/Maths/tp/projet/SujetTPnote.pdf b/2A/Maths/tp/projet/SujetTPnote.pdf
new file mode 100644
index 0000000..196680f
Binary files /dev/null and b/2A/Maths/tp/projet/SujetTPnote.pdf differ
diff --git a/2A/Maths/tp/projet/exercice.py b/2A/Maths/tp/projet/exercice.py
deleted file mode 100644
index 800e759..0000000
--- a/2A/Maths/tp/projet/exercice.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# Exercice 1
-
-# 1 - Combien y a t'il de dominos dans un jeu classique ?
-# un jeu de dominos classique est composé de 28 pièces dont chaque moitié comporte un certain nombre de petits points allant de 0 à 6.
-
-# 2 - Pourquoi est-il possible que le jeu s'arrête sans avoir posé tous les dominos ?
-# Il est possible que le jeu s'arrete avant d'avoir posé tout les dominos car chaque moitié comporte un certain nombre de petits points allant de 0 à 6, il est donc possible 
-
-# 3 - Pourquoi X et Y sont des variables aléatoires ?
\ No newline at end of file
diff --git a/2A/Maths/tp/projet/projet.ipynb b/2A/Maths/tp/projet/projet.ipynb
new file mode 100644
index 0000000..d8699fc
--- /dev/null
+++ b/2A/Maths/tp/projet/projet.ipynb
@@ -0,0 +1,523 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a35eeb9f-df70-4ab1-a243-2d2025888eb0",
+   "metadata": {},
+   "source": [
+    "# Exercice 1\n",
+    "1) Combien y a t'il de dominos dans un jeu classique ?  \n",
+    "Un jeu de dominos classique est composé de 28 pièces dont chaque moitié comporte un certain nombre de petits points allant de 0 à 6, sans doublons, ce qui donne 7 * 4 = 28 pièces.\n",
+    "\n",
+    "2) Pourquoi est-il possible que le jeu s'arrête sans avoir posé tous les dominos ?  \n",
+    "Il est possible que le jeu s'arrete avant d'avoir posé tout les dominos car chaque moitié comporte un certain nombre de petits points allant de 0 à 6. Si les combinaisons de dominos disponibles dans la pioche ne sont pas compatibles avec les extrémités de la chaîne déjà construite, le jeu peut se terminer sans avoir posé tous les dominos. Cela dépend de la chance et de l'ordre dans lequel les dominos sont tirés.\n",
+    "\n",
+    "3) Pourquoi X et Y sont des variables aléatoires ?  \n",
+    "X et Y sont des variables aléatoires car leur valeur dépend du hasard et des choix effectués tout au long du jeu. La variable aléatoire X représente le nombre de dominos posés dans la chaîne, et elle dépend du nombre de dominos tirés et de la possibilité de les placer à chaque étape. De même, la variable aléatoire Y représente le nombre de points restants dans la pioche, ce qui dépend également de la manière dont les dominos sont tirés et placés. En raison de la nature aléatoire du jeu, X et Y prennent des valeurs différentes à chaque partie, d'où leur caractère aléatoire. Pour comprendre leur comportement, il est nécessaire d'étudier leur distribution de probabilité."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f8b9e53-7277-4663-ad35-0db9e824d45f",
+   "metadata": {},
+   "source": [
+    "- Quelle structure de données pour représenter la pioche de dominos restants ?\n",
+    "    - La structure nécéssaire est une file car on insere en queue mais on supprime en tete\n",
+    "- Quelle structure de données pour représenter la chaîne de dominos déjà construite? (Sachant qu'il suffit de considérer l'information pertinente pour le déroulement du jeu.)\n",
+    "    - Une liste car c'est une fassons simple de stocker les dominos mis en place sur le tapis\n",
+    "- Comment savoir si le jeu est \u001c",
+    "fini ?\n",
+    "    - si on ne peut plus inserer en tete ou en queue les dominos de la pioche.\n",
+    "- Est-il éventuellement utile d'écrire certaines sous-fonctions, afin de clarifier le code ?  \n",
+    "Ca peut être plus simple à comprendre le code, notamment pour le comptage de Y."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "060f3b6e-ed57-4ecc-9338-f2491f54bd74",
+   "metadata": {},
+   "source": [
+    "exemple de file en python :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "bee8d798-d9bb-464c-9b66-329678fa2fda",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "[2, 3]\n"
+     ]
+    }
+   ],
+   "source": [
+    "queue = []                 # la file est vide\n",
+    "\n",
+    "queue.append(1)            # la file contient [1]\n",
+    "queue.append(2)            # la file contient [1, 2]\n",
+    "queue.append(3)            # la file contient [1, 2, 3]\n",
+    "\n",
+    "result = queue.pop(0)      # la file contient [2, 3]\n",
+    "\n",
+    "print(result)\n",
+    "print(queue)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fabca55-4ebf-4499-b652-86844be439e5",
+   "metadata": {},
+   "source": [
+    "**Initialisation et affichage de la pioche**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "fe55883a-6887-43dd-9498-5333a51799e2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1, 1]\n",
+      "[1, 2]\n",
+      "[1, 3]\n",
+      "[1, 4]\n",
+      "[1, 5]\n",
+      "[1, 6]\n",
+      "[2, 2]\n",
+      "[2, 3]\n",
+      "[2, 4]\n",
+      "[2, 5]\n",
+      "[2, 6]\n",
+      "[3, 3]\n",
+      "[3, 4]\n",
+      "[3, 5]\n",
+      "[3, 6]\n",
+      "[4, 4]\n",
+      "[4, 5]\n",
+      "[4, 6]\n",
+      "[5, 5]\n",
+      "[5, 6]\n",
+      "[6, 6]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "\n",
+    "# initialisation de la pioche contenant 28 pièces\n",
+    "pioche = [[i, j] for i in range(1,7) for j in range(i, 7)]\n",
+    "\n",
+    "# Exemple d'utilisation : affichez la file de dominos\n",
+    "for domino in pioche:\n",
+    "    print(domino)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "09689b16-24dc-4025-bad9-90d0fe385b6b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def comptePoints(P):\n",
+    "    # Initialise un compteur pour les points\n",
+    "    nb = 0\n",
+    "    \n",
+    "    # Parcours tous les dominos de la liste\n",
+    "    for domino in P:\n",
+    "        # Ajoute les points des deux moitiés du domino\n",
+    "        nb += sum(domino)\n",
+    "    \n",
+    "    return nb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "f62cffa4-8e44-4b62-a49a-c3b4c9c50964",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X = 13, Y = 70\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fonction pour simuler une partie du jeu de dominos\n",
+    "def une_chaine_domino():\n",
+    "    # Liste représentant les dominos sur le jeu\n",
+    "    tapis = []\n",
+    "\n",
+    "    #initialisation d'une variable pour compter le nombre de pioche dans la pioche\n",
+    "    cpt = 0\n",
+    "    \n",
+    "    # Liste représentant la pioche de dominos restants\n",
+    "    pioche = [(i, j) for i in range(1, 7) for j in range(i, 7)]\n",
+    "\n",
+    "    # Tant que la pioche n'est pas vide et qu'on peut poser des dominos\n",
+    "    while pioche:\n",
+    "        domino = random.choice(pioche)  # Tirer un domino au hasard\n",
+    "        pioche.remove(domino)  # Retirer le domino de la pioche\n",
+    "\n",
+    "        if not tapis:  # Si c'est le premier domino, ajoutez-le directement\n",
+    "            tapis.append(domino)\n",
+    "        else:\n",
+    "            # Vérifiez si le domino peut être placé à l'une des extrémités de la chaîne\n",
+    "            if domino[0] == tapis[0][0] or domino[1] == tapis[0][0]:\n",
+    "                tapis.insert(0, domino)  # Placez-le au début de la chaîne\n",
+    "                cpt = 0;\n",
+    "            elif domino[0] == tapis[0][1] or domino[1] == tapis[0][1]: # On regarde le second argument du premier couple du tapis\n",
+    "                tapis.append(domino)  # Placez-le à la fin de la chaîne\n",
+    "                cpt = 0;\n",
+    "            else:\n",
+    "                pioche.append(domino)\n",
+    "                cpt = cpt + 1;\n",
+    "                if(cpt > len(pioche)):\n",
+    "                    break  # Si après un tour entier de la pioche est éfféctué sans pour voir placer un domino\n",
+    "\n",
+    "    # Valeur de X : nombre de dominos posés dans la chaîne\n",
+    "    X = len(tapis)\n",
+    "\n",
+    "    # Valeur de Y : nombre de points restants dans la pioche\n",
+    "    Y = comptePoints(pioche)\n",
+    "\n",
+    "    return X, Y\n",
+    "\n",
+    "# Utilisation de la fonction\n",
+    "X, Y = une_chaine_domino()\n",
+    "print(f\"X = {X}, Y = {Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0e26c4cc-b76f-40b6-9146-ee2ffb396909",
+   "metadata": {},
+   "source": [
+    "# Exercice 3 (Analyse probabiliste).  \n",
+    "Simulez un grand nombre de réalisations du jeu (au moins 10000).  \n",
+    "Puis, à l'aide des méthodes déjà vues en cours et en TP :"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "c86fee95-c245-407b-b93b-4c53661b08a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Moyenne de X : 14.9434\n",
+      "Moyenne de Y : 47.56\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Nombre de réalisations du jeu\n",
+    "nombre_de_realisations = 10000\n",
+    "\n",
+    "# Liste pour stocker les résultats des n réalisations\n",
+    "resultats = []\n",
+    "\n",
+    "# Simulez le jeu un grand nombre de fois et stockez les résultats\n",
+    "for _ in range(nombre_de_realisations):\n",
+    "    X, Y = une_chaine_domino()\n",
+    "    resultats.append((X, Y))\n",
+    "\n",
+    "# Vous pouvez maintenant analyser les résultats pour obtenir des statistiques\n",
+    "# Par exemple, vous pouvez calculer la moyenne et l'écart-type pour X et Y.\n",
+    "moyenne_X = sum(X for X, Y in resultats) / nombre_de_realisations\n",
+    "moyenne_Y = sum(Y for X, Y in resultats) / nombre_de_realisations\n",
+    "\n",
+    "# Affichez les résultats statistiques\n",
+    "print(f\"Moyenne de X : {moyenne_X}\")\n",
+    "print(f\"Moyenne de Y : {moyenne_Y}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "111760f4-ecc7-4a97-84bc-de48314e0eb0",
+   "metadata": {},
+   "source": [
+    "1. Estimer et représenter la loi de probabilité de la variable X.\n",
+    "2. Calculer et tracer la fonction de répartition de X.\n",
+    "3. Estimer l'espérance de X.\n",
+    "4. Estimer la variance de X.\n",
+    "5. Mêmes questions pour la variable Y .\n",
+    "6. Estimer la probabilité de succès au jeu, c'est-à-dire, la probabilité de parvenir à placer tous\n",
+    "les dominos dans la chaine.\n",
+    "7. Estimer le nombre médian de points restants dans la pioche."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "559e0d36-2c7d-4242-a626-3a300ac4f731",
+   "metadata": {},
+   "source": [
+    "Pour répondre à ces questions, vous pouvez utiliser les résultats de votre simulation du jeu de dominos pour estimer les propriétés des variables aléatoires X et Y. Voici comment vous pouvez procéder pour chaque question :\n",
+    "\n",
+    "1. Estimer et représenter la loi de probabilité de la variable X :\n",
+    "   Pour estimer la loi de probabilité de X, comptez le nombre de fois où chaque valeur de X apparaît dans vos résultats et divisez-le par le nombre total de réalisations. Vous pouvez ensuite représenter cette distribution de probabilité sous forme d'histogramme.\n",
+    "\n",
+    "2. Calculer et tracer la fonction de répartition de X :\n",
+    "   Pour calculer la fonction de répartition (CDF) de X, triez d'abord les valeurs de X dans l'ordre croissant, puis calculez la proportion de réalisations avec des valeurs de X inférieures ou égales à chaque valeur donnée.\n",
+    "\n",
+    "3. Estimer l'espérance de X :\n",
+    "   L'espérance de X (la moyenne) peut être estimée en calculant la moyenne des valeurs de X dans vos résultats.\n",
+    "\n",
+    "4. Estimer la variance de X :\n",
+    "   Pour estimer la variance de X, calculez la variance des valeurs de X dans vos résultats. Vous pouvez également estimer l'écart-type en prenant la racine carrée de la variance.\n",
+    "\n",
+    "5. Mêmes questions pour la variable Y :\n",
+    "   Utilisez la même approche que pour X pour estimer et représenter la loi de probabilité de Y, calculer et tracer la fonction de répartition de Y, estimer l'espérance de Y et la variance de Y.\n",
+    "\n",
+    "6. Estimer la probabilité de succès au jeu :\n",
+    "   La probabilité de succès au jeu est le rapport du nombre de réalisations où X est égal au nombre total de dominos dans un jeu (28) par le nombre total de réalisations.\n",
+    "\n",
+    "7. Estimer le nombre médian de points restants dans la pioche :\n",
+    "   Pour estimer le nombre médian de points restants dans la pioche, triez d'abord les valeurs de Y dans l'ordre croissant et trouvez la médiane."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8bf0079e-641d-499e-82fa-7a5f39194498",
+   "metadata": {},
+   "source": [
+    "# Exercice 4 (Covariance et corrélation) :\n",
+    "\n",
+    "1. Pour effectuer 200 réalisations du jeu, vous pouvez utiliser votre fonction `une_chaine_domino` pour obtenir les valeurs de X et Y. Ensuite, vous pouvez représenter ces valeurs sous la forme d'un nuage de points en utilisant la bibliothèque Matplotlib. Voici comment vous pouvez le faire :\n",
+    "\n",
+    "   ```python\n",
+    "   import matplotlib.pyplot as plt\n",
+    "\n",
+    "   # Effectuer 200 réalisations du jeu\n",
+    "   nombre_de_realisations = 200\n",
+    "   resultats = [une_chaine_domino() for _ in range(nombre_de_realisations)]\n",
+    "\n",
+    "   # Extraire les valeurs de X et Y dans des listes distinctes\n",
+    "   X_valeurs = [X for X, Y in resultats]\n",
+    "   Y_valeurs = [Y for X, Y in resultats]\n",
+    "\n",
+    "   # Créer un nuage de points\n",
+    "   plt.figure(figsize=(8, 6))\n",
+    "   plt.scatter(X_valeurs, Y_valeurs, alpha=0.5)\n",
+    "   plt.title('Nuage de points de X et Y')\n",
+    "   plt.xlabel('Valeurs de X')\n",
+    "   plt.ylabel('Valeurs de Y')\n",
+    "   plt.grid(True)\n",
+    "   plt.show()\n",
+    "   ```\n",
+    "\n",
+    "   L'interprétation du nuage de points peut vous permettre de visualiser s'il existe une relation entre les valeurs de X et Y.\n",
+    "\n",
+    "2. Le nombre Z = X * Y est une variable aléatoire car il dépend des variables aléatoires X et Y. Tant que X et Y sont des variables aléatoires, toute combinaison linéaire de celles-ci est également une variable aléatoire.\n",
+    "\n",
+    "3. Pour estimer l'espérance de X, Y et Z, vous pouvez calculer la moyenne des valeurs observées dans vos réalisations. Pour vérifier l'indépendance de X et Y, vous pouvez calculer la covariance de X et Y. Si la covariance est proche de zéro, cela suggère que X et Y sont indépendants. Pour le calcul de la covariance, vous pouvez utiliser la fonction `np.cov` de NumPy.\n",
+    "\n",
+    "   ```python\n",
+    "   esperance_X = np.mean(X_valeurs)\n",
+    "   esperance_Y = np.mean(Y_valeurs)\n",
+    "\n",
+    "   # Calcul de Z = X * Y pour chaque réalisation\n",
+    "   Z_valeurs = [X * Y for X, Y in resultats]\n",
+    "   esperance_Z = np.mean(Z_valeurs)\n",
+    "\n",
+    "   # Calcul de la covariance entre X et Y\n",
+    "   covariance_XY = np.cov(X_valeurs, Y_valeurs)[0, 1]\n",
+    "\n",
+    "   # Vérification d'indépendance\n",
+    "   independants = abs(covariance_XY) < 1e-10\n",
+    "   ```\n",
+    "\n",
+    "4. Pour estimer la covariance des variables X et Y, vous pouvez utiliser la valeur `covariance_XY` calculée précédemment. Pour le coefficient de corrélation, vous pouvez diviser la covariance par le produit des écarts-types de X et Y. Le coefficient de corrélation mesure la force et la direction de la relation linéaire entre les variables. Un coefficient de corrélation proche de 1 ou -1 indique une forte corrélation, tandis qu'un coefficient proche de 0 indique une faible corrélation.\n",
+    "\n",
+    "   ```python\n",
+    "   ecart_type_X = np.std(X_valeurs)\n",
+    "   ecart_type_Y = np.std(Y_valeurs)\n",
+    "   coefficient_correlation = covariance_XY / (ecart_type_X * ecart_type_Y)\n",
+    "   ```\n",
+    "\n",
+    "   Vous pouvez commenter sur la signification du coefficient de corrélation : s'il est proche de 1 ou -1, cela indique une forte corrélation linéaire entre X et Y, tandis qu'un coefficient proche de 0 indique une faible corrélation.\n",
+    "\n",
+    "Ces étapes vous permettront d'explorer la relation entre les variables X, Y et Z, d'estimer leurs espérances, de vérifier l'indépendance de X et Y, et de calculer la covariance et le coefficient de corrélation entre X et Y."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b52ef252-f23b-4087-8158-052dc6de28dc",
+   "metadata": {},
+   "source": [
+    "1) Effectuer 200 réalisations du jeu et représenter les valeurs correspondantes de X et Y sous la forme d'un nuage de points (avec un point (x,y) pour chaque réalisation de X et Y observée). Interprétez le résultat."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "c66c8f57-b527-4d67-b184-2b16e764d744",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "# ... (votre code pour obtenir X_valeurs et Y_valeurs)\n",
+    "# Effectuer 200 réalisations du jeu\n",
+    "nombre_de_realisations = 200\n",
+    "resultats = [une_chaine_domino() for _ in range(nombre_de_realisations)]\n",
+    "\n",
+    "# Extraire les valeurs de X et Y dans des listes distinctes\n",
+    "X_valeurs = [X for X, Y in resultats]\n",
+    "Y_valeurs = [Y for X, Y in resultats]\n",
+    "\n",
+    "# Ajuster une régression linéaire aux points\n",
+    "coefficients = np.polyfit(X_valeurs, Y_valeurs, 1)\n",
+    "slope, intercept = coefficients\n",
+    "\n",
+    "# Créer un nuage de points\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "plt.scatter(X_valeurs, Y_valeurs, alpha=0.5)\n",
+    "\n",
+    "# Tracer la droite de régression linéaire\n",
+    "x_range = np.linspace(min(X_valeurs), max(X_valeurs), 100)\n",
+    "y_fit = slope * x_range + intercept\n",
+    "plt.plot(x_range, y_fit, color='red', label=f'Régression Linéaire')\n",
+    "\n",
+    "plt.title('Nuage de points de X et Y avec Régression Linéaire et Médiane de Y')\n",
+    "plt.xlabel('Valeurs de X')\n",
+    "plt.ylabel('Valeurs de Y')\n",
+    "plt.legend()\n",
+    "plt.grid(True)\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e625af4f-7df2-4f31-8f55-d7b9e2b96d78",
+   "metadata": {},
+   "source": [
+    "2) On définit le nombre Z = X × Y comme le produit entre X et Y . Expliquer pourquoi Z est une variable aléatoire."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "78884a6a-548d-4f24-af2c-e0c2220d4e53",
+   "metadata": {},
+   "source": [
+    "Z est une variable aléatoire car c'est un produit de variables àléatoires"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "fa92c9dc-cd8f-45b4-8b33-8e98c333c419",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "esperance de X :  14.61\n",
+      "esperance de Y :  50.45\n",
+      "esperance de Z :  675.645\n",
+      "covariance de X et Y :  -61.73819095477388\n",
+      "X et Y indépendants ? :  False\n"
+     ]
+    }
+   ],
+   "source": [
+    "esperance_X = np.mean(X_valeurs)\n",
+    "esperance_Y = np.mean(Y_valeurs)\n",
+    "\n",
+    "# Calcul de Z = X * Y pour chaque réalisation\n",
+    "Z_valeurs = [X * Y for X, Y in resultats]\n",
+    "esperance_Z = np.mean(Z_valeurs)\n",
+    "\n",
+    "# Calcul de la covariance entre X et Y\n",
+    "covariance_XY = np.cov(X_valeurs, Y_valeurs)[0, 1]\n",
+    "\n",
+    "# Vérification d'indépendance\n",
+    "independants = abs(covariance_XY) < 1e-10\n",
+    "\n",
+    "print(\"esperance de X : \", esperance_X)\n",
+    "print(\"esperance de Y : \", esperance_Y)\n",
+    "\n",
+    "print(\"esperance de Z : \", esperance_Z)\n",
+    "\n",
+    "print(\"covariance de X et Y : \", covariance_XY)\n",
+    "\n",
+    "print(\"X et Y indépendants ? : \", independants)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "7fec6ae6-4157-4742-90fc-9f6e569c8446",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ecart tyope de X :  2.8527004749885676\n",
+      "ecart tyope de Y :  22.241121824224606\n",
+      "coefficient de correlation :  -0.9730631729407484\n"
+     ]
+    }
+   ],
+   "source": [
+    "ecart_type_X = np.std(X_valeurs)\n",
+    "ecart_type_Y = np.std(Y_valeurs)\n",
+    "coefficient_correlation = covariance_XY / (ecart_type_X * ecart_type_Y)\n",
+    "\n",
+    "print(\"ecart tyope de X : \", ecart_type_X)\n",
+    "print(\"ecart tyope de Y : \", ecart_type_Y)\n",
+    "print(\"coefficient de correlation : \", coefficient_correlation)"
+   ]
+  }
+ ],
+ "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}