math-exercises 3.0.199 → 3.0.201

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

@@ -16,3 +16,4 @@ export * from "./decimals/index.js";
 export * from "./rationals/index.js";
 export * from "./sign/index.js";
 export * from "./ratio/index.js";
+export * from "./factorial/index.js";

package/lib/exercises/math/calculLitteral/inequations/index.d.ts

@@ -9,4 +9,5 @@ export * from "./minNumberInequality.js";
 export * from "./isInequalityTrue.js";
 export * from "./inverseInequalityWithGraph.js";
 export * from "./exp/index.js";
+export * from "./inequationCenteredInterval.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/index.js

@@ -9,3 +9,4 @@ export * from "./minNumberInequality.js";
 export * from "./isInequalityTrue.js";
 export * from "./inverseInequalityWithGraph.js";
 export * from "./exp/index.js";
+export * from "./inequationCenteredInterval.js";

package/lib/exercises/math/calculLitteral/inequations/inequationCenteredInterval.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { InegalitySymbols } from "../../../../math/inequations/inequation.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsCenter: NodeIdentifiers;
+    nodeIdsRadius: NodeIdentifiers;
+    inegSymbol: InegalitySymbols;
+};
+type Options = {
+    nbDigits: string;
+};
+export declare const inequationCenteredInterval: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=inequationCenteredInterval.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/inequationCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inequationCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/inequationCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAQ9C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,aAAa,EAAE,eAAe,CAAC;IAC/B,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA8UF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/inequationCenteredInterval.js

