math-exercises 3.0.125 → 3.0.127

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

@@ -1 +1 @@
-{"version":3,"file":"fractionsSumsPrimeDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,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;AAuHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAiBhE,CAAC"}
+{"version":3,"file":"fractionsSumsPrimeDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAcrC,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;AAyLF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAkBhE,CAAC"}

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

@@ -3,7 +3,9 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
 import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { rationalParser } from "../../../../tree/parsers/rationalParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers, opts) => {
@@ -26,6 +28,61 @@ const getAnswer = (identifiers) => {
     const answer = ratio1.add(ratio2).toTree().toTex();
     return answer;
 };
+const getHint = () => {
+    return `Il faut tout d'abord mettre les fractions au même dénominateur. Ensuite, additionne les numérateurs, puis simplifie le résultat obtenu.`;
+};
+const getCorrection = (identifiers) => {
+    const { denom1, denom2, num1, num2 } = identifiers;
+    const firstFrac = frac(num1, denom1);
+    const secondFrac = frac(num2, denom2);
+    let technique = "";
+    let firstFracFinal = firstFrac;
+    let secondFracFinal = secondFrac;
+    const firstProduct = frac(multiply(num1, denom2), multiply(num2, denom2));
+    firstFracFinal = firstProduct.simplify({
+        forbidRationalSimplification: true,
+    });
+    const secondProduct = frac(multiply(num2, denom1), multiply(denom2, denom1));
+    secondFracFinal = secondProduct.simplify({
+        forbidRationalSimplification: true,
+    });
+    technique = `on multiple le numérateur et le dénominateur de la première fraction par $${denom2}$, et le numérateur et dénominateur de la deuxième fraction par $${denom1}$ : 
+    
+$$
+${firstFrac.toTex()} = ${firstProduct.toTex({
+        forceNoSimplification: true,
+    })} = ${firstFracFinal.toTex()}
+$$
+
+$$
+${secondFrac.toTex()} = ${secondProduct.toTex({
+        forceNoSimplification: true,
+    })} = ${secondFracFinal.toTex()}
+$$
+`;
+    const sumFinal = add(firstFracFinal, secondFracFinal);
+    const subSumFinal = frac(add(firstFracFinal.leftChild, secondFracFinal.leftChild), firstFracFinal.rightChild);
+    const finalNonSimp = subSumFinal.simplify({
+        forbidRationalSimplification: true,
+    });
+    const final = subSumFinal.simplify();
+    const isSimplifiable = finalNonSimp.toTex() !== final.toTex();
+    return `On commence par mettre les fractions au même dénominateur. Pour cela, ${technique}
+  
+On peut alors additionner les deux fractions : 
+
+$$
+${sumFinal.toTex()} = ${subSumFinal.toTex()} = ${finalNonSimp.toTex()}
+$$
+
+${isSimplifiable
+        ? `On peut alors simplifier cette fraction : 
+  
+$$
+${finalNonSimp.toTex()} = ${final.toTex()}
+$$`
+        : "Cette fraction est déjà simplifiée."}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -33,6 +90,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -103,4 +162,5 @@ export const fractionsSumsPrimeDenominators = {
     subject: "Mathématiques",
     options,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -4,4 +4,5 @@ export * from "./mentalMultiplications.js";
 export * from "./mentalPercentage.js";
 export * from "./mentalAddAndSubNoRelative.js";
 export * from "./mentalMultiplicationsNoRelative.js";
+export * from "./mentalProgramSolve.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC"}

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

@@ -4,3 +4,4 @@ export * from "./mentalMultiplications.js";
 export * from "./mentalPercentage.js";
 export * from "./mentalAddAndSubNoRelative.js";
 export * from "./mentalMultiplicationsNoRelative.js";
+export * from "./mentalProgramSolve.js";

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { ProgCalcIdentifiers } from "../../../../math/progCalc/progCalc.js";
+type Identifiers = {
+    nodeIdsStartingNumber: NodeIdentifiers;
+    progCalcIds: ProgCalcIdentifiers;
+};
+type Options = {
+    numberType: "Entier" | "Décimal";
+    nbSteps: number;
+    nbDigits: number;
+};
+export declare const mentalProgramSolve: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=mentalProgramSolve.d.ts.map

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentalProgramSolve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalProgramSolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAgCzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AA8MF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA0B7D,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.js

@@ -0,0 +1,231 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { ProgCalc, ProgCalcConstructor, } from "../../../../math/progCalc/progCalc.js";
+import { isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getStrSolvingStep = (nodeStep) => {
+    //write 10 + (-8) instead of 10 - 8
+    function isNegative(node) {
+        return !abs(node).simplify().equals(node.simplify());
+    }
+    if (isAddNode(nodeStep) && isNegative(nodeStep.rightChild)) {
+        return `${nodeStep.leftChild.toTex()} + (${nodeStep.rightChild.toTex()}) = ${nodeStep
+            .simplify()
+            .toTex()}`;
+    }
+    else if (isOppositeNode(nodeStep)) {
+        return `-(${nodeStep.child.toTex()}) = ${nodeStep.simplify().toTex()}`;
+    }
+    else {
+        const texL = nodeStep.toTex({
+            allowDoubleMinus: true,
+            forceTimesSign: true,
+            forceParenthesis: true,
+            forceNoSimplification: true,
+            allowMinusAnywhereInFraction: true,
+        });
+        const texR = nodeStep.simplify().toTex();
+        return `${texL} = ${texR}`;
+    }
+};
+const getPropositions = (n, { answer, progCalcIds, nodeIdsStartingNumber }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
+    //applies progCalc to finalNumber
+    tryToAddWrongProp(propositions, progCalc.apply(nodeFinalNumber).simplify().toTex());
+    //applies progCalc operations in reverse to finalNumber
+    const progCalcReversed = new ProgCalc(progCalc.operations.toReversed());
+    tryToAddWrongProp(propositions, progCalcReversed.apply(nodeFinalNumber).simplify().toTex());
+    //stops at intermediary step (stops before goal)
+    const progCalcInverse = progCalc.getInverseProgCalc();
+    const inverseOperations = progCalcInverse.operations;
+    const arrStepNodes = [nodeFinalNumber];
+    for (let i = 0; i < inverseOperations.length - 1; i++) {
+        const nodePrevious = arrStepNodes[arrStepNodes.length - 1].simplify();
+        const operation = inverseOperations[i];
+        const nodeStep = operation.func(nodePrevious);
+        arrStepNodes.push(nodeStep);
+    }
+    shuffle(arrStepNodes).forEach((nodeStep) => {
+        if (propositions.length < n) {
+            tryToAddWrongProp(propositions, nodeStep.simplify().toTex());
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsStartingNumber } = identifiers;
+    return NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { nodeIdsStartingNumber, progCalcIds } = identifiers;
+    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
+    const strFinalNumber = opts?.numberType == "Entier"
+        ? nodeFinalNumber.evaluate().frenchify()
+        : nodeFinalNumber
+            .evaluate()
+            .toFixed(opts?.nbDigits ?? 0)
+            .replace(".", ",");
+    return `Voici un programme de calcul :
+
+> Choisir un nombre
+
+${progCalc.getArrOfFrenchStrings().map((str) => `> ${str}`).join(`
+  
+`)}
+
+Quel nombre faut-il choisir au départ pour obtenir $ ${strFinalNumber} $ à la fin ?`;
+};
+const getHint = () => {
+    return `Pars du résultat obtenu à la fin et remonte à l'envers en inversant chaque étape.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsStartingNumber, progCalcIds } = identifiers;
+    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
+    const arrOpInverse = progCalc.getInverseProgCalc().operations;
+    const arrStrSolvingSteps = [];
+    let nodePrevious = nodeFinalNumber;
+    for (let i = 0; i < arrOpInverse.length; i++) {
+        const operation = arrOpInverse[i];
+        if (nodePrevious.opts) {
+            nodePrevious.opts.forceParenthesis = true;
+        }
+        else {
+            nodePrevious.opts = {
+                forceParenthesis: true,
+            };
+        }
+        const nodeStep = operation.func(nodePrevious);
+        const strSolvingStep = getStrSolvingStep(nodeStep);
+        nodePrevious = nodeStep.simplify();
+        arrStrSolvingSteps.push(strSolvingStep);
+    }
+    return `
+On part de la fin et on remonte à l'envers en inversant chaque étape.
+
+${alignTex(arrStrSolvingSteps.map((str) => {
+        const [lhs, rhs] = str.split("=");
+        return [lhs, "=", rhs];
+    }))}
+  
+Le nombre choisi au départ était donc $ ${nodeStartingNumber.toTex()} $.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMentalProgramSolveQuestion = (optsIn) => {
+    const opts = optsIn ? Object.assign(optsDefault, optsIn) : optsDefault;
+    let nbDigits = 0;
+    switch (opts.numberType) {
+        case "Décimal":
+            nbDigits = opts.nbDigits ?? 2;
+            break;
+        default:
+        case "Entier":
+            nbDigits = 0;
+            break;
+    }
+    const powerOf10 = Math.pow(10, nbDigits);
+    const valueStart = randint(0, 33 * powerOf10, []) / powerOf10;
+    const nodeStartingNumber = valueStart.toTree();
+    const isSingleUseOperators = false;
+    const progCalc = ProgCalcConstructor.randomMental(opts.nbSteps, nodeStartingNumber, nbDigits, isSingleUseOperators);
+    const identifiers = {
+        nodeIdsStartingNumber: valueStart.toTree().toIdentifiers(),
+        progCalcIds: progCalc.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const optsDefault = {
+    numberType: "Entier",
+    nbSteps: 4,
+    nbDigits: 0,
+};
+const options = [
+    {
+        id: "numberType",
+        label: "Type de nombres utilisés",
+        defaultValue: optsDefault.numberType,
+        values: ["Entier", "Décimal"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+    {
+        id: "nbSteps",
+        label: "Nombre d'étapes de transformation",
+        defaultValue: optsDefault.nbSteps,
+        values: [2, 3, 4, 5, 6],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+    {
+        id: "nbDigits",
+        label: "Nombre de décimales",
+        defaultValue: optsDefault.nbDigits,
+        values: [0, 1, 2],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+    },
+];
+export const mentalProgramSolve = {
+    id: "mentalProgramSolve",
+    label: "Résoudre un problème basé sur un programme de calcul avec des entiers ou des décimaux",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMentalProgramSolveQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!opts?.numberType,
+            message: "Veuillez choisir un type de nombres.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type A10N = {
+    a: number;
+    n: number;
+};
+type Identifiers = {
+    signType: string;
+    items: A10N[];
+};
+type Options = {
+    signTypes: string[];
+    nbCollisions: number[];
+};
+export declare const compareA10N: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=compareA10N.d.ts.map

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwTF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA0CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBtD,CAAC"}