math-exercises 3.0.125 → 3.0.127

package/lib/exercises/math/calculLitteral/equation/equationFromProblem.js

@@ -0,0 +1,454 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+class ProblemConstructor {
+    static byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays) {
+        const shuffleFuncs = shuffleArrays.map((shuffleArray) => {
+            return (array) => {
+                return array.map((_, i) => array[shuffleArray[i]]);
+            };
+        });
+        const groups = Object.fromEntries(Object.entries(skeleton.groups).map(([gpName, gp]) => {
+            const vars = Object.fromEntries(Object.entries(gp.vars).map(([varName, varSkeleton]) => {
+                const node = groupNameToVarNameToValue[gpName][varName];
+                return [varName, new ProblemVar(varSkeleton, node)];
+            }));
+            return [gpName, new ProblemVarGroup(gp, vars)];
+        }));
+        const [mysteryGroupName, mysteryVarNameInGroup] = mysteryVarPath.split(".");
+        const mysteryGroup = groups[mysteryGroupName];
+        const mysteryVar = mysteryGroup.vars[mysteryVarNameInGroup];
+        return new Problem(skeleton, groups, mysteryGroup, mysteryVar, shuffleFuncs);
+    }
+}
+class Problem {
+    skeleton;
+    groups;
+    mysteryGroup;
+    mysteryVar;
+    shuffleFuncs;
+    equalNode;
+    frenchStr;
+    constructor(skeleton, groups, mysteryGroup, mysteryVar, shuffleFuncs) {
+        this.skeleton = skeleton;
+        this.groups = groups;
+        this.mysteryGroup = mysteryGroup;
+        this.mysteryVar = mysteryVar;
+        this.shuffleFuncs = shuffleFuncs;
+        this.equalNode = this.skeleton.equalNodeFunc(mysteryGroup, mysteryVar, groups, shuffleFuncs);
+        this.frenchStr = this.skeleton.strFunc(mysteryGroup, mysteryVar, groups, shuffleFuncs);
+        //populate computed groups
+        Object.values(groups)
+            .filter((group) => group.skeleton.isComputed)
+            .forEach((group) => {
+            Object.values(group.vars).forEach((problemVar) => {
+                if (problemVar.value === undefined) {
+                    problemVar.value = group.getNode(mysteryVar, groups, shuffleFuncs);
+                }
+            });
+        });
+    }
+    getArrayOfUsefulVarNames() {
+        return [this.mysteryVar.skeleton.varName];
+    }
+    getArrayOfUsefulNodes() {
+        return Object.values(this.groups).flatMap((group) => {
+            return Object.values(group.vars)
+                .flatMap((problemVar) => problemVar === this.mysteryVar
+                ? problemVar.getVarNode()
+                : problemVar.getValueNode())
+                .filter((node) => !!node);
+        });
+    }
+    getExplanationString() {
+        const arrArr = Object.values(this.groups).map((group) => [
+            `\\text{${group.getScalarString(this.mysteryVar).replaceAll("$", "")}}`,
+            `:`,
+            `${group
+                .getNode(this.mysteryVar, this.groups, this.shuffleFuncs)
+                .toTex()}`,
+        ]);
+        return alignTex(arrArr, false);
+    }
+}
+class ProblemVarGroup {
+    skeleton;
+    vars;
+    constructor(skeleton, vars) {
+        this.skeleton = skeleton;
+        this.vars = vars;
+    }
+    toTex(mysteryVar) {
+        return this.skeleton.strFunc(this, mysteryVar);
+    }
+    getNode(mysteryVar, groups, shuffleFuncs) {
+        return this.skeleton.nodeFunc(this, mysteryVar, groups, shuffleFuncs);
+    }
+    getScalarString(mysteryVar) {
+        return `${this.skeleton.strToScalar} ${this.toTex(mysteryVar)}`;
+    }
+}
+class ProblemVar {
+    skeleton;
+    value;
+    constructor(skeleton, value) {
+        this.skeleton = skeleton;
+        this.value = value;
+    }
+    getVarNode() {
+        return this.skeleton.varName.toTree();
+    }
+    getValueNode() {
+        return this.value;
+    }
+}
+class ProblemVarSkeletonGroup {
+    vars;
+    strToScalar;
+    strFunc;
+    nodeFunc;
+    isCanBeMysteryGroup;
+    isComputed;
+    constructor(vars, strToScalar, strFunc, nodeFunc, isCanBeMysteryGroup, isComputed) {
+        this.vars = vars;
+        this.strToScalar = strToScalar;
+        this.strFunc = strFunc;
+        this.nodeFunc = nodeFunc;
+        this.isCanBeMysteryGroup = isCanBeMysteryGroup;
+        this.isComputed = isComputed;
+    }
+    createRandomValuesDict() {
+        return Object.fromEntries(Object.entries(this.vars)
+            .filter(([_, varSkeleton]) => !!varSkeleton.randNode)
+            .map(([varName, varSkeleton]) => {
+            return [varName, varSkeleton.randNode()];
+        }));
+    }
+}
+class ProblemSkeleton {
+    sampleStr;
+    strFunc;
+    equalNodeFunc;
+    groups;
+    swappableGroups;
+    constructor(sampleStr, strFunc, equalNodeFunc, groups, swappableGroups) {
+        this.sampleStr = sampleStr;
+        this.strFunc = strFunc;
+        this.equalNodeFunc = equalNodeFunc;
+        this.groups = groups;
+        this.swappableGroups = swappableGroups;
+    }
+    createRandomValuesDict() {
+        return Object.fromEntries(Object.entries(this.groups).map(([gpName, gp]) => {
+            return [gpName, gp.createRandomValuesDict()];
+        }));
+    }
+    createRandomMysteryVarPath() {
+        const [groupName, group] = random(Object.entries(this.groups).filter(([_, group]) => group.isCanBeMysteryGroup));
+        const [groupVarNameInGroup, _] = random(Object.entries(group.vars));
+        return `${groupName}.${groupVarNameInGroup}`;
+    }
+    createRandomShuffleArrays() {
+        return this.swappableGroups.map((arrayOfGroupNames) => {
+            return randomMany([...Array(arrayOfGroupNames.length).keys()], arrayOfGroupNames.length);
+        });
+    }
+}
+const skeletons = [
+    new ProblemSkeleton(`Clara a acheté des ingrédients pour réaliser des pizzas. 
+Elle a pris trois pâtes à pizza à 1,95 € l’unité et deux pots de sauce tomate. 
+Elle a payé au total 8,37 €. 
+Quel est le prix, noté a, d'un pot de sauce ?`, (_group, mysteryVar, groups, shuffleFuncs) => {
+        const { total, ...groupsWithoutTotal } = groups;
+        const [gp1, gp2] = shuffleFuncs[0](Object.values(groupsWithoutTotal));
+        return `Clara a acheté des ingrédients pour réaliser des pizzas. Elle a pris ${gp1.toTex(mysteryVar)} et, dans un autre rayon, ${gp2.toTex(mysteryVar)}. Elle a payé au total $${total
+            .getNode(mysteryVar, groups, shuffleFuncs)
+            .toTex()}$ €. ${mysteryVar.skeleton.question}`;
+    }, (_group, mysteryVar, groups, shuffleFuncs) => {
+        const { pizza, sauce } = groups;
+        const [gp1, gp2] = shuffleFuncs[0]([pizza, sauce]);
+        return new EqualNode(add(gp1.getNode(mysteryVar), gp2.getNode(mysteryVar)), groups.total.getNode(mysteryVar, groups, shuffleFuncs));
+    }, {
+        pizza: new ProblemVarSkeletonGroup({
+            count: {
+                varName: "n",
+                str: "le nombre de pâtes à pizza",
+                question: `Quel est le nombre, noté $n$, de pâtes à pizza ?`,
+                randNode() {
+                    return randint(1, 11, []).toTree();
+                },
+            },
+            price: {
+                varName: "p",
+                str: "le prix d'une pâte à pizza",
+                question: `Quel est le prix, noté $p$, d'une pâte à pizza ?`,
+                randNode() {
+                    return randfloat(0.5, 4, 2, []).toTree();
+                },
+            },
+        }, "le coût pour", (group, mysteryVar) => {
+            switch (mysteryVar?.skeleton.varName) {
+                case "n":
+                    return `des pâtes à pizza à $${group.vars.price.value.toTex()}$ € l’unité`;
+                case "p": {
+                    const isPlural = group.vars.count.value.evaluate() >= 2;
+                    return `$${group.vars.count.value.toTex()}$ ${"pâte" + (isPlural ? "s" : "")} à pizza`;
+                }
+                default: {
+                    const isPlural = group.vars.count.value.evaluate() >= 2;
+                    return `$${group.vars.count.value.toTex()}$ ${"pâte" + (isPlural ? "s" : "")} à pizza à $${group.vars.price.value.toTex()}$ € l’unité`;
+                }
+            }
+        }, (group, mysteryVar) => {
+            const varCount = group.vars.count;
+            const varPrice = group.vars.price;
+            return multiply(varCount === mysteryVar
+                ? varCount.getVarNode()
+                : varCount.getValueNode(), varPrice === mysteryVar
+                ? varPrice.getVarNode()
+                : varPrice.getValueNode());
+        }, true, false),
+        sauce: new ProblemVarSkeletonGroup({
+            count: {
+                varName: "m",
+                str: "le nombre de boîtes de sauce tomate",
+                question: `Quel est le nombre, noté $m$, de boîtes de sauce tomate ?`,
+                randNode() {
+                    return randint(1, 11, []).toTree();
+                },
+            },
+            price: {
+                varName: "s",
+                str: "le prix d'une boîte de sauce",
+                question: `Quel est le prix, noté $s$, d'une boîte de sauce tomate ?`,
+                randNode() {
+                    return randfloat(0.5, 4, 2, []).toTree();
+                },
+            },
+        }, "le coût pour", (group, mysteryVar) => {
+            switch (mysteryVar?.skeleton.varName) {
+                case "m":
+                    return `des boîtes de sauce tomate à $${group.vars.price.value.toTex()}$ € l’unité`;
+                case "s": {
+                    const isPlural = group.vars.count.value.evaluate() >= 2;
+                    return `$${group.vars.count.value.toTex()}$ ${"boîte" + (isPlural ? "s" : "")} de sauce tomate`;
+                }
+                default: {
+                    const isPlural = group.vars.count.value.evaluate() >= 2;
+                    return `$${group.vars.count.value.toTex()}$ ${"boîte" + (isPlural ? "s" : "")} de sauce tomate à $${group.vars.price.value.toTex()}$ € l’unité`;
+                }
+            }
+        }, (group, mysteryVar) => {
+            const varCount = group.vars.count;
+            const varPrice = group.vars.price;
+            return multiply(varCount === mysteryVar
+                ? varCount.getVarNode()
+                : varCount.getValueNode(), varPrice === mysteryVar
+                ? varPrice.getVarNode()
+                : varPrice.getValueNode());
+        }, true, false),
+        total: new ProblemVarSkeletonGroup({
+            total: {
+                varName: "t",
+                str: "le coût total",
+                question: `Quel est le coût total, noté $t$, de ses achats ?`,
+            },
+        }, "le", () => {
+            return "coût total";
+        }, (_group, _mysteryVar, groups, shuffleFuncs) => {
+            const { total, ...groupsWithoutTotal } = groups;
+            const orderedNodes = shuffleFuncs[0](Object.values(groupsWithoutTotal)).map((group) => group.getNode());
+            // console.log(
+            //   "orderedNodes[0].leftChild",
+            //   (orderedNodes[0] as MultiplyNode).leftChild,
+            // );
+            // console.log(
+            //   "isAlgebraicNode((orderedNodes[0] as MultiplyNode).leftChild)",
+            //   isAlgebraicNode((orderedNodes[0] as MultiplyNode).leftChild),
+            // );
+            // console.log(
+            //   "orderedNodes[0].leftChild.evaluate",
+            //   (orderedNodes[0] as MultiplyNode).leftChild.evaluate,
+            // );
+            // console.log("orderedNodes[0].evaluate()", orderedNodes[0].evaluate());
+            // console.log("orderedNodes[1].evaluate()", orderedNodes[1].evaluate());
+            return round(add(orderedNodes[0], orderedNodes[1]).evaluate(), 2).toTree();
+        }, false, true),
+    }, [["pizza", "sauce"]]),
+];
+const getInstruction = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return `${mdTable([[""], [problem.frenchStr]])}
+  
+Parmi les équations suivantes, laquelle modélise cette situation ?`;
+};
+const getHint = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return `${Object.values(problem.groups).map((group) => `Quel est ${group.getScalarString(problem.mysteryVar)} ?`).join(`
+    
+`)}`;
+};
+const getCorrection = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return `On peut former les expressions suivantes: 
+${problem.getExplanationString()}
+
+L'équation qui modélise la situation est donc: 
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getAnswerNode = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return problem.equalNode;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getKeys = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    const arrayOfNodes = problem.getArrayOfUsefulNodes();
+    return [
+        "equal",
+        ...arrayOfNodes.map((node) => {
+            const tex = node.toTex();
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getEquationFromSentenceExerciseQuestion = () => {
+    const problemSkeletonIndex = random([...Array(skeletons.length).keys()]);
+    const problemSkeleton = skeletons[problemSkeletonIndex];
+    const groupNameToVarNameToValue = problemSkeleton.createRandomValuesDict();
+    const mysteryVarPath = problemSkeleton.createRandomMysteryVarPath();
+    const shuffleArrays = problemSkeleton.createRandomShuffleArrays();
+    const problem = ProblemConstructor.byHydratingSkeleton(problemSkeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    const equalNodeIds = problem.equalNode.toIdentifiers();
+    const identifiers = {
+        problemSkeletonIndex,
+        groupNameToVarNameToValue,
+        mysteryVarPath,
+        shuffleArrays,
+        equalNodeIds,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const answerNode = getAnswerNode(identifiers);
+    function nodeByReplacingOperations(node, replacementDict) {
+        if (isOperatorNode(node)) {
+            const leftChild = nodeByReplacingOperations(node.leftChild, replacementDict);
+            const rightChild = nodeByReplacingOperations(node.rightChild, replacementDict);
+            const targetOperatorId = replacementDict[+node.id] ?? node.id;
+            switch (+targetOperatorId) {
+                case OperatorIds.add:
+                    return add(leftChild, rightChild);
+                case OperatorIds.substract:
+                    return substract(leftChild, rightChild);
+                case OperatorIds.multiply:
+                    return multiply(leftChild, rightChild);
+                case OperatorIds.divide:
+                    return frac(leftChild, rightChild);
+                default:
+                    return add(leftChild, rightChild);
+            }
+        }
+        else if (isEqualNode(node)) {
+            const leftChild = nodeByReplacingOperations(node.leftChild, replacementDict);
+            const rightChild = nodeByReplacingOperations(node.rightChild, replacementDict);
+            return new EqualNode(leftChild, rightChild);
+        }
+        else {
+            return node;
+        }
+    }
+    //add everywhere
+    {
+        const wrongEqualNode = nodeByReplacingOperations(answerNode, {
+            [OperatorIds.multiply]: OperatorIds.add,
+            [OperatorIds.substract]: OperatorIds.add,
+            [OperatorIds.divide]: OperatorIds.add,
+        });
+        tryToAddWrongProp(propositions, wrongEqualNode.toTex());
+    }
+    //multiply becomes frac
+    {
+        const wrongEqualNode = nodeByReplacingOperations(answerNode, {
+            [OperatorIds.multiply]: OperatorIds.divide,
+        });
+        tryToAddWrongProp(propositions, wrongEqualNode.toTex());
+    }
+    //l*r = a becomes l = r
+    {
+        const leftChild = answerNode.leftChild;
+        const wrongEqualNode = new EqualNode(leftChild.leftChild, leftChild.rightChild);
+        tryToAddWrongProp(propositions, wrongEqualNode.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const answerNode = getAnswerNode(identifiers); //!TODO: this call crashes but it's a mystery
+    const ansNode = parseLatex(ans);
+    return substract(ansNode, answerNode).evaluate() === 0;
+};
+export const equationFromProblem = {
+    id: "equationFromProblem",
+    label: "Traduire un problème en une équation mathématique",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getEquationFromSentenceExerciseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -14,4 +14,5 @@ export * from "./binomialsTrinomialsProposedSolutions.js";
 export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
+export * from "./equationFromProblem.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./binomialsTrinomialsProposedSolutions.js";
 export * from "./equationWithDistributivity.js";
 export * from "./choseOperationToSolveEquation.js";
 export * from "./factorizeEquation.js";
+export * from "./equationFromProblem.js";

package/lib/exercises/math/calculLitteral/factorisation/factorizeAX2PlusBX.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    isAdd: boolean;
+    varName: string;
+};
+export declare const factorizeAX2PlusBX: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=factorizeAX2PlusBX.d.ts.map

package/lib/exercises/math/calculLitteral/factorisation/factorizeAX2PlusBX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorizeAX2PlusBX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factorizeAX2PlusBX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAmFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factorizeAX2PlusBX.js

@@ -0,0 +1,70 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { a, b, isAdd, varName } = identifiers;
+    const x = varName;
+    return `Laquelle de ces propositions est la forme factorisée de $${a}${x}^2 ${isAdd ? "+" : "-"} ${b}${x}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { varName } = identifiers;
+    return `$${varName}$ semble être le facteur commun.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isAdd, varName } = identifiers;
+    const x = varName;
+    return `Si on factorise par $${x}$ on obtient : 
+  
+$$
+${a}${x}^2 ${isAdd ? "+" : "-"} ${b}${x} = ${x}(${a}${x}${isAdd ? "+" : "-"}${b})
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { a, b, isAdd, varName } = identifiers;
+    const x = varName;
+    const addSub = isAdd ? add : substract;
+    const propositions = [];
+    addValidProp(propositions, `${x}(${a}${x}${isAdd ? "+" : "-"}${b})`, "tex");
+    tryToAddWrongProp(propositions, `(${multiply(a.toTree(), b.toTree()).toTex()})${x}^3`, "tex");
+    tryToAddWrongProp(propositions, `(${addSub(a.toTree(), b.toTree()).toTex()})${x}`, "tex");
+    tryToAddWrongProp(propositions, `(${a}${x}^2${isAdd ? "+" : "-"}${b}${x})${x}^2`, "tex");
+    return shuffleProps(propositions, n);
+};
+const getFactorizeAX2PlusBXQuestion = () => {
+    const [a, b] = randomMany(primes, 2);
+    const varName = random(["x", "y", "z", "t"]);
+    const isAdd = coinFlip();
+    return getQuestionFromIdentifiers({ a, b, isAdd, varName });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const factorizeAX2PlusBX = {
+    id: "factorizeAX2PlusBX",
+    label: "Factoriser $ax^2 + bx$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getFactorizeAX2PlusBXQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -6,4 +6,5 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
+export * from "./factorizeAX2PlusBX.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC"}

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

@@ -6,3 +6,4 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
+export * from "./factorizeAX2PlusBX.js";

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

@@ -5,5 +5,7 @@ export * from "./inequations/index.js";
 export * from "./simplifying/index.js";
 export * from "./systems/index.js";
 export * from "./isolate/index.js";
+export * from "./writing/index.js";
 export * from "./formulas/index.js";
+export * from "./ordering/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calculLitteral/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calculLitteral/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

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

@@ -5,4 +5,6 @@ export * from "./inequations/index.js";
 export * from "./simplifying/index.js";
 export * from "./systems/index.js";
 export * from "./isolate/index.js";
+export * from "./writing/index.js";
 export * from "./formulas/index.js";
+export * from "./ordering/index.js";

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

@@ -1,2 +1,3 @@
-export {};
+export * from "./isolateXInInvXPlusInvYEqualsInvU.js";
+export * from "./isolateUInInvXPlusInvYEqualsInvU.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/isolate/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/isolate/index.ts"],"names":[],"mappings":"AACA,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC"}

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

@@ -1,2 +1,3 @@
-export {};
 // export * from "./isolateVariable.js";
+export * from "./isolateXInInvXPlusInvYEqualsInvU.js";
+export * from "./isolateUInInvXPlusInvYEqualsInvU.js";

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

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

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

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