@@ -0,0 +1,263 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { InequationSymbol, } from "../../../../math/inequations/inequation.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { UnionIntervalNode } from "../../../../tree/nodes/sets/unionIntervalNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsCenter, nodeIdsRadius, inegSymbol } = identifiers;
+    const [nodeCenter, nodeRadius] = [nodeIdsCenter, nodeIdsRadius].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("x");
+    const nodeIneqInstr = new InequationNode([abs(substract(nodeVarX, nodeCenter)), nodeRadius], inegSymbol);
+    const nodeIneqSol = (() => {
+        if (inegSymbol === "<" || inegSymbol === "\\le") {
+            const nodeIneqRewritten = new InequationNode([
+                substract(nodeCenter, nodeRadius).simplify(),
+                nodeVarX,
+                add(nodeCenter, nodeRadius).simplify(),
+            ], inegSymbol);
+            return new InequationSolutionNode(nodeIneqRewritten.toInterval());
+        }
+        else {
+            const arrNodeIneqRewritten = [
+                new InequationNode([nodeVarX, substract(nodeCenter, nodeRadius).simplify()], new InequationSymbol(inegSymbol).reversed()),
+                new InequationNode([nodeVarX, add(nodeCenter, nodeRadius).simplify()], inegSymbol),
+            ];
+            return new InequationSolutionNode(new UnionIntervalNode(arrNodeIneqRewritten.map((nodeIneq) => nodeIneq.toInterval())));
+        }
+    })();
+    return {
+        nodeCenter,
+        nodeRadius,
+        nodeIneqInstr,
+        nodeIneqSol,
+        inegSymbol,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsCenter, nodeIdsRadius, inegSymbol } = identifiers;
+    const [nodeCenter, nodeRadius] = [nodeIdsCenter, nodeIdsRadius].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("x");
+    const nodeIneqInstr = new InequationNode([abs(substract(nodeVarX, nodeCenter)), nodeRadius], inegSymbol);
+    return `Résoudre l'inéquation suivante : 
+  
+$$
+${nodeIneqInstr.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIneqSol } = getHydrated(identifiers);
+    return nodeIneqSol.toTex();
+};
+const getHint = () => {
+    return `Soient $3$ réels $y$, $v$ et $l$.
+
+Si on a :
+
+${alignTex([
+        ["", `\\lvert y - v \\rvert < l`],
+        ["\\Leftrightarrow", `y - v < l  \\ \\ \\text{et} \\ \\  -(y - v) < l`],
+        ["\\Leftrightarrow", `y < l + v  \\ \\ \\text{et} \\ \\  v - l < y`],
+        ["\\Leftrightarrow", `v - l < y < v + l`],
+    ])}
+
+alors, autrement dit, $y$ est strictement dans l'intervalle centré en $v$ et de rayon $l$.
+
+Si on a :
+
+${alignTex([
+        ["", `\\lvert y - v \\rvert > l`],
+        ["\\Leftrightarrow", `y - v > l  \\ \\ \\text{ou} \\ \\  -(y - v) > l`],
+        ["\\Leftrightarrow", `y > l + v  \\ \\ \\text{ou} \\ \\  v - l > y`],
+        ["\\Leftrightarrow", `y < v - l  \\ \\ \\text{ou} \\ \\  v + l < y`],
+    ])}
+
+alors, autrement dit, $y$ est strictement hors de l'intervalle centré en $v$ et de rayon $l$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeCenter, nodeRadius, nodeIneqInstr, nodeIneqSol, inegSymbol } = getHydrated(identifiers);
+    const nodeVarX = new VariableNode("x");
+    if (inegSymbol === "<" || inegSymbol === "\\le") {
+        const nodeIneqLhs1 = new InequationNode([substract(nodeVarX, nodeCenter), nodeRadius], inegSymbol);
+        const nodeIneqRhs1 = new InequationNode([opposite(substract(nodeVarX, nodeCenter)), nodeRadius], inegSymbol);
+        const nodeIneqLhs2 = new InequationNode([nodeVarX, add(nodeRadius, nodeCenter)], inegSymbol);
+        const nodeIneqRhs2 = new InequationNode([substract(nodeCenter, nodeRadius), nodeVarX], inegSymbol);
+        const nodeIneq3 = new InequationNode([
+            substract(nodeCenter, nodeRadius),
+            nodeVarX,
+            add(nodeCenter, nodeRadius),
+        ], inegSymbol);
+        return `
+
+${alignTex([
+            ["", `${nodeIneqInstr.toTex()}`],
+            [
+                "\\Leftrightarrow",
+                `${nodeIneqLhs1.toTex()} \\ \\ \\text{et} \\ \\ ${nodeIneqRhs1.toTex()}`,
+            ],
+            [
+                "\\Leftrightarrow",
+                `${nodeIneqLhs2.toTex()} \\ \\ \\text{et} \\ \\ ${nodeIneqRhs2.toTex()}`,
+            ],
+            ["\\Leftrightarrow", nodeIneq3.toTex()],
+        ])}
+
+alors, autrement dit, $x$ est ${inegSymbol === "<" ? "strictement" : ""} dans l'intervalle centré en $${nodeCenter.toTex()}$ et de rayon $${nodeRadius.toTex()}$.
+
+$$
+${nodeIneqSol.toTex()}
+$$
+
+`;
+    }
+    else {
+        const nodeIneqLhs1 = new InequationNode([substract(nodeVarX, nodeCenter), nodeRadius], inegSymbol);
+        const nodeIneqRhs1 = new InequationNode([opposite(substract(nodeVarX, nodeCenter)), nodeRadius], inegSymbol);
+        const nodeIneqLhs2 = new InequationNode([nodeVarX, add(nodeRadius, nodeCenter)], inegSymbol);
+        const nodeIneqRhs2 = new InequationNode([substract(nodeCenter, nodeRadius), nodeVarX], inegSymbol);
+        const inegSymbolReversed = new InequationSymbol(inegSymbol).reversed();
+        const nodeIneqLhs3 = new InequationNode([nodeVarX, substract(nodeCenter, nodeRadius)], inegSymbolReversed);
+        const nodeIneqRhs3 = new InequationNode([add(nodeCenter, nodeRadius), nodeVarX], inegSymbolReversed);
+        return `
+
+${alignTex([
+            ["", `${nodeIneqInstr.toTex()}`],
+            [
+                "\\Leftrightarrow",
+                `${nodeIneqLhs1.toTex()} \\ \\ \\text{ou} \\ \\ ${nodeIneqRhs1.toTex()}`,
+            ],
+            [
+                "\\Leftrightarrow",
+                `${nodeIneqLhs2.toTex()} \\ \\ \\text{ou} \\ \\ ${nodeIneqRhs2.toTex()}`,
+            ],
+            [
+                "\\Leftrightarrow",
+                `${nodeIneqLhs3.toTex()} \\ \\ \\text{ou} \\ \\ ${nodeIneqRhs3.toTex()}`,
+            ],
+        ])}
+
+alors, autrement dit, $x$ est ${inegSymbol === ">" ? "strictement" : ""} hors de l'intervalle centré en $${nodeCenter.toTex()}$ et de rayon $${nodeRadius.toTex()}$.
+
+$$
+${nodeIneqSol.toTex()}
+$$
+
+`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeIdsCenter, nodeIdsRadius, inegSymbol } = identifiers;
+    const [nodeCenter] = [nodeIdsCenter].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    //student: > -> <
+    {
+        tryToAddWrongProp(propositions, getAnswer({
+            ...identifiers,
+            inegSymbol: new InequationSymbol(inegSymbol).reversed(),
+        }));
+    }
+    //student: center <-> radius
+    {
+        tryToAddWrongProp(propositions, getAnswer({
+            ...identifiers,
+            nodeIdsCenter: nodeIdsRadius,
+            nodeIdsRadius: abs(nodeCenter).simplify().toIdentifiers(),
+        }));
+    }
+    //student: center -> -center
+    {
+        tryToAddWrongProp(propositions, getAnswer({
+            ...identifiers,
+            nodeIdsCenter: opposite(nodeCenter).simplify().toIdentifiers(),
+        }));
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return "S=\\ " + parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const nbDigits = parseInt(opts.nbDigits);
+    const nodeCenter = randfloat(-10, 10, nbDigits).toTree();
+    const nodeRadius = randfloat(1, 10, nbDigits, [
+        round(abs(nodeCenter).evaluate(), nbDigits),
+    ]).toTree();
+    const inegSymbol = random(["<", "\\le", "\\ge", ">"]);
+    const identifiers = {
+        nodeIdsCenter: nodeCenter.toIdentifiers(),
+        nodeIdsRadius: nodeRadius.toIdentifiers(),
+        inegSymbol,
+    };
+    return identifiers;
+};
+const getInequationCenteredIntervalQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["S", "equal", "lbracket", "rbracket", "semicolon", "infty", "cup"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    nbDigits: "0",
+};
+const options = [
+    {
+        id: "nbDigits",
+        label: "Nombre de décimales pour le centre et le rayon",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["0", "1", "2"],
+        defaultValue: optsDefault.nbDigits,
+    },
+];
+export const inequationCenteredInterval = {
+    id: "inequationCenteredInterval",
+    label: "Résoudre une inéquation du type $ \\lvert x - u \\rvert < d $",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getInequationCenteredIntervalQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    pdfOptions: { shouldSpreadPropositions: true },
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/combinatory/anagrams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anagrams.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/anagrams.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAqGrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAoEF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAY1C,CAAC"}
+{"version":3,"file":"anagrams.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/anagrams.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AA2GrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+IF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

package/lib/exercises/math/combinatory/anagrams.js

@@ -1,7 +1,12 @@
 import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { facto } from "../../../tree/nodes/functions/factorialNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const words = [
     "angle",
     "armoire",
@@ -65,66 +70,93 @@ const words = [
     "toilette",
     "vitre",
 ];
-const letters = [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "é",
-    "è",
-    "à",
-    "ç",
-];
 const getInstruction = (identifiers) => {
     const { word } = identifiers;
     return `Combien d'anagrammes mathématiques du mot ${word} sont possibles ?`;
 };
+const getAnswerStuff = (identifiers) => {
+    const { word } = identifiers;
+    const dictOccur = word.split("").reduce((acc, x) => {
+        if (!acc[x]) {
+            acc[x] = 0;
+        }
+        acc[x] += 1;
+        return acc;
+    }, {});
+    const arrArrStrCharAndOcc = Object.entries(dictOccur).filter(([_, count]) => count > 1);
+    const isWithoutDuplicate = arrArrStrCharAndOcc.length === 0;
+    const nodeAnswer = (() => {
+        if (isWithoutDuplicate) {
+            return facto(word.length);
+        }
+        else {
+            return frac(facto(word.length), arrArrStrCharAndOcc
+                .slice(1)
+                .reduce((acc, [_, count]) => multiply(acc, facto(count)), facto(arrArrStrCharAndOcc[0][1].toTree())));
+        }
+    })();
+    return { dictOccur, arrArrStrCharAndOcc, isWithoutDuplicate, nodeAnswer };
+};
 const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeAnswer.evaluate().frenchify();
+};
+const getHint = () => {
+    return `Une anagramme mathématique est une permutation des caractères d'un mot. 
+Si le mot a $n$ caractères distincts, le nombre d'anagrammes est le nombre de permutations d'un ensemble de $n$ éléments.
+Si le mot a des caractères qui sont présents plusieurs fois, on commence par faire comme s'ils étaient tous distincts, puis, 
+pour chaque caractère qui est présent $p$ fois, 
+il faudra penser à diviser par le nombre de permutations d'un ensemble de $p$ éléments, 
+pour éliminer tous les arrangements que l'on aura compté plusieurs fois.`;
+};
+const getCorrection = (identifiers) => {
     const { word } = identifiers;
-    const repeats = [];
-    const wordLetters = word.split("");
-    letters.forEach((letter) => {
-        const nbOfRepeats = wordLetters.filter((l) => l === letter).length;
-        if (nbOfRepeats > 1)
-            repeats.push(nbOfRepeats);
-    });
-    const getFacto = (n) => {
-        if (n === 1)
-            return 1;
-        return n * getFacto(n - 1);
-    };
-    const facto = word
-        .split("")
-        .map((_el, index) => index + 1)
-        .reduce((acc, curr) => acc * curr, 1);
-    let arrangements = 1;
-    repeats.forEach((nbOfRepeats) => {
-        arrangements *= getFacto(nbOfRepeats);
+    const { arrArrStrCharAndOcc, isWithoutDuplicate, nodeAnswer } = getAnswerStuff(identifiers);
+    return `Une anagramme mathématique est une permutation des caractères d'un mot. 
+Ici le mot est "${word}".
+C'est un mot de longueur $${word.length}$.
+${(() => {
+        if (isWithoutDuplicate) {
+            return `Tous les caractères sont distincts. 
+Le nombre d'anagrammes mathématiques est le nombre de permutations d'un ensemble à $${word.length}$ éléments : $${nodeAnswer.toTex()} = ${nodeAnswer
+                .evaluate()
+                .frenchify()}$.`;
+        }
+        else {
+            return `${arrArrStrCharAndOcc.map(([strChar, count]) => `Le caractère "${strChar}" est présent $${count}$ fois.`).join(`
+`)}
+Si tous les caractères étaient distincts, le nombre d'anagrammes mathématiques serait le nombre de permutations d'un ensemble à $${word.length}$ éléments : $${word.length}!$.
+Mais il faut diviser par le nombre de permutations que l'on a comptées en trop.
+${arrArrStrCharAndOcc.map(([strChar, count]) => `On a compté $${count}!$ fois trop de permutations en ce qui concerne le caractère "${strChar}".`).join(`
+`)}
+Le nombre d'anagrammes mathématiques du mot "${word}" est donc : $${nodeAnswer.toTex()} = ${nodeAnswer
+                .evaluate()
+                .frenchify()}$.
+`;
+        }
+    })()}
+`;
+};
+const getPropositions = (n, { answer, word }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, Math.pow(word.length, word.length) + "");
+    tryToAddWrongProp(propositions, (word.length * (word.length + 1)) / 2 + "");
+    tryToAddWrongProp(propositions, word.length * word.length + "");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(1000, 10000) + "");
     });
