math-exercises 3.0.140 → 3.0.142

package/lib/exercises/math/calcul/arithmetics/euclideanDivision.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"euclideanDivision.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/euclideanDivision.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAYnD,CAAC"}
+{"version":3,"file":"euclideanDivision.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/euclideanDivision.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/euclideanDivision.js

@@ -2,9 +2,9 @@ import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../..
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { equal, EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 const getInstruction = (identifiers) => {
     const { dividend, divisor } = identifiers;
     return `Écrire la division euclidienne de $${dividend}$ par $${divisor}$.`;
@@ -15,6 +15,34 @@ const getAnswer = (identifiers) => {
     const answerTex = answer.toTex();
     return answerTex;
 };
+const getHint = (identifiers) => {
+    const { dividend, divisor } = identifiers;
+    return `La division euclidienne de $${dividend}$ par $${divisor}$ est de la forme : 
+  
+$$
+${dividend} = ${divisor} \\times q + r
+$$
+
+où $q$ (le quotient) et $r$ (le reste) sont deux entier naturels, avec $r<${divisor}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { dividend, divisor, quotient, remainder } = identifiers;
+    // const steps = divisionStepsManual(identifiers.dividend, identifiers.divisor);
+    return `On a : 
+  
+$$
+${divisor}\\times ${quotient} = ${divisor * quotient}
+$$
+
+On en déduit donc que : 
+
+$$
+${getAnswer(identifiers)}
+$$
+
+Cette écriture est bien la division euclidienne de $${dividend}$ par $${divisor}$, car le reste $${remainder}$ est bien inférieur à $${divisor}$.
+`;
+};
 const getEuclideanDivisionQuestions = () => {
     let dividend = randint(5, 100);
     let divisor = randint(2, 11);
@@ -34,6 +62,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -42,14 +72,15 @@ const isAnswerValid = (ans, { dividend, divisor, quotient, remainder }) => {
     const validLatexs = tree.toAllValidTexs();
     return validLatexs.includes(ans);
 };
-const getPropositions = (n, { answer, dividend }) => {
+const getPropositions = (n, { answer, dividend, divisor, quotient, remainder }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, equal(dividend, add(multiply(divisor, quotient - 1), remainder + dividend)).toTex());
     propWhile(propositions, n, () => {
-        const divisor = randint(2, 11);
-        const quotient = Math.floor(randint(5, 100) / divisor);
-        const remainder = randint(5, 100) % divisor;
-        const wrongAnswer = new EqualNode(new NumberNode(dividend), new AddNode(new MultiplyNode(new NumberNode(divisor), new NumberNode(quotient)), new NumberNode(remainder)));
+        const fakeDivisor = randint(2, 11);
+        const fakeQuotient = Math.floor(randint(5, 100) / fakeDivisor);
+        const fakeRemainder = randint(5, 100) % fakeDivisor;
+        const wrongAnswer = new EqualNode(new NumberNode(dividend), new AddNode(new MultiplyNode(new NumberNode(fakeDivisor), new NumberNode(fakeQuotient)), new NumberNode(fakeRemainder)));
         tryToAddWrongProp(propositions, wrongAnswer.toTex());
     });
     return shuffleProps(propositions, n);
@@ -66,4 +97,30 @@ export const euclideanDivision = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
+function _divisionStepsManual(dividend, divisor) {
+    if (divisor === 0) {
+        throw new Error("Division par zéro impossible.");
+    }
+    const steps = [];
+    let remainder = dividend;
+    const quotient = Math.floor(dividend / divisor);
+    const quotientStr = quotient.toString();
+    for (let i = 0; i < quotientStr.length; i++) {
+        // On forme la "partie" du quotient qu'on utilise (ex : 10, puis 3)
+        const factor = parseInt(quotientStr[i], 10) * Math.pow(10, quotientStr.length - 1 - i);
+        if (factor === 0)
+            continue;
+        const product = factor * divisor;
+        const before = remainder;
+        remainder -= product;
+        steps.push({
+            quotientPart: factor,
+            product,
+            remainderBefore: before,
+            remainderAfter: remainder,
+        });
+    }
+    return steps;
+}

package/lib/exercises/math/calcul/arithmetics/findLeftoverInContext.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situation: number;
+    total: number;
+    divisor: number;
+};
+export declare const findLeftoverInContext: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findLeftoverInContext.d.ts.map

package/lib/exercises/math/calcul/arithmetics/findLeftoverInContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findLeftoverInContext.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/findLeftoverInContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmHF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/findLeftoverInContext.js

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } 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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
+import { randomFirstname } from "../../../../utils/strings/randomFirstname.js";
+const getPropositions = (n, { answer, divisor, total }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, Math.floor(total / divisor).frenchify());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, Math.max(0, (total % divisor) + randint(-3, 3, [0])).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (identifiers.total % identifiers.divisor).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { divisor, situation, total } = identifiers;
+    switch (situation) {
+        case 0:
+            return `J'ai $${total}$ bonbons. Si je les range dans des sachets de $${divisor}$ bonbons, combien de bonbons ne seront pas dans un sachet ?`;
+        case 1:
+            return `Une bibliothèque possède $${total}$ livres à stocker dans des boîtes. Chaque boîte doit contenir $${divisor}$ livres. Combien de livres resteront hors des boîtes ?`;
+        case 2: {
+            const pre = randomFirstname();
+            return `${pre.name} possède $${total}$ billes. ${pre.isFeminine ? "Elle" : "Il"} veux remplir des tubes de $${divisor}$ billes chacun. Combien de billes ne seront pas dans un tube ?`;
+        }
+        case 3:
+            return `Un magasin reçoit $${total}$ cartes promotionnelles. Il veut les regrouper en paquets de $${divisor}$ cartes. Combien de cartes ne seront pas dans un paquet ?`;
+        case 4:
+        default:
+            return `J'ai récolté $${total}$ pommes. Je veux les ranger dans des paniers de $${divisor}$ pommes chacun. Combien de pommes ne seront pas dans un panier ?`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Écris la division euclidienne de $${identifiers.total}$ par $${identifiers.divisor}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { total, divisor, situation } = identifiers;
+    const answer = getAnswer(identifiers);
+    const objectType = ["bonbon", "livre", "bille", "carte", "pomme"][situation];
+    const contentType = ["sachet", "boîte", "tube", "paquet", "panier"][situation];
+    const quotient = Math.floor(total / divisor);
+    const leftover = total % divisor;
+    return `On écrit la division euclidienne de $${identifiers.total}$ par $${identifiers.divisor}$ :
+  
+$$
+${total} = ${divisor} \\times ${quotient} + ${leftover}
+$$
+  
+Le reste est $${answer}$.
+
+On peut donc faire $${quotient}$ ${pluralize(contentType, quotient)} de $${divisor}$ ${pluralize(objectType, divisor)}, et il va rester $${answer}$ ${pluralize(objectType, total % divisor)}.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindLeftoverInContextQuestion = () => {
+    let total = 0;
+    let divisor = 0;
+    do {
+        total = randint(30, 100);
+        divisor = randint(3, 20);
+    } while (total % divisor === 0);
+    const identifiers = {
+        situation: randint(0, 5),
+        divisor,
+        total,
+    };
+    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 findLeftoverInContext = {
+    id: "findLeftoverInContext",
+    connector: "=",
+    label: "Déterminer le reste d'une division euclidienne dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindLeftoverInContextQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findRightPrimeDecomposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAkIF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC"}
+{"version":3,"file":"findRightPrimeDecomposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAiIF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC"}

package/lib/exercises/math/calcul/arithmetics/findRightPrimeDecomposition.js

@@ -1,6 +1,4 @@
-import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, 
-// tryToAddWrongProp,
-addWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
 import { isPrime } from "../../../../math/utils/arithmetic/isPrime.js";
@@ -27,7 +25,7 @@ const getPropositions = (n, { answer, fakeDecomps }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     for (const decomp of fakeDecomps) {
-        addWrongProp(propositions, reifyAlgebraic(decomp).toTex({ forceNoSimplification: true }));
+        tryToAddWrongProp(propositions, reifyAlgebraic(decomp).toTex({ forceNoSimplification: true }));
     }
     return shuffleProps(propositions, n);
 };
@@ -50,7 +48,7 @@ n = p_1^{k_1} \\times p_2^{k_2} \\times ...
 $$`}
 
 où $p_1$, $p_2$, ... sont des nombres premiers${opts?.doNotUsePowers
-        ? " ."
+        ? "."
         : " et $k_1$, $k_2$, ... sont des entiers naturels."} 
 
 Parmi les écritures proposées, il faut donc repérer celle dans laquelle chaque facteur est un nombre premier.`;
@@ -75,7 +73,6 @@ const getFindRightPrimeDecompositionQuestion = (opts) => {
     // );
     const fakeDecomps = [];
     const nonPrimes = [];
-    console.log(nb);
     for (let i = 0; i < 3; i++) {
         const nonPrime = doWhile(() => random(divisors.slice(1).filter((n) => !isPrime(n))), (n) => nonPrimes.includes(n));
         nonPrimes.push(nonPrime);

package/lib/exercises/math/calcul/arithmetics/index.d.ts

@@ -13,4 +13,8 @@ export * from "./isMultipleOrDivisor.js";
 export * from "./coprime.js";
 export * from "./countDivisors.js";
 export * from "./findPrimeInList.js";
+export * from "./findRightPrimeDecomposition.js";
+export * from "./primeNumberIdentification.js";
+export * from "./primeNumbersAffirmations.js";
+export * from "./findLeftoverInContext.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/arithmetics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC"}

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

@@ -13,4 +13,7 @@ export * from "./isMultipleOrDivisor.js";
 export * from "./coprime.js";
 export * from "./countDivisors.js";
 export * from "./findPrimeInList.js";
-// export * from "./findRightPrimeDecomposition.js";
+export * from "./findRightPrimeDecomposition.js";
+export * from "./primeNumberIdentification.js";
+export * from "./primeNumbersAffirmations.js";
+export * from "./findLeftoverInContext.js";

package/lib/exercises/math/calcul/arithmetics/primeNumbersAffirmations.d.ts

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

package/lib/exercises/math/calcul/arithmetics/primeNumbersAffirmations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primeNumbersAffirmations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/primeNumbersAffirmations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAiDrC,KAAK,WAAW,GAAG;IACjB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,wBAAwB,EAAE,MAAM,EAAE,CAAC;CACpC,CAAC;AAqFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/calcul/arithmetics/primeNumbersAffirmations.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, addWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+const rightAffirmations = [
+    "Tout entier naturel est diviseur de lui-même.",
+    "Il y a une infinité de nombres premiers.",
+    "Tout nombre entier admet au moins deux diviseurs.",
+    "$1$ est diviseur de tous les nombres entiers.",
+    "$2$ est le seul nombre premier pair.",
+    "Un nombre premier n'a que deux diviseurs : $1$ et lui-même.",
+];
+const rightAffirmationsCorrections = [
+    `C'est vrai, car pour tout entier naturel $n$, on a : 
+  
+$$
+n = n\\times 1
+$$`,
+    "C'est vrai, c'est une propriété du cours.",
+    `C'est vrai, car pour tout entier naturel $n$, on a : 
+  
+$$
+n = n\\times 1
+$$
+
+donc tout entier naturel est divisible par $1$ et par lui-même.`,
+    `C'est vrai, car pour tout entier naturel $n$, on a : 
+  
+$$
+n = 1\\times n
+$$`,
+    `C'est vrai, car $2$ est divisible uniquement par $1$ et par lui-même, et tous les nombres pairs sont divisibles par $2$, donc ils au moins trois diviseurs.`,
+    "C'est vrai, c'est la définition d'un nombre premier.",
+];
+const wrongAffirmations = [
+    "Tout nombre impair est premier.",
+    "$0$ est diviseur de tous les nombres entiers.",
+    "$1$ est un nombre premier.",
+    "Tout nombre premier est impair.",
+    "Il n'existe pas de nombre premier qui soit pair.",
+];
+const wrongAffirmationsCorrections = [
+    "C'est faux, par exemple $9$ est divisible par $1$, par $3$ et par lui-même, donc il n'a pas uniquement deux diviseurs.",
+    "C'est faux, $0$ est un diviseur de lui-même, mais d'aucun autre entier naturel.",
+    "C'est faux, car $1$ n'a qu'un seul diviseur, lui-même.",
+    "C'est faux, car $2$ est un nombre premier pair.",
+    "C'est faux, $2$ est un nombre premier pair.",
+];
+const getPropositions = (n, { rightAffirmationsIndexes, wrongAffirmationsIndexes }) => {
+    const propositions = [];
+    for (const i of rightAffirmationsIndexes) {
+        addValidProp(propositions, rightAffirmations[i], "raw");
+    }
+    for (const i of wrongAffirmationsIndexes) {
+        addWrongProp(propositions, wrongAffirmations[i], "raw");
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = () => {
+    return `Parmi les affirmations suivantes, laquelle ou lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return `Un nombre $k$ est un diviseur d'un nombre $n$ si on peut l'écrire sous la forme $n = k \\times m$, où $m$ est un entier naturel.`;
+};
+const getCorrection = (identifiers) => {
+    const { rightAffirmationsIndexes, wrongAffirmationsIndexes } = identifiers;
+    return `Voici le(s) affirmation(s) correcte(s) :
+  
+${rightAffirmationsIndexes
+        .map((i) => `- ${rightAffirmations[i]}\n \n ${rightAffirmationsCorrections[i]}\n \n `)
+        .join("")}
+
+\n \n \n 
+${wrongAffirmationsIndexes.length === 0
+        ? ""
+        : `Le(s) affirmation(s) incorrecte(s) sont donc les suivantes : 
+
+${wrongAffirmationsIndexes
+            .map((i) => `- ${wrongAffirmations[i]}\n \n ${wrongAffirmationsCorrections[i]}\n \n `)
+            .join("")}`}`;
+};
+const getPrimeNumbersAffirmationsQuestion = () => {
+    const rightAnswersCount = randint(1, 5);
+    const wrongAnswersCount = 4 - rightAnswersCount;
+    const rightIndexes = randTupleInt(rightAnswersCount, {
+        from: 0,
+        to: rightAffirmations.length,
+        allDifferent: true,
+    });
+    const wrongIndexes = wrongAnswersCount > 0
+        ? randTupleInt(wrongAnswersCount, {
+            from: 0,
+            to: wrongAffirmations.length,
+            allDifferent: true,
+        })
+        : [];
+    const identifiers = {
+        rightAffirmationsIndexes: rightIndexes,
+        wrongAffirmationsIndexes: wrongIndexes,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const primeNumbersAffirmations = {
+    id: "primeNumbersAffirmations",
+    label: "Sélectionner les affirmations correctes concernant les nombres premiers",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPrimeNumbersAffirmationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/calcul/fractions/fractionEquality.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    num1: number;
+    num2: number;
+    denum1: number;
+    denum2: number;
+};
+export declare const fractionEquality: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=fractionEquality.d.ts.map

package/lib/exercises/math/calcul/fractions/fractionEquality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fractionEquality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionEquality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionEquality.js

@@ -0,0 +1,123 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp,
+// GeneratorOption,
+// GeneratorOptionTarget,
+// GeneratorOptionType,
+ } 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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { denum1, denum2, num1, num2 } = identifiers;
+    addValidProp(propositions, num1 * denum2 === num2 * denum1 ? "Oui" : "Non", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { denum1, denum2, num1, num2 } = identifiers;
+    return num1 * denum2 === num2 * denum1 ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { denum1, denum2, num1, num2 } = identifiers;
+    return `L'égalité suivante est-elle vraie ?
+  
+$$
+${frac(num1, denum1).toTex()} = ${frac(num2, denum2).toTex()}
+$$`;
+};
+const getHint = () => {
+    return `Deux fractions $\\frac{a}{b}$ et $\\frac{c}{d}$ sont égales si et seulement si : 
+  
+$$
+a\\times d = b\\times c
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { denum1, denum2, num1, num2 } = identifiers;
+    const equal = num1 * denum2 === num2 * denum1;
+    return `Deux fractions $\\frac{a}{b}$ et $\\frac{c}{d}$ sont égales si et seulement si : 
+  
+$$
+a\\times d = b\\times c
+$$
+
+Ici, on a :
+
+- $${multiply(num1, denum2).toSimplificationTex()}$
+
+- $${multiply(num2, denum1).toSimplificationTex()}$
+
+${equal
+        ? `Les deux fractions sont donc bien égales.`
+        : `Les deux fractions ne sont donc pas égales.`}
+`;
+};
+const getFractionEqualityQuestion = () => {
+    const isEqual = coinFlip();
+    let num1 = randint(2, 11);
+    let denum1 = randint(2, 11, [num1]);
+    let num2;
+    let denum2;
+    const ratio = randint(2, 7);
+    if (isEqual) {
+        num2 = num1 * ratio;
+        denum2 = denum1 * ratio;
+    }
+    else {
+        num2 = num1 * ratio + randint(-1, 2, [0]);
+        denum2 = denum1 * ratio + randint(-1, 2, [0]);
+    }
+    if (coinFlip())
+        [num1, denum1, num2, denum2] = [num2, denum2, num1, denum1];
+    const identifiers = {
+        num1,
+        num2,
+        denum1,
+        denum2,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+// type Options = {
+//   numberType: string[];
+// };
+// const options: GeneratorOption[] = [
+//   {
+//     id: "numberType",
+//     label: "Type de nombres",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     defaultValue: ["Entier", "Décimal"],
+//     values: ["Entier", "Décimal"],
+//   },
+// ];
+export const fractionEquality = {
+    id: "fractionEquality",
+    label: "Vérifier une égalité du type $\\frac{a}{b} = \\frac{c}{d}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFractionEqualityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calcul/fractions/index.d.ts

@@ -18,4 +18,5 @@ export * from "./fractionForbiddenValue.js";
 export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";
 export * from "./fractionsMix.js";
+export * from "./fractionEquality.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/fractions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

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

@@ -18,3 +18,4 @@ export * from "./fractionForbiddenValue.js";
 export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";
 export * from "./fractionsMix.js";
+export * from "./fractionEquality.js";

package/lib/exercises/math/calcul/proportionality/fourthProportionalFromProblem.d.ts

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

package/lib/exercises/math/calcul/proportionality/fourthProportionalFromProblem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fourthProportionalFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/fourthProportionalFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AA6cF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}