diff --git a/maths/chap2/chap.json b/maths/chap2/chap.json
new file mode 100644
index 0000000..0169c77
--- /dev/null
+++ b/maths/chap2/chap.json
@@ -0,0 +1,5 @@
+{
+    "title": "Dénombrement",
+    "description": "", 
+    "difficulty": 3
+}
diff --git "a/maths/chap2/partie1/G\303\251n\303\251ration des permutations d\342\200\231un ensemble fini, ou tirage al\303\251atoire d\342\200\231une permutation .md" "b/maths/chap2/partie1/G\303\251n\303\251ration des permutations d\342\200\231un ensemble fini, ou tirage al\303\251atoire d\342\200\231une permutation .md"
new file mode 100644
index 0000000..89ea717
--- /dev/null
+++ "b/maths/chap2/partie1/G\303\251n\303\251ration des permutations d\342\200\231un ensemble fini, ou tirage al\303\251atoire d\342\200\231une permutation .md"	
@@ -0,0 +1,123 @@
+\# Chapitre 2 \- Partie 1 : Génération des permutations d’un ensemble fini
+
+\#\# INTRODUCTION  
+Dans ce chapitre, nous étudions comment manipuler l'ordre des éléments d'un ensemble fini. Cette notion est fondamentale en combinatoire (dénombrement) et en informatique, que ce soit pour tester toutes les possibilités d'un problème ou pour simuler des phénomènes aléatoires (jeux de cartes, échantillonnage).
+
+\#\#\# Définitions  
+\* \*\*Permutation :\*\* Soit E un ensemble fini de n éléments. Une permutation de E est une liste ordonnée contenant tous les éléments de E une et une seule fois.   
+\* \*\*Dénombrement :\*\* Le nombre de permutations d'un ensemble à n éléments est donné par la factorielle de n, notée n\! :
+
+$$n\! \= n \\times (n-1) \\times (n-2) \\times \\dots \\times 2 \\times 1$$
+
+Par convention, $0\! \= 1$.
+
+\---
+
+\#\# Algorithme \- Cas 1 : Génération systématique (exhaustive)
+
+\#\#\# Idée générale  
+⇒ L'objectif est de lister toutes les permutations possibles sans en oublier aucune. On utilise une approche récursive basée sur un arbre de choix : on fixe un premier élément, puis on recommence le processus avec les éléments restants.
+
+\#\#\# Méthode générale  
+\* \*\*Cas de base :\*\* Si l'ensemble ne contient qu'un élément, la seule permutation est l'élément lui-même.  
+\* \*\*Hérédité (Récursion) :\*\* Pour générer les permutations d'un ensemble E :  
+    \* Pour chaque élément x de E :  
+        1\. Placer x en première position.  
+        2\. Générer toutes les permutations de l'ensemble E∖{x}.  
+        3\. Associer x à chacune de ces permutations.
+
+\#\#\# Exemples pour visualiser  
+Pour E={A,B,C}, on a $3\! \= 6$ permutations :  
+\* On fixe A : il reste {B,C}. On peut avoir (B,C) ou (C,B).  
+    \* Résultats : (A,B,C) et (A,C,B).  
+\* On fixe B : il reste {A,C}. On peut avoir (A,C) ou (C,A).  
+    \* Résultats : (B,A,C) et (B,C,A).  
+\* On fixe C : il reste {A,B}. On peut avoir (A,B) ou (B,A).  
+    \* Résultats : (C,A,B) et (C,B,A).
+
+\#\#\# → EXERCICES d’application directs  
+\* \*\*Calcul :\*\* Calculez 5\! et déduisez-en le nombre de façons d'ordonner 5 livres sur une étagère.  
+\* \*\*Logique :\*\* Si on génère les permutations de {1,2,3,4,5}, combien de permutations commencent par le chiffre 3 ?  
+\* \*\*Représentation :\*\* Dessinez l'arbre complet des permutations pour l'ensemble {1,2,3}.
+
+\*\* CORRECTIONS :\*\*  
+\* \*\*Calcul :\*\* $5\! \= 5 \\times 4 \\times 3 \\times 2 \\times 1 \= 120$. Il y a donc 120 façons différentes d'ordonner ces 5 livres sur l'étagère.  
+\* \*\*Logique :\*\* Si le chiffre 3 est fixé en première position, il reste 4 éléments $\\{1, 2, 4, 5\\}$ à ordonner. Le nombre de permutations pour ces 4 éléments restants est de $4\! \= 24$. Il y a donc 24 permutations qui commencent par le chiffre 3\.  
+\* \*\*Représentation :\*\*  
+    \* \*\*Choix 1 :\*\* On fixe 1 $\\rightarrow$ Reste $\\{2, 3\\} \\rightarrow$ Branches finales : (1, 2, 3\) et (1, 3, 2\)  
+    \* \*\*Choix 2 :\*\* On fixe 2 $\\rightarrow$ Reste $\\{1, 3\\} \\rightarrow$ Branches finales : (2, 1, 3\) et (2, 3, 1\)  
+    \* \*\*Choix 3 :\*\* On fixe 3 $\\rightarrow$ Reste $\\{1, 2\\} \\rightarrow$ Branches finales : (3, 1, 2\) et (3, 2, 1\)
+
+\---
+
+\#\# Algorithme \- Cas 2 : Tirage aléatoire (Mélange de Fisher-Yates)
+
+\#\#\# Idée générale  
+⇒ Lorsque n est grand, il est impossible de lister toutes les permutations (ex: 52\! pour un jeu de cartes). On cherche alors à obtenir une seule permutation au hasard, de manière "équiprobable" (chaque permutation doit avoir la même chance de sortir).
+
+\#\#\# Méthode générale (Algorithme de Knuth / Fisher-Yates)  
+On parcourt la liste de la fin vers le début et on procède à des échanges :  
+1\.  Soit une liste L de n éléments (indices de 0 à n−1).  
+2\.  Pour i allant de n−1 à 1 (par pas de \-1) :  
+    \* Choisir un entier aléatoire j tel que $0 \\le j \\le i$.  
+    \* Échanger les éléments situés aux indices i et j.
+
+\#\#\# Exemples pour visualiser  
+Mélangeons \[X,Y,Z\] (indices 0, 1, 2\) :  
+\* Étape 1 (i=2) : On choisit j entre 0 et 2\. Supposons j=0. On échange L\[2\] et L\[0\].  
+    \* La liste devient \[Z,Y,X\]. L'élément X est "fixé" à sa place finale.  
+\* Étape 2 (i=1) : On choisit j entre 0 et 1\. Supposons j=1. On échange L\[1\] et L\[1\] (pas de changement).  
+    \* La liste reste \[Z,Y,X\].  
+\* Résultat : La permutation aléatoire obtenue est (Z,Y,X).
+
+\#\#\# → EXERCICES d’application directs  
+\* \*\*Simulation :\*\* Appliquez l'algorithme à la main sur la liste \[1,2,3,4\] avec les tirages successifs suivants : j=1 (pour i=3), puis j=0 (pour i=2), puis j=0 (pour i=1). Quel est le résultat final ?  
+\* \*\*Analyse :\*\* Pourquoi ne tire-t-on pas j entre 0 et n−1 à chaque étape ? (Question de réflexion sur l'uniformité du mélange).
+
+\*\* CORRECTIONS :\*\*  
+\* \*\*Simulation :\*\*  
+    \* État initial : \`\[1, 2, 3, 4\]\`  
+    \* Étape 1 ($i=3$, $j=1$) : On échange l'indice 3 (valeur 4\) avec l'indice 1 (valeur 2). La liste devient \`\[1, 4, 3, 2\]\`.  
+    \* Étape 2 ($i=2$, $j=0$) : On échange l'indice 2 (valeur 3\) avec l'indice 0 (valeur 1). La liste devient \`\[3, 4, 1, 2\]\`.  
+    \* Étape 3 ($i=1$, $j=0$) : On échange l'indice 1 (valeur 4\) avec l'indice 0 (valeur 3). La liste devient \`\[4, 3, 1, 2\]\`.  
+    \* \*\*Résultat final :\*\* \`\[4, 3, 1, 2\]\`  
+\* \*\*Analyse :\*\* C'est pour garantir un mélange équiprobable. Si l'on tirait $j$ de $0$ à $n-1$ à chaque étape, l'algorithme effectuerait $n^n$ chemins possibles. Or, $n^n$ n'est pas un multiple de $n\!$ (le nombre total de permutations). En conséquence, le hasard serait biaisé. L'algorithme de Fisher-Yates, avec sa borne glissante $j \\le i$, offre exactement $n\!$ chemins possibles, garantissant une parfaite uniformité.
+
+\---
+
+\#\# Algorithme \- Cas 3 : Permutations avec éléments identiques (Anagrammes)
+
+\#\#\# Idée générale  
+⇒ Jusqu'à présent, nous avons permuté des éléments tous distincts. Mais que se passe-t-il si notre ensemble de départ contient des doublons ? L'idée est de générer (ou dénombrer) les permutations, puis d'éliminer les "doublons" créés par le fait que changer de place deux éléments identiques ne modifie pas le résultat final.
+
+\#\#\# Méthode générale  
+Pour calculer le nombre de permutations distinctes d'un ensemble de n éléments où un élément se répète $n\_1$ fois, un autre $n\_2$ fois, etc., on utilise la formule :  
+$$\\frac{n\!}{n\_1\! \\times n\_2\! \\times \\dots \\times n\_k\!}$$
+
+\#\#\# Exemples pour visualiser  
+Cherchons toutes les anagrammes du mot \*\*"ELLE"\*\*.  
+\* Nombre total de lettres : $n \= 4$. Donc $4\! \= 24$ permutations au total.  
+\* Répétitions : La lettre 'E' apparait 2 fois ($2\! \= 2$). La lettre 'L' apparait 2 fois ($2\! \= 2$).  
+\* Nombre de permutations distinctes : $\\frac{4\!}{2\! \\times 2\!} \= \\frac{24}{2 \\times 2} \= \\frac{24}{4} \= 6$.  
+\* \*Vérification visuelle :\* ELLE, ELEL, EELL, LELE, LEEL, LLEE. On retrouve bien exactement 6 combinaisons.
+
+\#\#\# → EXERCICES d’application directs  
+1\. \*\*Dénombrement simple :\*\* Combien d'anagrammes distinctes peut-on former avec le mot "MATHS" ?  
+2\. \*\*Dénombrement avec répétitions :\*\* Calculez le nombre d'anagrammes distinctes du mot "ANANAS".
+
+\*\* CORRECTIONS :\*\*  
+\* \*\*Dénombrement simple :\*\* Les 5 lettres de "MATHS" sont toutes distinctes. Il s'agit d'une permutation classique du Cas 1\. Le calcul est donc $5\! \= 120$.  
+\* \*\*Dénombrement avec répétitions :\*\* Le mot "ANANAS" contient 6 lettres ($n=6$). Il y a des répétitions : 'A' apparait 3 fois, 'N' apparait 2 fois, et 'S' apparait 1 fois.  
+Le calcul est : $\\frac{6\!}{3\! \\times 2\! \\times 1\!} \= \\frac{720}{6 \\times 2 \\times 1} \= \\frac{720}{12} \= 60$. Il y a 60 anagrammes distinctes.
+
+\---
+
+\#\# Résumé global \+ Conseils  
+\* \*\*Complexité :\*\* La génération exhaustive (Cas 1\) a une complexité en O(n\!), ce qui devient inutilisable très vite. Le mélange aléatoire (Cas 2\) est en O(n), il est extrêmement efficace.  
+\* \*\*Utilisation :\*\*  
+    \* Toutes les permutations → Problèmes d'optimisation (ex: voyageur de commerce sur très peu de villes).  
+    \* Une permutation aléatoire → Simulations de Monte-Carlo, jeux, cryptographie.  
+    \* Permutations avec doublons → Problèmes d'anagrammes, chemins sur quadrillage.  
+\* \*\*Conseils :\*\*  
+    \* Attention aux indices lors de l'implémentation du mélange (la borne $j \\le i$ est cruciale).  
+  
diff --git a/maths/chap2/partie1/lesson1.json b/maths/chap2/partie1/lesson1.json
new file mode 100644
index 0000000..2ca5415
--- /dev/null
+++ b/maths/chap2/partie1/lesson1.json
@@ -0,0 +1,4 @@
+{
+  "title": "Génération des permutations d’un ensemble fini",
+  "difficulty": 3
+}
diff --git a/maths/chap2/partie1/partie1.json b/maths/chap2/partie1/partie1.json
new file mode 100644
index 0000000..32e026f
--- /dev/null
+++ b/maths/chap2/partie1/partie1.json
@@ -0,0 +1,6 @@
+{
+    "title": "Génération des permutations d’un ensemble fini
+",
+    "description": "",
+    "difficulty": 3
+}
diff --git "a/maths/chap2/partie2/G\303\251n\303\251ration des parties \303\240 2, 3 \303\251l\303\251ments d\342\200\231un ensemble fini.md" "b/maths/chap2/partie2/G\303\251n\303\251ration des parties \303\240 2, 3 \303\251l\303\251ments d\342\200\231un ensemble fini.md"
new file mode 100644
index 0000000..b0cf8ab
--- /dev/null
+++ "b/maths/chap2/partie2/G\303\251n\303\251ration des parties \303\240 2, 3 \303\251l\303\251ments d\342\200\231un ensemble fini.md"	
@@ -0,0 +1,89 @@
+\# Chapitre 2 \- Partie 2 : Génération des parties à 2 et 3 éléments d’un ensemble fini
+
+\#\# INTRODUCTION
+
+Après avoir étudié les \*\*permutations\*\* (où l'ordre des éléments compte), nous nous intéressons maintenant aux \*\*parties\*\* (ou sous-ensembles). Dans une partie, l'ordre n'a aucune importance : l'ensemble $\\{A, B\\}$ est le même que $\\{B, A\\}$.
+
+\#\#\# Définitions  
+\* \*\*Combinaison :\*\* Une combinaison de $k$ éléments parmi $n$ est un sous-ensemble de $k$ éléments distincts choisis dans un ensemble $E$ de cardinal $n$.  
+\* \*\*Coefficient binomial :\*\* Le nombre de ces parties est noté $\\binom{n}{k}$ (se lit "$k$ parmi $n$"). Il se calcule par :  
+    $$\\binom{n}{k} \= \\frac{n\!}{k\!(n-k)\!}$$  
+\* \*\*Propriété de génération :\*\* Pour générer des parties sans doublons (ex: ne pas lister $\\{1, 2\\}$ puis $\\{2, 1\\}$), on impose généralement un \*\*ordre strict\*\* sur les indices : $i \< j \< l \\dots$
+
+\---
+
+\#\# Algorithme \- Cas 1 : Génération des parties à 2 éléments (paires)
+
+\#\#\# Idée générale  
+⇒ Pour générer toutes les paires $\\{x\_i, x\_j\\}$ d'un ensemble de taille $n$, on utilise deux boucles imbriquées. La clé pour éviter les répétitions est que la deuxième boucle commence toujours après l'indice de la première.
+
+\#\#\# Méthode générale  
+Pour un ensemble $E$ d'indices allant de $0$ à $n-1$ :  
+1\. Pour $i$ allant de $0$ à $n-2$ :  
+2\. Pour $j$ allant de $i \+ 1$ à $n-1$ :  
+3\. Afficher la paire $\\{E\[i\], E\[j\]\\}$.
+
+\#\#\# Exemples pour visualiser  
+Soit $E \= \\{1, 2, 3, 4\\}$. Ici $n=4$. On attend $\\binom{4}{2} \= 6$ paires.  
+\* \*\*$i \= 0$ (élément '1') :\*\* $j$ varie de $1$ à $3$.  
+    \* Paires : $\\{1, 2\\}$, $\\{1, 3\\}$, $\\{1, 4\\}$.  
+\* \*\*$i \= 1$ (élément '2') :\*\* $j$ varie de $2$ à $3$.  
+    \* Paires : $\\{2, 3\\}$, $\\{2, 4\\}$. (On ne reprend pas '1' car $j \> i$).  
+\* \*\*$i \= 2$ (élément '3') :\*\* $j$ varie de $3$ à $3$.  
+    \* Paire : $\\{3, 4\\}$.  
+\* \*\*$i \= 3$ :\*\* La boucle $j$ ne peut pas démarrer ($j$ doit être $\> 3$). Fin.
+
+\#\#\# → EXERCICES d’application directs  
+1\. \*\*Calcul :\*\* Combien de paires peut-on former avec un ensemble de 10 personnes ?  
+2\. \*\*Algorithme :\*\* Énumérez toutes les parties à 2 éléments de l'ensemble $\\{A, B, C, D, E\\}$.
+
+\*\* CORRECTIONS :\*\*  
+1\. \*\*Calcul :\*\* $\\binom{10}{2} \= \\frac{10 \\times 9}{2 \\times 1} \= 45$. On peut former 45 paires.  
+2\. \*\*Algorithme :\*\* $\\{A,B\\}, \\{A,C\\}, \\{A,D\\}, \\{A,E\\}, \\{B,C\\}, \\{B,D\\}, \\{B,E\\}, \\{C,D\\}, \\{C,E\\}, \\{D,E\\}$.
+
+\---
+
+\#\# Algorithme \- Cas 2 : Génération des parties à 3 éléments (triplets)
+
+\#\#\# Idée générale  
+⇒ C'est une extension du cas précédent. Pour un triplet $\\{x\_i, x\_j, x\_l\\}$, on utilise trois boucles imbriquées avec la condition $i \< j \< l$.
+
+\#\#\# Méthode générale  
+1\. Pour $i$ allant de $0$ à $n-3$ :  
+2\. Pour $j$ allant de $i \+ 1$ à $n-2$ :  
+3\. Pour $l$ allant de $j \+ 1$ à $n-1$ :  
+4\. Afficher le triplet $\\{E\[i\], E\[j\], E\[l\]\\}$.
+
+\#\#\# Exemples pour visualiser  
+Soit $E \= \\{A, B, C, D, E\\}$. $n=5$, on attend $\\binom{5}{3} \= 10$ triplets.  
+\* \*\*$i=0 (A)$ :\*\*  
+    \* $j=1 (B) \\rightarrow l \\in \\{2, 3, 4\\}$ : $\\{A,B,C\\}, \\{A,B,D\\}, \\{A,B,E\\}$  
+    \* $j=2 (C) \\rightarrow l \\in \\{3, 4\\}$ : $\\{A,C,D\\}, \\{A,C,E\\}$  
+    \* $j=3 (D) \\rightarrow l \\in \\{4\\}$ : $\\{A,D,E\\}$  
+\* \*\*$i=1 (B)$ :\*\*  
+    \* $j=2 (C) \\rightarrow l \\in \\{3, 4\\}$ : $\\{B,C,D\\}, \\{B,C,E\\}$  
+    \* $j=3 (D) \\rightarrow l \\in \\{4\\}$ : $\\{B,D,E\\}$  
+\* \*\*$i=2 (C)$ :\*\*  
+    \* $j=3 (D) \\rightarrow l \\in \\{4\\}$ : $\\{C,D,E\\}$
+
+\#\#\# → EXERCICES d’application directs  
+1\. \*\*Logique :\*\* Dans l'algorithme ci-dessus pour $n=5$, pourquoi la première boucle $i$ s'arrête-t-elle à $n-3$ (indice 2\) ?  
+2\. \*\*Programmation :\*\* Complétez ce code Python pour générer les triplets d'une liste \`L\` :  
+\`\`\`python  
+for i in range(len(L)-2):  
+    for j in range(i+1, len(L)-1):  
+        for k in range(j+1, len(L)):  
+            print(..........)  
+\`\`\`
+
+\*\* CORRECTIONS :\*\*  
+1\. \*\*Logique :\*\* Pour former un triplet, si $i$ est le premier élément, il doit rester au moins deux éléments après lui (pour $j$ et $l$). L'indice maximum pour $i$ est donc $n-3$.  
+2\. \*\*Programmation :\*\* \`print(L\[i\], L\[j\], L\[k\])\`
+
+\---
+
+\#\# Résumé global \+ Conseils
+
+\* \*\*Différence clé :\*\* Permutations \= l'ordre compte ($A,B \\neq B,A$). Parties \= l'ordre ne compte pas ($\\left\\{A,B\\right\\} \= \\left\\{B,A\\right\\}$).  
+\* \*\*Structure algorithmique :\*\* Pour générer des parties de taille $k$, on utilise $k$ boucles imbriquées.  
+\* \*\*Complexité :\*\* Le nombre de parties augmente très vite avec $n$. $\\binom{n}{k}$ est maximal quand $k \\approx n/2$.  
diff --git a/maths/chap2/partie2/lesson2.json b/maths/chap2/partie2/lesson2.json
new file mode 100644
index 0000000..d64b7bf
--- /dev/null
+++ b/maths/chap2/partie2/lesson2.json
@@ -0,0 +1,4 @@
+{
+  "title": "Génération des parties à 2 et 3 éléments d’un ensemble fini",
+  "difficulty": 3
+}
diff --git a/maths/chap2/partie2/partie2.json b/maths/chap2/partie2/partie2.json
new file mode 100644
index 0000000..ff7960f
--- /dev/null
+++ b/maths/chap2/partie2/partie2.json
@@ -0,0 +1,5 @@
+{
+    "title": "Génération des parties à 2 et 3 éléments d’un ensemble fini",
+    "description": "",
+    "difficulty": 3
+}