math-exercises 3.0.155 → 3.0.157

package/lib/exercises/math/probaStat/basicProbas/pickEquiprobableSituations.js

@@ -1,14 +1,64 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { probaWheelGGBCommands } from "../../../../geogebra/probas/probaWheelGGBCommands.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { dichoFilter } from "../../../../utils/arrays/dichoFilter.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getDictEventsAndProba = (arrItem) => {
+    const outDict = {};
+    const indexesColorsUsed = [
+        ...new Set(arrItem.map((wheelItem) => wheelItem.indexColor)),
+    ];
+    //couleur
+    {
+        const dictColor = indexesColorsUsed.reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.indexColor === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["couleur"] = dictColor;
+    }
+    const valuesUsed = [...new Set(arrItem.map((wheelItem) => wheelItem.value))];
+    //numéro
+    {
+        const dictValue = valuesUsed.reduce((acc, v) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value === v).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[v] = nodeProba;
+            return acc;
+        }, {});
+        outDict["numéro"] = dictValue;
+    }
+    //parité
+    {
+        const dictColor = [0, 1].reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value % 2 === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["parité"] = dictColor;
+    }
+    //geq5
+    {
+        const dictGeq5 = dichoFilter(arrItem.map((item) => item.value), (v) => v >= 5).reduce((acc, arrV, i) => {
+            const nodeProba = frac(arrV.length, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["geq5"] = dictGeq5;
+    }
+    return outDict;
+};
 //on note le numéro du secteur obtenu
 //on note la couleur du secteur obtenu
 //on note la parité du numéro obtenu
-const getPropositions = (n, { answer, items }) => {
+//on note si le numéro est supérieur ou égal à 5
+const getPropositions = (_arg1, { answer: _arg2, items }) => {
     const propositions = [];
-    addValidProp(propositions, answer);
     const colors = [0, 0, 0, 0];
     const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
     const pars = [0, 0];
@@ -32,7 +82,16 @@ const getPropositions = (n, { answer, items }) => {
         addValidProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
     else
         tryToAddWrongProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
-    return shuffleProps(propositions, n);
+    if ((() => {
+        const [arrGeq5, arrLt5] = dichoFilter(items.map((item) => item.value), (v) => v >= 5);
+        return arrLt5.length === arrGeq5.length;
+    })()) {
+        addValidProp(propositions, "On note si le numéro obtenu est supérieur ou égal à $5$", "raw");
+    }
+    else {
+        tryToAddWrongProp(propositions, "On note si le numéro obtenu est supérieur ou égal à $5$", "raw");
+    }
+    return propositions;
 };
 const getInstruction = (identifiers) => {
     const { items } = identifiers;
@@ -45,22 +104,51 @@ const getHint = () => {
 };
 const getCorrection = (identifiers) => {
     const { items } = identifiers;
-    const colors = [0, 0, 0, 0];
-    const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    const pars = [0, 0];
-    for (let i = 0; i < items.length; i++) {
-        colors[items[i].indexColor]++;
-        nums[items[i].value]++;
-        if (items[i].value % 2 === 0)
-            pars[0]++;
-        else
-            pars[1]++;
-    }
+    const dictEventsAndProba = getDictEventsAndProba(items);
+    const arrAnswer = getPropositions(4, { answer: "", ...identifiers }).filter((proposition) => proposition.isRightAnswer);
     return `On détaille chaque situation : 
   
-- 
-- 
-- `;
+${mdTable([
+        ["", ""],
+        ["Numéro", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["numéro"]).map(([s, nodeProba]) => [
+            `$${s}$`,
+            `$${nodeProba.toTex()}$`,
+        ]),
+        ["", ""],
+        ["Couleur", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["couleur"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [
+                ["rouge", "bleu", "vert", "orange"][indexEvent],
+                `$${nodeProba.toTex()}$`,
+            ];
+        }),
+        ["", ""],
+        ["Parité", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["parité"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [["pair", "impair"][indexEvent], `$${nodeProba.toTex()}$`];
+        }),
+        ["", ""],
+        ["Supérieur ou égal à $5$", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["geq5"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [["oui", "non"][indexEvent], `$${nodeProba.toTex()}$`];
+        }),
+    ])}
+
+Les situations équiprobables sont celles où toutes les issues ont la même probabilité.
+${arrAnswer.length > 1 ? "Ce sont donc :" : `C'est donc :`}
+
+${arrAnswer.map((proposition) => `- ${proposition.statement}`).join(`
+`)}
+
+`;
 };
 const getGGBOptions = (identifiers) => {
     const { items } = identifiers;
@@ -89,13 +177,18 @@ const hasRightAnswer = (items) => {
     return (colors.filter((e) => !!e).every((i) => i === colors[0]) ||
         nums
             .filter((e) => !!e)
-            .every((i) => i === nums[0] || pars.every((i) => i === pars[0])));
+            .every((i) => i === nums[0] || pars.every((i) => i === pars[0])) ||
+        (() => {
+            const [arrGeq5, arrLt5] = dichoFilter(items.map((item) => item.value), (v) => v >= 5);
+            return arrLt5.length === arrGeq5.length;
+        })());
 };
 const getPickEquiprobableSituationsQuestion = () => {
+    const nbWheelItems = randint(8, 11);
     let items = [];
     do {
         items = [];
-        for (let i = 0; i < 9; i++) {
+        for (let i = 0; i < nbWheelItems; i++) {
             items.push({
                 value: randint(1, 10),
                 indexColor: randint(0, 4),
@@ -127,6 +220,7 @@ export const pickEquiprobableSituations = {
     subject: "Mathématiques",
     getHint,
     getCorrection,
+    hasHintAndCorrection: true,
     getInstruction,
     getGGBOptions,
     hasGeogebra: true,

package/lib/exercises/math/probaStat/basicProbas/pickEquiprobableTo.js

@@ -122,7 +122,7 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getHint = () => {
-    return `Compte le nombre d'issues réalisent chaque évènement et cherche lesquels sont égaux entre eux.`;
+    return `Compte le nombre d'issues qui réalisent chaque évènement et cherche lesquels sont égaux entre eux.`;
 };
 const getCorrection = (identifiers) => {
     const { arrItem, typeAsked } = identifiers;
@@ -280,7 +280,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const pickEquiprobableTo = {
     id: "pickEquiprobableTo",
     connector: "=",
-    label: "Déterminer les situations équiprobables à une situation donnée",
+    label: "Déterminer les évènements équiprobables",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getPickEquiprobableToQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/probaStat/basicProbas/rangeBasicProbas.js

@@ -9,7 +9,7 @@ import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { min, max, target, isIncluded } = identifiers;
     return `Sur un ordinateur, on exécute un programme qui retourne au hasard 
-un nombre entier compris entre $${min.frenchify()}$ et $${max.frenchify()}$ 
+un nombre entier compris entre $${min.frenchify()}$ inclus et $${max.frenchify()}$ 
 ${isIncluded ? "inclus" : "exclu"}.  
 
 Quelle est la probabilité que le programme retourne $${target.frenchify()}$ ?`;

package/lib/exercises/math/probaStat/stats1var/etendueTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etendueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueTable.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA6GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"etendueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueTable.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAmHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueTable.js

@@ -45,7 +45,11 @@ const getHint = () => {
 const getCorrection = (identifiers) => {
     const { randomValues } = identifiers;
     return `La plus grande valeur de cette série est $${randomValues[randomValues.length - 1]}$ et la plus petite est $${randomValues[0]}$.
-  
+
+$$
+${randomValues[randomValues.length - 1]} - ${randomValues[0]} = ${randomValues[randomValues.length - 1] - randomValues[0]}
+$$
+
 L'étendue de la série est donc $${randomValues[randomValues.length - 1] - randomValues[0]}$.
   `;
 };

package/lib/exercises/math/probaStat/stats1var/medianWithList.js

@@ -19,7 +19,7 @@ const getAnswer = (identifiers) => {
     return median([...sortedValues].sort((a, b) => a - b)).frenchify();
 };
 const getHint = (_, opts) => {
-    return `La médiane est la valeur centrale de la série : il y a autant de valeur inférieures à la médiane que de valeurs supérieures à la médiane.
+    return `La médiane est la valeur centrale de la série : il y a autant de valeurs inférieures à la médiane que de valeurs supérieures à la médiane.
 
 ${opts?.isOrdered
         ? "Les valeurs sont déjà rangées par ordre croissant."

package/lib/exercises/math/probaStat/stats1var/medianWithTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAiIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAiJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/medianWithTable.js

@@ -55,7 +55,6 @@ const getCorrection = (identifiers) => {
         eccs.push(s);
     }
     const total = eccs[eccs.length - 1];
-    const rank = total / 2;
     return `On dresse le tableau des effectifs cumulés croissants (ECC) : 
   
 ${mdTable([
@@ -64,11 +63,26 @@ ${mdTable([
         ["ECC", ...eccs.map((e) => dollarize(e))],
     ])}
 
-L'effectif total est donc $${total}$. 
+L'effectif total est donc $${total}$.
 
-Puisque $\\frac{${total}}{2} = ${rank.frenchify()}$, la médiane est ${rank % 1 === 0
-        ? `entre la $${rank}$ème et la $${rank + 1}$ème valeur.`
-        : `la $${Math.ceil(rank)}$ème valeur.`}
+${(() => {
+        switch (total % 2) {
+            case 0: {
+                const rank = total / 2;
+                return `L'effectif est pair. La médiane est entre la $${rank}$ème et la $${rank + 1}$ème valeur.`;
+            }
+            case 1: {
+                const rank = (total + 1) / 2;
+                return `L'effectif est impair.
+
+$$
+\\frac{${total}+1}{2} = ${rank.frenchify()}
+$$
+
+La médiane est la $${rank.frenchify()}$ème valeur.`;
+            }
+        }
+    })()}
 
 La médiane est donc $${getAnswer(identifiers)}$.`;
 };

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.js

@@ -89,7 +89,7 @@ Si l'on regarde les valeurs strictement supérieures à $${a.frenchify()}$ :
 ${valuesAboveA
         .map((v) => `
     
-$${v.frenchify()}$ est $${(v - a).frenchify()}$ points en dessus de $${a.frenchify()}$
+$${v.frenchify()}$ est $${(v - a).frenchify()}$ points au dessus de $${a.frenchify()}$
 
 `)
         .join("")}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA+MF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAsNF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.js

@@ -9,6 +9,7 @@ const arrStrOutcomeSmall = [`P`, `F`];
 const getInstruction = (identifiers) => {
     const { arrIndex } = identifiers;
     const strRand = arrIndex.join("");
+    const topRow = [`\\text{Lancer} \\ 1$ /// $\\text{Lancer} \\ 2`, "P", "F"];
     return `On tire deux fois à pile ou face avec une pièce de monnaie.
 On note les issues de cette expérience aléatoire dans le tableau ci-dessous. 
 
@@ -18,14 +19,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{...}", "(P,F)"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                            topRow,
+                            ["P", "\\text{...}", "(P;F)"],
+                            ["F", "\\text{}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{...}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{}"],
+                            topRow,
+                            ["P", "\\text{...}", "\\text{}"],
+                            ["F", "(F;P)", "\\text{}"],
                         ], true)}`,
                     ]);
                 }
@@ -34,14 +35,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{...}"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                            topRow,
+                            ["P", "(P;P)", "\\text{...}"],
+                            ["F", "\\text{}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{...}"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "(F,F)"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{...}"],
+                            ["F", "\\text{}", "(F;F)"],
                         ], true)}`,
                     ]);
                 }
@@ -50,14 +51,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "\\text{...}", "\\text{}"],
+                            topRow,
+                            ["P", "(P;P)", "\\text{}"],
+                            ["F", "\\text{...}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "\\text{...}", "(F,F)"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{}"],
+                            ["F", "\\text{...}", "(F;F)"],
                         ], true)}`,
                     ]);
                 }
