math-exercises 3.0.77 → 3.0.78

package/lib/exercises/math/functions/variations/varTableExtremaReading.js

@@ -29,12 +29,26 @@ const getInstruction = (identifiers) => {
         : `Sur l'intervalle $${interval.toTex()}$, quel est le ${type} de la fonction $f$ ?`}`;
     return instruction;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return "";
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return "";
-// };
+const getHint = (identifiers) => {
+    return `Le minimum d'une fonction $f$ sur un intervalle $[a;b]$ est la plus petite valeur de $f(x)$ pour $x$ appartenant à $[a;b]$. On dit alors que le minimum de $f$ sur $[a;b]$ est $f(x)$, atteint en $x$.
+
+Le maximum d'une fonction $f$ sur un intervalle $[a;b]$ est la plus grande valeur de $f(x)$ pour $x$ appartenant à $[a;b]$. On dit alors que le maximum de $f$ sur $[a;b]$ est $f(x)$, atteint en $x$.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { intervalXIndexes, isAskingMin, isAskingX, xValues, yValues } = identifiers;
+    const type = isAskingMin ? "minimum" : "maximum";
+    const type2 = isAskingMin ? "petite" : "grande";
+    const interval = new IntervalNode(identifiers.xValues[identifiers.intervalXIndexes[0]].toTree(), identifiers.xValues[identifiers.intervalXIndexes[1]].toTree(), ClosureType.FF);
+    const x = xValues[yValues.indexOf((isAskingMin ? Math.min : Math.max)(...yValues.slice(intervalXIndexes[0], intervalXIndexes[1] + 1)))].frenchify();
+    const y = yValues[yValues.indexOf((isAskingMin ? Math.min : Math.max)(...yValues.slice(intervalXIndexes[0], intervalXIndexes[1] + 1)))].frenchify();
+    return `On cherche la plus ${type2} valeur de $f(x)$ (deuxième ligne) pour les valeurs de $x$ allant de $${interval.a.toTex()}$ à $${interval.b.toTex()}$ (première ligne). On lit que cette valeur est $${y}$, atteinte pour $x = ${x}$. 
+
+${identifiers.isAskingX
+        ? `Sur l'intervalle $${interval.toTex()}$, le ${type} de la fonction $f$ est donc atteint pour $x = ${x}$.`
+        : `Sur l'intervalle $${interval.toTex()}$, le ${type} de la fonction $f$ est donc $${y}$.`}
+`;
+};
 const getGGBOptions = (identifiers) => {
     const xValues = identifiers.xValues;
     const yValues = identifiers.yValues;
@@ -103,8 +117,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -121,4 +135,5 @@ export const varTableExtremaReading = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasGeogebra: true,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/angles/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./recognizeAngleType.js";
+export * from "./parallelogramFourthAngle.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/angles/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/geometry/angles/index.js

@@ -1 +1,2 @@
 export * from "./recognizeAngleType.js";
+export * from "./parallelogramFourthAngle.js";

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    doubleAngle: number;
+    singleAngle: number;
+};
+export declare const parallelogramFourthAngle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramFourthAngle.d.ts.map

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramFourthAngle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/parallelogramFourthAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.js

@@ -0,0 +1,92 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { degreeParser } from "../../../../tree/parsers/degreeParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, singleAngle, doubleAngle }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${singleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle - doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${Math.abs(180 - 2 * singleAngle - doubleAngle)}^{\\circ}`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { singleAngle, doubleAngle } = identifiers;
+    const fourthAngle = 360 - singleAngle - 2 * doubleAngle;
+    return `${fourthAngle}^{\\circ}`;
+};
+const getInstruction = (identifiers) => {
+    return `Un parallélogramme a deux angles de mesure $${identifiers.doubleAngle}^{\\circ}$ et un angle de mesure $${identifiers.singleAngle}^{\\circ}$. 
+
+Quelle est la mesure de son quatrième angle ?`;
+};
+const getHint = (identifiers) => {
+    return `La somme des angles d'un parallélogramme est égale à $360°$.`;
+};
+const getCorrection = (identifiers) => {
+    const { singleAngle, doubleAngle } = identifiers;
+    const sum = singleAngle + 2 * doubleAngle;
+    return `La somme des angles d'un parallélogramme est égale à $360°$. Ici, la somme des trois angles connus vaut : 
+  
+$$
+${singleAngle}^{\\circ} + 2\\times ${doubleAngle}^{\\circ} = ${sum}^{\\circ}
+$$
+
+Le quatrième angle vaut donc : 
+
+$$
+360^{\\circ} - ${sum}^{\\circ} = ${singleAngle} ^{\\circ}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return degreeParser(ans) === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParallelogramFourthAngleQuestion = (ops) => {
+    const doubleAngle = randint(10, 170);
+    const singleAngle = 180 - doubleAngle;
+    const identifiers = {
+        singleAngle,
+        doubleAngle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getKeys = (identifiers) => {
+    return ["degree"];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const parallelogramFourthAngle = {
+    id: "parallelogramFourthAngle",
+    label: "Déterminer le $4$ème angle d'un parallélogramme en connaissant les $3$ autres",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramFourthAngleQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/checkEquiprobability.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    total: number;
+    distribution: number[];
+    observe: boolean;
+};
+export declare const checkEquiprobability: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=checkEquiprobability.d.ts.map

package/lib/exercises/math/probaStat/checkEquiprobability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkEquiprobability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/checkEquiprobability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAsIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/probaStat/checkEquiprobability.js

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const wrong = answer === "Oui" ? "Non" : "Oui";
+    tryToAddWrongProp(propositions, wrong, "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { observe, distribution } = identifiers;
+    if (observe) {
+        return "Oui";
+    }
+    else {
+        return distribution.every((v) => v === distribution[0]) ? "Oui" : "Non";
+    }
+};
+const getInstruction = ({ total, distribution, observe, }) => {
+    const colors = ["rouges", "vertes", "bleues", "jaunes"];
+    const colorLines = distribution
+        .map((count, i) => `$${count}$ cartes sont ${colors[i]}`)
+        .join(", ");
+    return `Un jeu est constitué de $${total}$ cartes numérotées de $1$ à $${total}$.
+
+${colorLines}.
+
+On tire une carte au hasard.
+
+On observe ${observe ? "le numéro" : "la couleur"} de la carte tirée.  
+
+Les issues sont-elles équiprobables ?`;
+};
+const getHint = ({ observe }) => {
+    if (observe) {
+        return `Pense à combien de cartes portent chaque numéro.  
+Y a-t-il autant de cartes pour chaque numéro possible ?`;
+    }
+    else {
+        return `Regarde le nombre de cartes de chaque couleur.  
+A-t-on autant de chances d'obtenir toutes les couleurs ?`;
+    }
+};
+const getCorrection = ({ total, distribution, observe, }) => {
+    const colors = ["rouge", "vert", "bleu", "jaune"];
+    const probs = distribution
+        .map((count, i) => `$$
+P(\\text{${colors[i]}}) = ${frac(count, total).toTex()}
+$$`)
+        .join("\n \n");
+    const explanation = observe
+        ? `Chaque carte a un numéro distinct entre $1$ et $${total}$, donc chaque numéro a une probabilité d'être tiré égale à $${frac(1, total).toTex()}$.  
+Toutes les issues sont donc équiprobables.`
+        : `Les probabilités associées à chaque couleur sont : \n\n ${probs} \n\n
+${distribution.every((v) => v === distribution[0])
+            ? "Puisqu'il y autant de cartes de chaque couleur, les issues sont équiprobables."
+            : "Les couleurs n'ont pas toutes le même nombre de cartes, donc les issues ne sont pas équiprobables."}`;
+    return `${explanation}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCheckEquiprobabilityQuestion = (ops) => {
+    let total;
+    let distribution;
+    const isEquiprobable = coinFlip();
+    const observe = coinFlip();
+    if (isEquiprobable) {
+        total = 4 * randint(10, 30);
+        const value = total / 4;
+        distribution = [value, value, value, value];
+    }
+    else {
+        total = randint(30, 61);
+        const a = randint(2, total - 6);
+        const b = randint(2, total - a - 4);
+        const c = randint(2, total - a - b - 2);
+        const d = total - a - b - c;
+        distribution = [a, b, c, d];
+    }
+    const identifiers = {
+        total,
+        distribution,
+        observe,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const checkEquiprobability = {
+    id: "checkEquiprobability",
+    label: "Reconnaître une situation équiprobable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckEquiprobabilityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/index.d.ts

@@ -16,4 +16,6 @@ export * from "./getMissingProbabilityValue.js";
 export * from "./getComplementaryProbability.js";
 export * from "./unionIntersectionProba.js";
 export * from "./calculateMeanFromFrequencies.js";
+export * from "./mostLeastProbable.js";
+export * from "./checkEquiprobability.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/probaStat/index.js

@@ -16,3 +16,5 @@ export * from "./getMissingProbabilityValue.js";
 export * from "./getComplementaryProbability.js";
 export * from "./unionIntersectionProba.js";
 export * from "./calculateMeanFromFrequencies.js";
+export * from "./mostLeastProbable.js";
+export * from "./checkEquiprobability.js";

package/lib/exercises/math/probaStat/mostLeastProbable.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export type Identifiers = {
+    numericValues: NodeIdentifiers[];
+    isMax: boolean;
+};
+export declare const mostLeastProbable: Exercise<Identifiers>;
+//# sourceMappingURL=mostLeastProbable.d.ts.map

package/lib/exercises/math/probaStat/mostLeastProbable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mostLeastProbable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/mostLeastProbable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA2HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

package/lib/exercises/math/probaStat/mostLeastProbable.js

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { round } from "../../../math/utils/round.js";
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+const getPropositions = (n, { answer }) => {
+    const allLabels = ["J", "R", "V"];
+    const props = [];
+    addValidProp(props, answer);
+    for (const label of allLabels) {
+        tryToAddWrongProp(props, label);
+    }
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ numericValues, isMax }) => {
+    const numericValuesParsed = numericValues.map((v) => reifyAlgebraic(v).evaluate());
+    const targetValue = isMax
+        ? Math.max(...numericValuesParsed)
+        : Math.min(...numericValuesParsed);
+    const index = numericValuesParsed.indexOf(targetValue);
+    return ["J", "R", "V"][index];
+};
+const getInstruction = ({ numericValues, isMax, }) => {
+    const labels = ["$J$", "$R$", "$V$"];
+    const displayValues = numericValues.map((v, i) => {
+        if (labels[i] === "$R$") {
+            const pct = round(reifyAlgebraic(v).evaluate() * 100, 6);
+            return `${pct.frenchify()}\\%`;
+        }
+        else {
+            return reifyAlgebraic(v).toTex();
+        }
+    });
+    const header = `Une expérience aléatoire a trois issues : ${labels.join(", ")}.
+  
+Leurs probabilités sont respectivement $${displayValues[0]}$ , $${displayValues[1]}$ et $${displayValues[2]}$.\n\n`;
+    return header + `Quelle issue est la ${isMax ? "plus" : "moins"} probable ?`;
+};
+const getHint = () => {
+    return "Convertis les probabilités dans le même format pour les comparer.";
+};
+const getCorrection = ({ numericValues, isMax, }) => {
+    const fraction = reifyAlgebraic(numericValues[0]);
+    const percent = reifyAlgebraic(numericValues[1]);
+    const evaluatedValues = numericValues.map((v) => round(reifyAlgebraic(v).evaluate(), 2));
+    const sortedAsc = [...evaluatedValues].sort((a, b) => a - b);
+    const target = isMax ? "plus" : "moins";
+    const result = getAnswer({ numericValues, isMax });
+    return `On convertit le pourcentage et la fraction en nombres décimaux (éventuellement avec une valeur approchée) pour pouvoir les comparer : 
+  
+- $${fraction.toTex()} ${approxOrEqual(fraction.evaluate(), 2).join("")}$
+
+- $${multiply(percent, 100).simplify().toTex()}\\% = ${percent.toTex()}$
+
+Puisque $${sortedAsc
+        .map((e) => e.frenchify())
+        .join("\\leq")}$, l'issue la ${target} probable est donc $${result}$.`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans.trim() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMostLeastProbableQuestion = (opts) => {
+    let numericValues = [];
+    do {
+        numericValues = [
+            RationalConstructor.randomIrreductibleProba().toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+        ];
+    } while (numericValues.some((e, i) => numericValues.some((e2, i2) => i2 !== i && round(e2.evaluate(), 2) === round(e.evaluate(), 2))));
+    const isMax = coinFlip();
+    return getQuestionFromIdentifiers({
+        numericValues: numericValues.map((e) => e.toIdentifiers()),
+        isMax,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const mostLeastProbable = {
+    id: "mostLeastProbable",
+    label: "Identifier l'issue la plus ou la moins probable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMostLeastProbableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/sets/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/sets/index.js

@@ -1,3 +1,4 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    subset: number;
+    set: number;
+};
+export declare const subsetsOfKnownSets: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=subsetsOfKnownSets.d.ts.map

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsetsOfKnownSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/subsetsOfKnownSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAiGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/sets/subsetsOfKnownSets.js

@@ -0,0 +1,99 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "\\subset");
+    tryToAddWrongProp(propositions, "\\not\\subset");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { subset, set } = identifiers;
+    return set > subset ? "\\subset" : "\\not\\subset";
+};
+const caseToTex = (set) => {
+    switch (set) {
+        case 0:
+            return "\\mathbb{N}";
+        case 1:
+            return "\\mathbb{Z}";
+        case 2:
+            return "\\mathbb{D}";
+        case 3:
+            return "\\mathbb{Q}";
+        case 4:
+        default:
+            return "\\mathbb{R}";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { subset, set } = identifiers;
+    return `Compléter par le bon symbole : 
+  
+$$
+${caseToTex(subset)} \\ \\ldots \\  ${caseToTex(set)}
+$$
+
+Le symbole $\\subset$ signifie "est inclus dans" et le symbole $\\not\\subset$ signifie "n'est pas inclus dans".`;
+};
+const getHint = (identifiers) => {
+    return `- $\\mathbb{N}$ est l'ensemble des nombres entiers naturels (nombres entiers positifs).
+- $\\mathbb{Z}$ est l'ensemble des nombres entiers relatifs (nombres entiers positis et négatifs).
+- $\\mathbb{R}$ est l'ensemble des nombres réels.
+- $\\mathbb{D}$ est l'ensemble des nombres décimaux (nombres avec un nombre fini de chiffres apres la virgule).
+- $\\mathbb{Q}$ est l'ensemble des nombres rationnels (nombres qui peuvent s'écrire sous la forme d'une fraction de deux entiers).
+`;
+};
+const getCorrection = (identifiers) => {
+    const { set, subset } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `Voici les inclusions dans l'ordre des ensembles de nombres :
+  
+$$
+\\mathbb{N} \\subset \\mathbb{Z} \\subset \\mathbb{D} \\subset \\mathbb{Q} \\subset \\mathbb{R}
+$$
+
+${answer === "\\subset"
+        ? `
+On a donc :
+
+$$
+${caseToTex(subset)} ${getAnswer(identifiers)}  ${caseToTex(set)}
+$$`
+        : `On a donc $${caseToTex(set)} \\subset  ${caseToTex(subset)}$, mais $${caseToTex(subset)} \\not\\subset  ${caseToTex(set)}$. `}`;
+};
+const getSubsetsOfKnownSetsQuestion = (ops) => {
+    const subset = randint(0, 6);
+    const set = randint(0, 6, [subset]);
+    const identifiers = { subset, set };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const subsetsOfKnownSets = {
+    id: "subsetsOfKnownSets",
+    label: "Inclusions des ensembles de nombres",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSubsetsOfKnownSetsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import { Exercise, Question } from "./exercises/exercise.js";
+import * as MathExercises from "./exercises/math/index.js";
 import "./prototypesEnhancement.js";
 import { parseAlgebraic } from "./tree/parsers/latexParser.js";
 declare const mathExercises: (Exercise<{
@@ -84,6 +85,16 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    expression: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    twoSided: boolean;
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b?: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b: number;
+    c: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -1449,6 +1460,9 @@ declare const mathExercises: (Exercise<{
     angleType: string;
     angleIndex: number;
     apexIndex: number;
+}, {}> | Exercise<{
+    doubleAngle: number;
+    singleAngle: number;
 }, {}> | Exercise<{
     lines: {
         pointA: number[];
@@ -1891,6 +1905,10 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     xValues: number[];
     yValues: number[];
+}, {}> | Exercise<MathExercises.Identifiers, {}> | Exercise<{
+    total: number;
+    distribution: number[];
+    observe: boolean;
 }, {}> | Exercise<{
     firstValue: number;
     askedRank: number;
@@ -2029,6 +2047,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     isQuestionAboutNotation: boolean;
     caseNumber: number;
+}, {}> | Exercise<{
+    subset: number;
+    set: number;
 }, {}> | Exercise<{
     x: number;
     y: number;