math-exercises 3.0.149 → 3.0.151

package/lib/exercises/math/scratch/scratchOperations1.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers;
+};
+export declare const scratchOperations1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchOperations1.d.ts.map

package/lib/exercises/math/scratch/scratchOperations1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchOperations1.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchOperations1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4F7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AA+JF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/scratch/scratchOperations1.js

@@ -0,0 +1,245 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, } 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 { round } from "../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../tree/nodes/operators/divideNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { NodeShuffler } from "../../../tree/utilities/nodeShuffler.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const createRandomNode = (depth) => {
+    let nodeX;
+    let nodeY;
+    if (depth === 0) {
+        return randint(1, 10).toTree();
+    }
+    else {
+        const depthLeft = randint(0, depth);
+        const depthRight = depth - 1 - depthLeft;
+        [nodeX, nodeY] = [depthLeft, depthRight].map((depthChild) => createRandomNode(depthChild));
+    }
+    return random([add, substract, multiply, divide])(nodeX, nodeY);
+};
+const getStrScratchblocks = (node) => {
+    if (isOperatorNode(node)) {
+        const nodeOperator = node;
+        const strScratchOperator = (() => {
+            switch (nodeOperator.id) {
+                case OperatorIds.add:
+                    return "+";
+                case OperatorIds.substract:
+                    return "-";
+                case OperatorIds.multiply:
+                    return "*";
+                case OperatorIds.divide:
+                    return "/";
+                default:
+                    throw new Error("unsupported id: " + nodeOperator.id);
+            }
+        })();
+        const [strLeft, strRight] = [
+            nodeOperator.leftChild,
+            nodeOperator.rightChild,
+        ].map((nodeChild) => {
+            return getStrScratchblocks(nodeChild);
+        });
+        return `(${strLeft}${strScratchOperator}${strRight})`;
+    }
+    else if (isNumberNode(node)) {
+        return `(${node.value.frenchify()})`;
+    }
+    else {
+        throw new Error("unsupported nodeType: " + node.type);
+    }
+};
+const getTexWithParentheses = (node) => {
+    if (isOperatorNode(node)) {
+        const nodeOperator = node;
+        const strScratchOperator = (() => {
+            switch (nodeOperator.id) {
+                case OperatorIds.add:
+                    return "+";
+                case OperatorIds.substract:
+                    return "-";
+                case OperatorIds.multiply:
+                    return "\\times";
+                case OperatorIds.divide:
+                    return "\\div";
+                default:
+                    throw new Error("unsupported id: " + nodeOperator.id);
+            }
+        })();
+        const [strLeft, strRight] = [
+            nodeOperator.leftChild,
+            nodeOperator.rightChild,
+        ].map((nodeChild) => {
+            return getTexWithParentheses(nodeChild);
+        });
+        return `\\left(${strLeft} \\ ${strScratchOperator} \\ ${strRight}\\right)`;
+    }
+    else if (isNumberNode(node)) {
+        return `${node.value.frenchify()}`;
+    }
+    else {
+        throw new Error("unsupported nodeType: " + node.type);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(nodeIds);
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à ${getStrScratchblocks(node)}
+</svg>
+
+Quelle est la valeur de la variable $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { nodeIds } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //convenience: store last step in -1
+        outDict[-1] = NodeConstructor.fromIdentifiers(nodeIds).evaluate();
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return dictSteps[-1].frenchify();
+};
+const getHint = () => {
+    return `Calcule en commençant par les blocs les plus internes.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(nodeIds);
+    const nodeSimplified = node.simplify();
+    const texAnswer = nodeSimplified.toTex();
+    return `Le bloc d'opérations correspond à l'expression :
+
+$$
+${getTexWithParentheses(node)}
+$$
+
+On évalue l'expression en commençant par les parenthèses les plus intérieures.
+
+La valeur de cette expression est $${texAnswer}$.
+
+À la fin de l'exécution du programme, $x$ vaut $${texAnswer}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const node = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
+    {
+        let counter = -1;
+        while (counter < 10) {
+            counter++;
+            const nodeDeepShuffled = NodeShuffler.deepShuffle(node, {
+                nodeTypesToShuffle: [
+                    "AddNode",
+                    "SubstractNode",
+                    "MultiplyNode",
+                    "DivideNode",
+                ],
+                nodeTypesNoFurther: [],
+            });
+            //add if no division by zero
+            try {
+                //check if explodes
+                {
+                    nodeDeepShuffled.evaluate();
+                }
+                const identifiersWrong = Object.assign({}, identifiers, {
+                    nodeIds: nodeDeepShuffled.toIdentifiers(),
+                });
+                tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+            }
+            catch (_) {
+                (() => { })();
+            }
+        }
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-59, 60).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScratchOperations1Question = () => {
+    const depth = randint(3, 5);
+    let node;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        node = createRandomNode(depth);
+        try {
+            {
+                node.simplify(); //may explode
+            }
+            const value = node.evaluate(); //may explode
+            const isInteger = () => round(value, 0) === value;
+            const isNotTooBig = () => Math.abs(value) < 60;
+            isValid = isInteger() && isNotTooBig();
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    if (!isValid) {
+        const nodeDefault = add(add(3, multiply(7, substract(3, 5))), 3);
+        node = nodeDefault;
+    }
+    const identifiers = {
+        nodeIds: node.toIdentifiers(),
+    };
+    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 scratchOperations1 = {
+    id: "scratchOperations1",
+    connector: "=",
+    label: "Calculer avec des priorités en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchOperations1Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/scratchOperations2.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    dictVars: Record<string, number>;
+    varNameDst: string;
+    nodeIds: NodeIdentifiers;
+};
+export declare const scratchOperations2: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchOperations2.d.ts.map

package/lib/exercises/math/scratch/scratchOperations2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchOperations2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchOperations2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4I7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAoOF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/scratch/scratchOperations2.js

@@ -0,0 +1,324 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { nodeBySubstitutingVar } from "../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode, } from "../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../tree/nodes/operators/divideNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { isVariableNode, } from "../../../tree/nodes/variables/variableNode.js";
+import { NodeShuffler } from "../../../tree/utilities/nodeShuffler.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getSetOfVarNames = (node) => {
+    if (isOperatorNode(node)) {
+        return new Set([node.leftChild, node.rightChild].flatMap((nodeChild) => [
+            ...getSetOfVarNames(nodeChild),
+        ]));
+    }
+    else if (isVariableNode(node)) {
+        return new Set([node.name]);
+    }
+    else {
+        return new Set([]);
+    }
+};
+const getSetOfNumbers = (node) => {
+    if (isOperatorNode(node)) {
+        return new Set([node.leftChild, node.rightChild].flatMap((nodeChild) => [
+            ...getSetOfNumbers(nodeChild),
+        ]));
+    }
+    else if (isNumberNode(node)) {
+        return new Set([node.value]);
+    }
+    else {
+        return new Set([]);
+    }
+};
+const createRandomNode = (depth, varNodes) => {
+    let nodeX;
+    let nodeY;
+    if (depth === 0) {
+        if (coinFlip()) {
+            return random(varNodes);
+        }
+        else {
+            return randint(1, 10).toTree();
+        }
+    }
+    else {
+        const depthLeft = randint(0, depth);
+        const depthRight = depth - 1 - depthLeft;
+        [nodeX, nodeY] = [depthLeft, depthRight].map((depthChild) => createRandomNode(depthChild, varNodes));
+    }
+    return random([add, substract, multiply, divide])(nodeX, nodeY);
+};
+const getStrScratchblocks = (node) => {
+    if (isOperatorNode(node)) {
+        const nodeOperator = node;
+        const strScratchOperator = (() => {
+            switch (nodeOperator.id) {
+                case OperatorIds.add:
+                    return "+";
+                case OperatorIds.substract:
+                    return "-";
+                case OperatorIds.multiply:
+                    return "*";
+                case OperatorIds.divide:
+                    return "/";
+                default:
+                    throw new Error("unsupported id: " + nodeOperator.id);
+            }
+        })();
+        const [strLeft, strRight] = [
+            nodeOperator.leftChild,
+            nodeOperator.rightChild,
+        ].map((nodeChild) => {
+            return getStrScratchblocks(nodeChild);
+        });
+        return `(${strLeft}${strScratchOperator}${strRight})`;
+    }
+    else if (isNumberNode(node)) {
+        return `(${node.value.frenchify()})`;
+    }
+    else if (isVariableNode(node)) {
+        return `(${node.name})`;
+    }
+    else {
+        throw new Error("unsupported nodeType: " + node.type);
+    }
+};
+const getTexWithParentheses = (node) => {
+    if (isOperatorNode(node)) {
+        const nodeOperator = node;
+        const strScratchOperator = (() => {
+            switch (nodeOperator.id) {
+                case OperatorIds.add:
+                    return "+";
+                case OperatorIds.substract:
+                    return "-";
+                case OperatorIds.multiply:
+                    return "\\times";
+                case OperatorIds.divide:
+                    return "\\div";
+                default:
+                    throw new Error("unsupported id: " + nodeOperator.id);
+            }
+        })();
+        const [strLeft, strRight] = [
+            nodeOperator.leftChild,
+            nodeOperator.rightChild,
+        ].map((nodeChild) => {
+            return getTexWithParentheses(nodeChild);
+        });
+        return `\\left(${strLeft} \\ ${strScratchOperator} \\ ${strRight}\\right)`;
+    }
+    else if (isNumberNode(node)) {
+        return `${node.value.frenchify()}`;
+    }
+    else if (isVariableNode(node)) {
+        return `${node.name}`;
+    }
+    else {
+        throw new Error("unsupported nodeType: " + node.type);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { dictVars, varNameDst, nodeIds } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(nodeIds);
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+${Object.entries(dictVars).map(([varName, value]) => `mettre [${varName} v] à (${value.frenchify()})`).join(`
+`)}
+mettre [${varNameDst} v] à ${getStrScratchblocks(node)}
+</svg>
+
+Quelle est la valeur de la variable $${varNameDst}$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { dictVars, nodeIds } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //convenience: store last step in -1
+        outDict[-1] = NodeConstructor.fromIdentifiers(nodeIds).evaluate(dictVars);
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return dictSteps[-1].frenchify();
+};
+const getHint = () => {
+    return `Calcule en commençant par les blocs les plus internes. Substitue chaque variable par sa valeur pour faire le calcul.`;
+};
+const getCorrection = (identifiers) => {
+    const { dictVars, varNameDst, nodeIds } = identifiers;
+    const node = NodeConstructor.fromIdentifiers(nodeIds);
+    const nodeSubstituted = Object.entries(dictVars).reduce((acc, [varName, value]) => {
+        const nodeBySub = nodeBySubstitutingVar(acc, value.toTree(), varName.toTree());
+        return nodeBySub;
+    }, node);
+    const nodeSimplified = nodeSubstituted.simplify();
+    const texAnswer = nodeSimplified.toTex();
+    return `Le bloc d'opérations correspond à l'expression :
+
+$$
+${getTexWithParentheses(node)}
+$$
+
+Après substitution des variables par leur valeur, on a :
+
+$$
+${getTexWithParentheses(nodeSubstituted)}
+$$
+
+On évalue l'expression en commençant par les parenthèses les plus intérieures.
+
+La valeur de cette expression est $${texAnswer}$.
+
+À la fin de l'exécution du programme, $${varNameDst}$ vaut $${texAnswer}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const node = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
+    {
+        let counter = -1;
+        while (counter < 10) {
+            counter++;
+            const nodeDeepShuffled = NodeShuffler.deepShuffle(node, {
+                nodeTypesToShuffle: [
+                    "AddNode",
+                    "SubstractNode",
+                    "MultiplyNode",
+                    "DivideNode",
+                ],
+                nodeTypesNoFurther: [],
+            });
+            //add if no division by zero
+            try {
+                //check if explodes
+                {
+                    nodeDeepShuffled.evaluate();
+                }
+                const identifiersWrong = Object.assign({}, identifiers, {
+                    nodeIds: nodeDeepShuffled.toIdentifiers(),
+                });
+                tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+            }
+            catch (_) {
+                (() => { })();
+            }
+        }
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-59, 60).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["x", "y", "z"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScratchOperations2Question = () => {
+    const varNames = ["x", "y", "z"];
+    const indexDst = randint(0, varNames.length);
+    let dictVars = Object.fromEntries(varNames
+        .filter((_, i) => i !== indexDst)
+        .map((varName) => [varName, randint(1, 10)]));
+    const depth = randint(3, 5);
+    let node;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        node = createRandomNode(depth, [...Object.keys(dictVars)].map((varName) => varName.toTree()));
+        const isContainingVars = () => [...getSetOfVarNames(node)].length > 0;
+        const isContainingNumbers = () => [...getSetOfNumbers(node)].length > 0;
+        if (isContainingVars() && isContainingNumbers()) {
+            try {
+                //sometimes, doing computation step by step can prevent algebraic simplification which would allow complete evaluation
+                //expl: 9 div (1 div y-y)
+                {
+                    const nodeSubstituted = Object.entries(dictVars).reduce((acc, [varName, value]) => {
+                        const nodeBySub = nodeBySubstitutingVar(acc, value.toTree(), varName.toTree());
+                        return nodeBySub;
+                    }, node);
+                    nodeSubstituted.simplify(); //may explode
+                }
+                const value = node.evaluate(dictVars); //may explode
+                const isInteger = () => round(value, 0) === value;
+                const isNotTooBig = () => Math.abs(value) < 60;
+                isValid = isInteger() && isNotTooBig();
+            }
+            catch (_) {
+                (() => { })();
+            }
+        }
+        else {
+            isValid = false;
+        }
+    }
+    if (!isValid) {
+        const [nodeA, nodeB] = [1, 8].map((v) => v.toTree());
+        dictVars = Object.fromEntries(varNames
+            .filter((_, i) => i !== indexDst)
+            .map((varName, k) => [
+            varName,
+            [nodeA, nodeB].map((node) => node.value)[k],
+        ]));
+        const nodeDefault = add(add(nodeB, multiply(7, substract(3, nodeA))), nodeA);
+        node = nodeDefault;
+    }
+    const identifiers = {
+        dictVars,
+        varNameDst: varNames[indexDst],
+        nodeIds: node.toIdentifiers(),
+    };
+    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 scratchOperations2 = {
+    id: "scratchOperations2",
+    connector: "=",
+    label: "Calculer avec des priorités et des variables en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchOperations2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/scratchPrintXY.d.ts

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

package/lib/exercises/math/scratch/scratchPrintXY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchPrintXY.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchPrintXY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAmMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}