@@ -66,14 +67,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "(P,F)"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{...}"],
+                            topRow,
+                            ["P", "\\text{}", "(P;F)"],
+                            ["F", "\\text{}", "\\text{...}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{...}"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{}"],
+                            ["F", "(F;P)", "\\text{...}"],
                         ], true)}`,
                     ]);
                 }
@@ -106,17 +107,14 @@ const getCorrection = (identifiers) => {
             ? highlighted(strEventSmall)
             : strEventSmall;
     });
+    const topRow = [`\\text{Lancer 1}$ /// $\\text{Lancer 2}`, "P", "F"];
     return `Dans le tableau ci-dessous, 
 le premier élément dans la parenthèse désigne le résultat du premier lancer 
 et le deuxième élémént le résultat du deuxième lancer.
 
 $P$ désigne $Pile$ et $F$ désigne $Face$.
   
-${mdTable([
-        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
-        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
-    ], true)}
+${mdTable([topRow, ["P", arrStr[0], arrStr[2]], ["F", arrStr[1], arrStr[3]]], true)}
 `;
 };
 const getPropositions = (n, { answer }) => {
@@ -153,6 +151,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: false,
+                firstRowIsHeader: false,
+                firstCellIsDivided: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.js

@@ -85,9 +85,9 @@ const getCorrection = (identifiers) => {
     return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
   
 ${mdTable([
-        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
-        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
+        [`\\text{Lancer} \\ 1$ /// $\\text{Lancer} \\ 2`, "P", "F"],
+        ["P", arrStr[0], arrStr[2]],
+        ["F", arrStr[1], arrStr[3]],
     ], true)}
 
 Sur les $${nbOutcomes.frenchify()}$ issues possibles, ${nbRealized === 1 ? "une seule réalise" : `$${nbRealized}$ réalisent`} l'évènement "${event.str}".

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.js

@@ -109,9 +109,9 @@ const getCorrection = (identifiers) => {
     return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
   
 ${mdTable([
-        ["\\text{}", ...numberPool.map((i) => `n_2 : ${i}`)],
+        ["n_1$ /// $n_2", ...numberPool.map((i) => `${i}`)],
         ...Object.entries(arrArrStr).map(([s, arrStr]) => [
-            `n_1 : ${+s}`,
+            `${+s}`,
             ...Object.values(arrStr),
         ]),
     ], true)}

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAyiBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAijBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.js

@@ -120,10 +120,12 @@ Quelle est la probabilité de l'évènement "La valeur de la somme en euros cont
                 const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
                 return `On peut construire le tableau ci-dessous :
 ${mdTable([
-                    ["Somme en euros", ...values[0].map(() => ``)],
-                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    [
+                        `$\\text{Billet}(\\textrm{€})$ /// $\\text{Pièce}(\\textrm{€})$`,
+                        ...values[0].map((v0) => `$${v0.frenchify()}$`),
+                    ],
                     ...values[1].map((v1) => [
-                        `$${v1.frenchify()}\\ \\textrm{€}$`,
+                        `$${v1.frenchify()}$`,
                         ...values[0].map((v0) => {
                             const strStd = `${(v0 + v1).frenchify()}`;
                             if (isRealizingEvent(v0, v1)) {
@@ -189,10 +191,12 @@ Quelle est la probabilité de l'évènement "La valeur de la somme en euros cont
                 const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
                 return `On peut construire le tableau ci-dessous :
 ${mdTable([
-                    ["Somme", ...values[0].map(() => ``)],
-                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    [
+                        `$\\text{Billet}(\\textrm{€})$ /// $\\text{Pièce}(\\textrm{€})$`,
+                        ...values[0].map((v0) => `$${v0.frenchify()}$`),
+                    ],
                     ...values[1].map((v1) => [
-                        `$${v1.frenchify()}\\ \\textrm{€}$`,
+                        `$${v1.frenchify()}$`,
                         ...values[0].map((v0) => {
                             const strStd = `${(v0 + v1).frenchify()}`;
                             if (isRealizingEvent(v0, v1)) {
@@ -252,8 +256,10 @@ Quelle est la probabilité de l'évènement "La somme gagnée est supérieure ou
                 const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
                 return `On peut construire le tableau ci-dessous :
 ${mdTable([
-                    ["Somme en euros", ...values[0].map(() => ``)],
-                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    [
+                        `$\\text{Multiplicateur}$ /// $\\text{Base}(\\textrm{€})$`,
+                        ...values[0].map((v0) => `$${v0.frenchify()}$`),
+                    ],
                     ...values[1].map((v1) => [
                         `$\\times ${v1.frenchify()}$`,
                         ...values[0].map((v0) => {
@@ -316,8 +322,10 @@ Quelle est la probabilité de l'évènement "La somme gagnée contient le chiffr
                 const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
                 return `On peut construire le tableau ci-dessous :
 ${mdTable([
-                    ["Somme gagnée", ...values[0].map(() => ``)],
-                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    [
+                        `$\\text{Multiplicateur}$ /// $\\text{Base}(\\textrm{€})$`,
+                        ...values[0].map((v0) => `$${v0.frenchify()}$`),
+                    ],
                     ...values[1].map((v1) => [
                         `$\\times ${v1.frenchify()}$`,
                         ...values[0].map((v0) => {

package/lib/exercises/math/spaceGeometry/solids/recognizeSolidFromSolidPattern.js

@@ -961,7 +961,7 @@ const getAnswer = (identifiers) => {
     return pattern.str;
 };
 const getHint = () => {
-    return `Les hachures indiquent les endroits où l'on plie le patron.
+    return `S'il y a des hachures sur le patron, sache qu'elles indiquent les endroits où le plier.
 Il n'y a pas de languettes sur les patrons en mathématiques.`;
 };
 const getCorrection = (identifiers) => {

package/lib/exercises/math/spaceGeometry/sphere/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./pickIsPointInSphereOrBall.js";
+export * from "./sphereLatLonReading.2d.js";
+export * from "./pinPointLatLon.2d.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAE/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/index.js

@@ -1,2 +1,4 @@
 export * from "./pickIsPointInSphereOrBall.js";
-// export * from "./sphereLatLonReading.js";
+// export * from "./sphereLatLonReading.3d.js";
+export * from "./sphereLatLonReading.2d.js";
+export * from "./pinPointLatLon.2d.js";

package/lib/exercises/math/spaceGeometry/sphere/pinPointLatLon.2d.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointsDict: Record<string, {
+        latLon: PointIdentifiers;
+        "2d": PointIdentifiers;
+    }>;
+    namePointTarget: string;
+};
+export declare const pinPointLatLon2d: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pinPointLatLon.2d.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/pinPointLatLon.2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinPointLatLon.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/pinPointLatLon.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAoFtC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAChB,MAAM,EACN;QACE,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CACF,CAAC;IACF,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAmKF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}