math-exercises 3.0.125 → 3.0.126

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: "Integer" | "Decimal";
+    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;AAI7C,OAAO,EAEL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AA2BzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAoMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB7D,CAAC"}

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

@@ -0,0 +1,217 @@
+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 { randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { ProgCalcConstructor, } from "../../../../math/progCalc/progCalc.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+const getStrSolvingStep = (nodeStep) => {
+    //write 10 + (-8) instead of 10 - 8
+    function isNegative(node) {
+        return !abs(node).simplify().equals(node.simplify());
+    }
+    if (nodeStep instanceof AddNode && isNegative(nodeStep.rightChild)) {
+        return `${nodeStep.leftChild.toTex()} + (${nodeStep.rightChild.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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const nodeFinalNumber = answer.toTree();
+    const nbWrong = n - 1;
+    const arrOffset = randomMany([-10, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 10], nbWrong);
+    for (let i = 0; i < arrOffset.length; i++) {
+        const offset = arrOffset[i];
+        tryToAddWrongProp(propositions, add(nodeFinalNumber, offset).simplify().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsStartingNumber } = identifiers;
+    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+    return nodeStartingNumber.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 strOpening = `Voici un programme de calcul :`;
+    const strChooseANumber = `Choisir un nombre
+    
+`;
+    const arrStrProgCalc = progCalc.getArrOfFrenchStrings().map((str) => `
+  
+${str}`);
+    const strProgCalc = arrStrProgCalc.reduce((acc, str) => acc + str);
+    const strFinalNumber = opts?.numberType == "Integer"
+        ? nodeFinalNumber.evaluate().frenchify()
+        : nodeFinalNumber
+            .evaluate()
+            .toFixed(opts?.nbDigits ?? 0)
+            .replace(".", ",");
+    const strQuestion = `Quel nombre faut-il choisir au départ pour obtenir $ ${strFinalNumber} $ à la fin ?`;
+    return `
+${strOpening}
+
+${strChooseANumber}
+
+${strProgCalc}
+
+${strQuestion}
+`;
+};
+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.
+
+${arrStrSolvingSteps.map((str) => `
+
+$$
+${str}
+$$
+`)}
+  
+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 "Integer":
+            nbDigits = 0;
+            break;
+        case "Decimal":
+            nbDigits = opts.nbDigits ?? 2;
+            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: "Integer",
+    nbSteps: 4,
+    nbDigits: 0,
+};
+const options = [
+    {
+        id: "numberType",
+        label: "Type de nombres utilisés",
+        defaultValue: optsDefault.numberType,
+        values: ["Integer", "Decimal"],
+        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,
+};

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"}