math-exercises 3.0.125 → 3.0.127

package/lib/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.js

@@ -0,0 +1,86 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { varNames } = identifiers;
+    const [x, y, u] = varNames;
+    return `On considère $${x}$, $${y}$ et $${u}$ trois nombres non nuls tels que  
+
+$$
+\\frac{1}{${x}}+\\frac{1}{${y}}=\\frac{1}{${u}}
+$$
+
+Alors  $${u}$ = ?`;
+};
+const getHint = (identifiers) => {
+    const { varNames } = identifiers;
+    const [, , u] = varNames;
+    return `Pour isoler $${u}$, il faut passer à l'inverse.`;
+};
+const getCorrection = (identifiers) => {
+    const { varNames } = identifiers;
+    const [x, y, u] = varNames;
+    return alignTex([
+        [`${u}`, "=", `\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}`],
+        [``, "=", `\\frac{1}{\\frac{${x}+${y}}{${x}${y}}}`],
+        [``, "=", `\\frac{${x}${y}}{${x}+${y}}`],
+    ]);
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { varNames } = identifiers;
+    const [x, y] = varNames;
+    const propositions = [];
+    addValidProp(propositions, `\\frac{${x}${y}}{${x}+${y}}`, "tex");
+    tryToAddWrongProp(propositions, `\\frac{${x}+${y}}{${x}${y}}`, "tex");
+    tryToAddWrongProp(propositions, `${x}${y}`, "tex");
+    tryToAddWrongProp(propositions, `${x} + ${y}`, "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getIsolateUInInvXPlusInvYEqualsInvUQuestion = () => {
+    const varNames = randomMany(["x", "y", "z", "t", "u", "v", "w"], 3);
+    return getQuestionFromIdentifiers({ varNames });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const isolateUInInvXPlusInvYEqualsInvU = {
+    id: "isolateUInInvXPlusInvYEqualsInvU",
+    label: "Isoler $u$ dans l'expression $\\frac{1}{x}+\\frac{1}{y}=\\frac{1}{u}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getIsolateUInInvXPlusInvYEqualsInvUQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};
+const getIsolateRInInvR1PlusInvR2EqualsInvRQuestion = () => {
+    const varNames = ["R_1", "R_2", "R"];
+    return getQuestionFromIdentifiers({ varNames });
+};
+export const isolateRInInvR1PlusInvR2EqualsInvR = {
+    id: "isolateRInInvR1PlusInvR2EqualsInvR",
+    label: "Isoler $R$ dans l'expression $\\frac{1}{R_1}+\\frac{1}{R_2}=\\frac{1}{R}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getIsolateRInInvR1PlusInvR2EqualsInvRQuestion(), nb, 30, () => false),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/isolate/isolateXInInvXPlusInvYEqualsInvU.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    varNames: string[];
+};
+export declare const isolateXInInvXPlusInvYEqualsInvU: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isolateXInInvXPlusInvYEqualsInvU.d.ts.map

package/lib/exercises/math/calculLitteral/isolate/isolateXInInvXPlusInvYEqualsInvU.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isolateXInInvXPlusInvYEqualsInvU.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/isolate/isolateXInInvXPlusInvYEqualsInvU.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAkFF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC"}

package/lib/exercises/math/calculLitteral/isolate/isolateXInInvXPlusInvYEqualsInvU.js

@@ -0,0 +1,80 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { varNames } = identifiers;
+    const [x, y, u] = varNames;
+    return `On considère $${x}$, $${y}$ et $${u}$ trois nombres non nuls tels que  
+
+$$
+\\frac{1}{${x}}+\\frac{1}{${y}}=\\frac{1}{${u}}
+$$
+
+Alors  $${x}$ = ?`;
+};
+const getHint = (identifiers) => {
+    const { varNames } = identifiers;
+    const [x, ,] = varNames;
+    return `Il faut isoler  $\\frac{1}{${x}}$ puis passer à l'inverse.`;
+};
+const getCorrection = (identifiers) => {
+    const { varNames } = identifiers;
+    const [x, y, u] = varNames;
+    return `On a : 
+
+$$
+\\frac{1}{${x}}=\\frac{1}{${u}}-\\frac{1}{${y}}
+$$
+
+$$
+\\frac{1}{${x}}=\\frac{${y}-${u}}{${u}${y}}
+$$
+
+Ainsi  
+
+$$
+${x}=\\frac{${u}${y}}{${y}-${u}}
+$$ 
+
+`;
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { varNames } = identifiers;
+    const [, y, u] = varNames;
+    const propositions = [];
+    addValidProp(propositions, `\\frac{${u}${y}}{${y}-${u}}`, "tex");
+    tryToAddWrongProp(propositions, `\\frac{${y}-${u}}{${u}${y}}`, "tex");
+    tryToAddWrongProp(propositions, `${u}-${y}`, "tex");
+    tryToAddWrongProp(propositions, `\\frac{${u}${y}}{${y}+${u}}`, "tex");
+    tryToAddWrongProp(propositions, `\\frac{${y}+${u}}{${u}${y}}`, "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getIsolateXInInvXPlusInvYEqualsInvUQuestion = () => {
+    const varNames = randomMany(["x", "y", "z", "t", "u", "v", "w"], 3);
+    return getQuestionFromIdentifiers({ varNames });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const isolateXInInvXPlusInvYEqualsInvU = {
+    id: "isolateXInInvXPlusInvYEqualsInvU",
+    label: "Isoler $x$ dans l'expression $\\frac{1}{x}+\\frac{1}{y}=\\frac{1}{u}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getIsolateXInInvXPlusInvYEqualsInvUQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    names: string[];
+    texInstruction: string;
+    texsCorrection: string[];
+    texsAnswer: string[];
+};
+export declare const compareAMinusB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareAMinusB.d.ts.map

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -0,0 +1,180 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { names, texInstruction } = identifiers;
+    return `Si $${names[0]}$ et $${names[1]}$  sont deux nombres tels que  
+  
+$$
+${texInstruction}
+$$   
+
+alors on peut dire que :`;
+};
+const getHint = () => {
+    return `Essaye d’isoler chaque variable de chaque côté de l’inégalité.`;
+};
+const getCorrection = (identifiers) => {
+    const { names, texInstruction, texsCorrection } = identifiers;
+    return `On a : 
+
+$$
+${texInstruction}
+$$
+
+En ajoutant $${names[1]}$ de chaque côté, on obtient :
+
+$$
+${texsCorrection[0]}
+$$
+
+${texsCorrection.length > 1
+        ? `On peut aussi en déduire l'inégalité moins stricte :
+  
+$$
+${texsCorrection[1]}
+$$
+  
+`
+        : ``}
+  
+`;
+};
+const getPropositions = (n, { names, texsAnswer }) => {
+    const propositions = [];
+    texsAnswer.forEach((tex) => {
+        addValidProp(propositions, tex);
+    });
+    const invalidProps = [
+        `${names[0]} < ${names[1]}`,
+        `${names[0]} > ${names[1]}`,
+        `${names[0]} \\leq ${names[1]}`,
+        `${names[0]} \\geq ${names[1]}`,
+        `${names[1]} < ${names[0]}`,
+        `${names[1]} > ${names[0]}`,
+        `${names[1]} \\leq ${names[0]}`,
+        `${names[1]} \\geq ${names[0]}`,
+    ].filter((tex) => !texsAnswer.includes(tex));
+    invalidProps.forEach((tex) => {
+        tryToAddWrongProp(propositions, tex);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { texsAnswer }) => {
+    return texsAnswer.includes(ans);
+};
+const getCompareAMinusBQuestion = () => {
+    const namesPool = ["a", "b", "c", "d", "r", "s", "t", "u", "v"];
+    const names = randomMany(namesPool, 2);
+    const compareSymbol = random(["inf", "sup", "leq", "geq"]);
+    let texsObjectArray = [];
+    switch (compareSymbol) {
+        case "inf":
+            {
+                texsObjectArray = [
+                    {
+                        texInstruction: `x - y < 0`,
+                        texsCorrection: [`x < y`, `x \\leq y`],
+                        texsAnswer: [`x < y`, `x \\leq y`, `y > x`, `y \\geq x`],
+                    },
+                    {
+                        texInstruction: `0 > x - y`,
+                        texsCorrection: [`y > x`, `y \\geq x`],
+                        texsAnswer: [`x < y`, `x \\leq y`, `y > x`, `y \\geq x`],
+                    },
+                ];
+            }
+            break;
+        case "sup":
+            {
+                texsObjectArray = [
+                    {
+                        texInstruction: `x - y > 0`,
+                        texsCorrection: [`x > y`, `x \\geq y`],
+                        texsAnswer: [`x > y`, `x \\geq y`, `y < x`, `y \\leq x`],
+                    },
+                    {
+                        texInstruction: `0 < x - y`,
+                        texsCorrection: [`y < x`, `y \\leq x`],
+                        texsAnswer: [`x > y`, `x \\geq y`, `y < x`, `y \\leq x`],
+                    },
+                ];
+            }
+            break;
+        case "leq":
+            {
+                texsObjectArray = [
+                    {
+                        texInstruction: `x - y \\leq 0`,
+                        texsCorrection: [`x \\leq y`],
+                        texsAnswer: [`x \\leq y`, `y \\geq x`],
+                    },
+                    {
+                        texInstruction: `0 \\geq x - y`,
+                        texsCorrection: [`y \\geq x`],
+                        texsAnswer: [`x \\leq y`, `y \\geq x`],
+                    },
+                ];
+            }
+            break;
+        case "geq":
+            {
+                texsObjectArray = [
+                    {
+                        texInstruction: `x - y \\geq 0`,
+                        texsCorrection: [`x \\geq y`],
+                        texsAnswer: [`x \\geq y`, `y \\leq x`],
+                    },
+                    {
+                        texInstruction: `0 \\leq x - y`,
+                        texsCorrection: [`y \\leq x`],
+                        texsAnswer: [`x \\geq y`, `y \\leq x`],
+                    },
+                ];
+            }
+            break;
+    }
+    function replaceVarNames(tex) {
+        return tex.replaceAll("x", names[0]).replaceAll("y", names[1]);
+    }
+    const order = coinFlip() ? [0, 1] : [1, 0];
+    let { texInstruction, texsCorrection, texsAnswer } = texsObjectArray[order[0]];
+    texInstruction = replaceVarNames(texInstruction);
+    texsCorrection = texsCorrection.map((tex) => replaceVarNames(tex));
+    texsAnswer = texsAnswer.map((tex) => replaceVarNames(tex));
+    return getQuestionFromIdentifiers({
+        names,
+        texInstruction,
+        texsCorrection,
+        texsAnswer,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: ["inf", "sup", "leq", "geq", ...identifiers.names],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareAMinusB = {
+    id: "compareAMinusB",
+    label: "Comparer deux nombres $a$ et $b$ par le calcul de leur différence.",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareAMinusBQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    names: string[];
+    texInstruction: string;
+    texAnswers: string[];
+};
+export declare const compareFromPiMinusFrac: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareFromPiMinusFrac.d.ts.map

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareFromPiMinusFrac.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.js

@@ -0,0 +1,144 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { names, texInstruction } = identifiers;
+    return `Sachant que  
+  
+$$
+${texInstruction}
+$$   
+
+comparer $${names[0]}$ et $${names[1]}$.`;
+};
+const getHint = (identifiers) => {
+    const { names } = identifiers;
+    return `Il faut comparer la valeur de $${names[0]}$ et de $${names[1]}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { names, texInstruction, texAnswers } = identifiers;
+    return `On a : 
+
+$$
+${texInstruction}
+$$
+
+En ajoutant $${names[1]}$ de chaque côté, on obtient :
+
+$$
+${texAnswers[0]}
+$$
+  
+`;
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, answer
+        .replace(">", "TMP(>)")
+        .replace("<", "TMP(<)")
+        .replace("TMP(>)", "<")
+        .replace("TMP(<)", ">"));
+    return shuffle(propositions);
+};
+const getAnswer = (identifiers) => {
+    const { texAnswers } = identifiers;
+    return texAnswers[0];
+};
+const isAnswerValid = (ans, { texAnswers }) => {
+    return texAnswers.includes(ans);
+};
+const getCompareFromPiMinusFracQuestion = () => {
+    const fracsPool = [
+        frac(31, 10),
+        frac(314, 100),
+        frac(31415926535, 10000000000),
+        frac(25, 8),
+        frac(22, 7),
+        frac(233, 71),
+        frac(377, 120),
+        frac(256, 81),
+        frac(355, 113),
+        frac(333, 106),
+        frac(339, 108),
+        frac(3927, 1250),
+        frac(62832, 20000),
+        frac(103993, 33102),
+        frac(104348, 33215),
+    ];
+    const nodes = [PiNode, random(fracsPool)];
+    const compareSymbol = coinFlip() ? ">" : "<";
+    const isPiOverFrac = substract(nodes[0], nodes[1]).evaluate() > 0;
+    const sortedIndexes = (isPiOverFrac ? +1 : -1) * (compareSymbol === ">" ? +1 : -1) === 1
+        ? [1, 0]
+        : [0, 1];
+    const names = sortedIndexes.map((sortedI) => `${nodes[sortedI].toTex()}`);
+    let texInstruction;
+    let texAnswers;
+    if (isPiOverFrac) {
+        texInstruction = `${names[0]} - ${names[1]} ${compareSymbol} 0`;
+        texAnswers = [
+            `${names[0]}${compareSymbol}${names[1]}`,
+            `${names[1]}${compareSymbol === ">" ? "<" : ">"}${names[0]}`,
+        ];
+    }
+    else {
+        texInstruction = `0 ${compareSymbol} ${names[0]} - ${names[1]}`;
+        texAnswers = [
+            `${names[0]}${compareSymbol === ">" ? "<" : ">"}${names[1]}`,
+            `${names[1]}${compareSymbol}${names[0]}`,
+        ];
+    }
+    return getQuestionFromIdentifiers({
+        names,
+        texInstruction,
+        texAnswers,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [
+            "sup",
+            "inf",
+            ...identifiers.names.map((name) => {
+                return {
+                    id: "custom",
+                    label: name,
+                    labelType: "tex",
+                    mathfieldInstructions: {
+                        method: "write",
+                        content: name,
+                    },
+                };
+            }),
+        ],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareFromPiMinusFrac = {
+    id: "compareFromPiMinusFrac",
+    label: "Comparer deux nombres ($\\pi$ et une fraction approximante) par le calcul de leur différence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareFromPiMinusFracQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./compareAMinusB.js";
+export * from "./compareFromPiMinusFrac.js";

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Item = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type Identifiers = {
+    items: Item[];
+};
+export declare const compareATimes0: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareATimes0.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareATimes0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareATimes0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.js

@@ -0,0 +1,120 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getInstruction = () => {
+    return `Soit a un nombre non nul. 
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return `$0$ divisé par un nombre non nul donne $0$.
+
+$0$ multiplié par n'importe quel nombre donne $0$.`;
+};
+const getCorrection = () => {
+    return `
+
+$$
+0 \\times a = 0
+$$ 
+
+et  
+
+$$
+\\frac{0}{a} = 0
+$$ 
+
+donc 
+
+$$
+0 \\times a = \\frac{0}{a} = 0
+$$
+
+`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getCompareATimes0Question = () => {
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.5],
+        [2, 0.45],
+        [3, 0.03],
+        [4, 0.02],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const arrayOfTex = [`0 \\times a`, `\\frac{0}{a}`, `0`];
+    const permutations = permute(arrayOfTex);
+    const validItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${[tex1, tex2, tex3].join("=")}$`,
+            `$${tex1}=${tex2}$ et $${tex2}=${tex3}$`,
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: true,
+            };
+        });
+    });
+    const invalidItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${tex1}>${tex2}$ et $${tex2}=${tex3}$`,
+            `$${tex1}=${tex2}$ et $${tex2}>${tex3}$`,
+            ...(tex3 === `\\frac{0}{a}`
+                ? [`$${tex1}=${tex2}$ et $${tex3}$ n'existe pas`]
+                : []),
+            ...(tex1 === `\\frac{0}{a}`
+                ? [`$${tex1}$ n'existe pas et $${tex2}=${tex3}$`]
+                : []),
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: false,
+            };
+        });
+    });
+    const items = shuffle([
+        ...shuffle(validItems).slice(0, nbValid),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ items });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const compareATimes0 = {
+    id: "compareATimes0",
+    label: "Comparer $0$ , $0 \\times a$ et $\\frac{0}{a}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareATimes0Question(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};