-    const answer = facto / arrangements + "";
-    return answer;
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getAnagramsQuestion = () => {
     const word = random(words);
@@ -135,26 +167,14 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: [],
+        keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
-const getPropositions = (n, { answer, word }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, Math.pow(word.length, word.length) + "");
-    tryToAddWrongProp(propositions, (word.length * (word.length + 1)) / 2 + "");
-    tryToAddWrongProp(propositions, word.length * word.length + "");
-    propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randint(1000, 10000) + "");
-    });
-    return shuffleProps(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
 export const anagrams = {
     id: "anagrams",
     connector: "=",
@@ -167,4 +187,5 @@ export const anagrams = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/combinatory/combination/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./writeCombinationFormulaUsingFactorial.js";
+export * from "./mentalCalculateCombination.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/combinatory/combination/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC;AAC3D,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/combinatory/combination/index.js

@@ -0,0 +1,2 @@
+export * from "./writeCombinationFormulaUsingFactorial.js";
+export * from "./mentalCalculateCombination.js";

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    total: number;
+    picked: number;
+};
+type Options = {
+    statementFormulaType: string;
+};
+export declare const mentalCalculateCombination: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=mentalCalculateCombination.d.ts.map

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentalCalculateCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/mentalCalculateCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8OF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBrE,CAAC"}