math-exercises 1.2.8 → 1.2.10

package/{src → lib}/tree/parsers/derivateParser.js

@@ -1,60 +1,60 @@
-"use strict";
-exports.__esModule = true;
-exports.derivateParser = void 0;
-var node_1 = require("../nodes/node");
-var numberNode_1 = require("../nodes/numbers/numberNode");
-var powerNode_1 = require("../nodes/operators/powerNode");
-var addNode_1 = require("../nodes/operators/addNode");
-var fractionNode_1 = require("../nodes/operators/fractionNode");
-var multiplyNode_1 = require("../nodes/operators/multiplyNode");
-var operatorNode_1 = require("../nodes/operators/operatorNode");
-var substractNode_1 = require("../nodes/operators/substractNode");
-var functionNode_1 = require("../nodes/functions/functionNode");
-var sqrtNode_1 = require("../nodes/functions/sqrtNode");
-var oppositeNode_1 = require("../nodes/functions/oppositeNode");
-function derivateParser(node) {
-    if (!node)
-        throw Error("encountered a null node ??");
-    switch (node.type) {
-        case node_1.NodeType.variable:
-            return new numberNode_1.NumberNode(1);
-        case node_1.NodeType.number:
-            return new numberNode_1.NumberNode(0);
-        case node_1.NodeType.operator:
-            var operatorNode = node;
-            var u = operatorNode.leftChild;
-            var v = operatorNode.rightChild;
-            switch (operatorNode.id) {
-                case operatorNode_1.OperatorIds.add:
-                    return new addNode_1.AddNode(derivateParser(u), derivateParser(v));
-                case operatorNode_1.OperatorIds.substract: {
-                    return new substractNode_1.SubstractNode(derivateParser(u), derivateParser(v));
-                }
-                case operatorNode_1.OperatorIds.multiply: {
-                    return new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v)));
-                }
-                case operatorNode_1.OperatorIds.divide:
-                case operatorNode_1.OperatorIds.fraction:
-                    return new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v))), new powerNode_1.PowerNode(v, new numberNode_1.NumberNode(2)));
-                case operatorNode_1.OperatorIds.power: {
-                    var operatorNode_2 = node;
-                    var n = operatorNode_2.rightChild;
-                    var u_1 = operatorNode_2.leftChild;
-                    return new multiplyNode_1.MultiplyNode(n, new multiplyNode_1.MultiplyNode(derivateParser(u_1), new powerNode_1.PowerNode(u_1, new numberNode_1.NumberNode(n.value - 1))));
-                }
-            }
-        case node_1.NodeType["function"]: {
-            var functionNode = node;
-            var child = functionNode.child;
-            switch (functionNode.id) {
-                case functionNode_1.FunctionsIds.sqrt: {
-                    return new fractionNode_1.FractionNode(derivateParser(child), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new sqrtNode_1.SqrtNode(child)));
-                }
-                case functionNode_1.FunctionsIds.opposite: {
-                    return new oppositeNode_1.OppositeNode(derivateParser(child));
-                }
-            }
-        }
-    }
-}
-exports.derivateParser = derivateParser;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derivateParser = void 0;
+const node_1 = require("../nodes/node");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const operatorNode_1 = require("../nodes/operators/operatorNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const functionNode_1 = require("../nodes/functions/functionNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+function derivateParser(node) {
+    if (!node)
+        throw Error("encountered a null node ??");
+    switch (node.type) {
+        case node_1.NodeType.variable:
+            return new numberNode_1.NumberNode(1);
+        case node_1.NodeType.number:
+            return new numberNode_1.NumberNode(0);
+        case node_1.NodeType.operator:
+            const operatorNode = node;
+            const u = operatorNode.leftChild;
+            const v = operatorNode.rightChild;
+            switch (operatorNode.id) {
+                case operatorNode_1.OperatorIds.add:
+                    return new addNode_1.AddNode(derivateParser(u), derivateParser(v));
+                case operatorNode_1.OperatorIds.substract: {
+                    return new substractNode_1.SubstractNode(derivateParser(u), derivateParser(v));
+                }
+                case operatorNode_1.OperatorIds.multiply: {
+                    return new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v)));
+                }
+                case operatorNode_1.OperatorIds.divide:
+                case operatorNode_1.OperatorIds.fraction:
+                    return new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(derivateParser(u), v), new multiplyNode_1.MultiplyNode(u, derivateParser(v))), new powerNode_1.PowerNode(v, new numberNode_1.NumberNode(2)));
+                case operatorNode_1.OperatorIds.power: {
+                    const operatorNode = node;
+                    const n = operatorNode.rightChild;
+                    const u = operatorNode.leftChild;
+                    return new multiplyNode_1.MultiplyNode(n, new multiplyNode_1.MultiplyNode(derivateParser(u), new powerNode_1.PowerNode(u, new numberNode_1.NumberNode(n.value - 1))));
+                }
+            }
+        case node_1.NodeType.function: {
+            const functionNode = node;
+            const child = functionNode.child;
+            switch (functionNode.id) {
+                case functionNode_1.FunctionsIds.sqrt: {
+                    return new fractionNode_1.FractionNode(derivateParser(child), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(2), new sqrtNode_1.SqrtNode(child)));
+                }
+                case functionNode_1.FunctionsIds.opposite: {
+                    return new oppositeNode_1.OppositeNode(derivateParser(child));
+                }
+            }
+        }
+    }
+}
+exports.derivateParser = derivateParser;

package/{src → lib}/tree/parsers/latexParser.js

@@ -1,117 +1,117 @@
-"use strict";
-exports.__esModule = true;
-exports.latexParser = void 0;
-var functionNode_1 = require("../nodes/functions/functionNode");
-var node_1 = require("../nodes/node");
-var operatorNode_1 = require("../nodes/operators/operatorNode");
-function latexParser(node) {
-    if (!node) {
-        console.log("parsing a null node ???");
-        return "";
-    }
-    switch (node.type) {
-        case node_1.NodeType.variable:
-            return node.tex;
-        case node_1.NodeType.number:
-            return node.tex;
-        case node_1.NodeType.operator:
-            var operatorNode = node;
-            var rightTex = latexParser(operatorNode.rightChild);
-            var leftTex = latexParser(operatorNode.leftChild);
-            var leftChild = operatorNode.leftChild, rightChild = operatorNode.rightChild;
-            switch (operatorNode.id) {
-                case operatorNode_1.OperatorIds.add:
-                    return "".concat(leftTex, " ").concat(rightTex[0] === "-" ? "" : "+ ").concat(rightTex);
-                case operatorNode_1.OperatorIds.substract: {
-                    var needBrackets = (rightChild.type === node_1.NodeType.operator &&
-                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
-                        rightTex[0] === "-";
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    return "".concat(leftTex, " - ").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.multiply: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
-                            leftTex = "(".concat(leftTex, ")");
-                    }
-                    var needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    //  permet de gérer le cas 3*2^x
-                    var showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
-                    }
-                    return "".concat(leftTex).concat(showTimesSign ? "\\times " : "").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.divide: {
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
-                            leftTex = "(".concat(leftTex, ")");
-                    }
-                    var needBrackets = rightTex[0] === "-";
-                    if (rightChild.type === node_1.NodeType.operator) {
-                        var operatorRightChild = rightChild;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
-                    }
-                    if (needBrackets)
-                        rightTex = "(".concat(rightTex, ")");
-                    return "".concat(leftTex, " \\div ").concat(rightTex);
-                }
-                case operatorNode_1.OperatorIds.fraction: {
-                    return "\\frac{".concat(leftTex, "}{").concat(rightTex, "}");
-                }
-                case operatorNode_1.OperatorIds.power: {
-                    var needBrackets = leftTex[0] === "-";
-                    if (leftChild.type === node_1.NodeType.operator) {
-                        var childOperator = leftChild;
-                        needBrackets || (needBrackets = [
-                            operatorNode_1.OperatorIds.add,
-                            operatorNode_1.OperatorIds.substract,
-                            operatorNode_1.OperatorIds.multiply,
-                            operatorNode_1.OperatorIds.divide,
-                            operatorNode_1.OperatorIds.fraction,
-                            operatorNode_1.OperatorIds.power,
-                        ].includes(childOperator.id));
-                    }
-                    if (needBrackets)
-                        leftTex = "(".concat(leftTex, ")");
-                    return "".concat(leftTex, "^{").concat(rightTex, "}");
-                }
-                case operatorNode_1.OperatorIds.equal: {
-                    return "".concat(leftTex, " = ").concat(rightTex);
-                }
-                default:
-                    return node.tex;
-            }
-        case node_1.NodeType["function"]: {
-            var functionNode = node;
-            var child = functionNode.child;
-            var childTex = latexParser(functionNode.child);
-            switch (functionNode.id) {
-                case functionNode_1.FunctionsIds.sqrt: {
-                    return "\\sqrt{".concat(childTex, "}");
-                }
-                case functionNode_1.FunctionsIds.opposite: {
-                    var needBrackets = childTex[0] === "-";
-                    if (child.type === node_1.NodeType.operator) {
-                        var operatorChild = child;
-                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
-                    }
-                    if (needBrackets)
-                        childTex = "(".concat(childTex, ")");
-                    return "-".concat(childTex);
-                }
-            }
-        }
-        default:
-            return "";
-    }
-}
-exports.latexParser = latexParser;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latexParser = void 0;
+const functionNode_1 = require("../nodes/functions/functionNode");
+const node_1 = require("../nodes/node");
+const operatorNode_1 = require("../nodes/operators/operatorNode");
+function latexParser(node) {
+    if (!node) {
+        console.log("parsing a null node ???");
+        return "";
+    }
+    switch (node.type) {
+        case node_1.NodeType.variable:
+            return node.tex;
+        case node_1.NodeType.number:
+            return node.tex;
+        case node_1.NodeType.operator:
+            const operatorNode = node;
+            let rightTex = latexParser(operatorNode.rightChild);
+            let leftTex = latexParser(operatorNode.leftChild);
+            const { leftChild, rightChild } = operatorNode;
+            switch (operatorNode.id) {
+                case operatorNode_1.OperatorIds.add:
+                    return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+                case operatorNode_1.OperatorIds.substract: {
+                    const needBrackets = (rightChild.type === node_1.NodeType.operator &&
+                        [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(rightChild.id)) ||
+                        rightTex[0] === "-";
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    return `${leftTex} - ${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.multiply: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(leftChild.id))
+                            leftTex = `(${leftTex})`;
+                    }
+                    let needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    //  permet de gérer le cas 3*2^x
+                    let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === node_1.NodeType.number;
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        showTimesSign || (showTimesSign = [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id));
+                    }
+                    return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.divide: {
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.multiply].includes(leftChild.id))
+                            leftTex = `(${leftTex})`;
+                    }
+                    let needBrackets = rightTex[0] === "-";
+                    if (rightChild.type === node_1.NodeType.operator) {
+                        const operatorRightChild = rightChild;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id));
+                    }
+                    if (needBrackets)
+                        rightTex = `(${rightTex})`;
+                    return `${leftTex} \\div ${rightTex}`;
+                }
+                case operatorNode_1.OperatorIds.fraction: {
+                    return `\\frac{${leftTex}}{${rightTex}}`;
+                }
+                case operatorNode_1.OperatorIds.power: {
+                    let needBrackets = leftTex[0] === "-";
+                    if (leftChild.type === node_1.NodeType.operator) {
+                        const childOperator = leftChild;
+                        needBrackets || (needBrackets = [
+                            operatorNode_1.OperatorIds.add,
+                            operatorNode_1.OperatorIds.substract,
+                            operatorNode_1.OperatorIds.multiply,
+                            operatorNode_1.OperatorIds.divide,
+                            operatorNode_1.OperatorIds.fraction,
+                            operatorNode_1.OperatorIds.power,
+                        ].includes(childOperator.id));
+                    }
+                    if (needBrackets)
+                        leftTex = `(${leftTex})`;
+                    return `${leftTex}^{${rightTex}}`;
+                }
+                case operatorNode_1.OperatorIds.equal: {
+                    return `${leftTex} = ${rightTex}`;
+                }
+                default:
+                    return node.tex;
+            }
+        case node_1.NodeType.function: {
+            const functionNode = node;
+            const child = functionNode.child;
+            let childTex = latexParser(functionNode.child);
+            switch (functionNode.id) {
+                case functionNode_1.FunctionsIds.sqrt: {
+                    return `\\sqrt{${childTex}}`;
+                }
+                case functionNode_1.FunctionsIds.opposite: {
+                    let needBrackets = childTex[0] === "-";
+                    if (child.type === node_1.NodeType.operator) {
+                        const operatorChild = child;
+                        needBrackets || (needBrackets = [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorChild.id));
+                    }
+                    if (needBrackets)
+                        childTex = `(${childTex})`;
+                    return `-${childTex}`;
+                }
+            }
+        }
+        default:
+            return "";
+    }
+}
+exports.latexParser = latexParser;

package/lib/utils/arrayEqual.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayEqual = void 0;
+function arrayEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+exports.arrayEqual = arrayEqual;

package/{src → lib}/utils/coin.js

@@ -1,7 +1,7 @@
-"use strict";
-exports.__esModule = true;
-exports.coin = void 0;
-var coin = function () {
-    return Math.random() < 0.5;
-};
-exports.coin = coin;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coin = void 0;
+const coin = () => {
+    return Math.random() < 0.5;
+};
+exports.coin = coin;

package/{src → lib}/utils/random.js

@@ -1,7 +1,7 @@
-"use strict";
-exports.__esModule = true;
-exports.random = void 0;
-function random(array) {
-    return array[Math.floor(Math.random() * array.length)];
-}
-exports.random = random;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+function random(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+exports.random = random;

package/lib/utils/shuffle.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = void 0;
+/* Randomize array in-place using Durstenfeld shuffle algorithm */
+function shuffle(array) {
+    const res = [...array];
+    for (var i = res.length - 1; i > 0; i--) {
+        var j = Math.floor(Math.random() * (i + 1));
+        var temp = res[i];
+        res[i] = res[j];
+        res[j] = temp;
+    }
+    return res;
+}
+exports.shuffle = shuffle;

package/package.json

@@ -1,28 +1,35 @@
-{
-  "name": "math-exercises",
-  "version": "1.2.8",
-  "description": "Générateurs d'exercices et questions mathématiques en latex",
-  "main": "src/index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start:dev": "nodemon"
-  },
-  "keywords": [],
-  "author": "Heureux Hasard",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^18.11.9",
-    "nodemon": "^2.0.20",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.3"
-  },
-  "dependencies": {},
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/krirkrirk/math-exercices.git"
-  },
-  "bugs": {
-    "url": "https://github.com/krirkrirk/math-exercices/issues"
-  },
-  "homepage": "https://github.com/krirkrirk/math-exercices#readme"
-}
+{
+  "name": "math-exercises",
+  "version": "1.2.10",
+  "description": "Générateurs d'exercices et questions mathématiques en latex",
+  "main": "src/index.js",
+  "files": [
+    "lib/**/*"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start:dev": "nodemon",
+    "build": "tsc",
+    "prepublish": "tsc"
+  },
+  "keywords": [],
+  "author": "Heureux Hasard",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "nodemon": "^2.0.20",
+    "prettier": "^2.8.4",
+    "ts-node": "^10.9.1",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krirkrirk/math-exercices.git"
+  },
+  "bugs": {
+    "url": "https://github.com/krirkrirk/math-exercices/issues"
+  },
+  "homepage": "https://github.com/krirkrirk/math-exercices#readme"
+}

package/nodemon.json

@@ -1,5 +0,0 @@
-{
-  "watch": ["src"],
-  "ext": "ts",
-  "exec": "ts-node ./src/index.ts"
-}

package/src/exercises/calcul/addAndSub.js

@@ -1,40 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.getAddAndSubQuestions = exports.addAndSubExercise = void 0;
-var randint_1 = require("../../mathutils/random/randint");
-var latexParser_1 = require("../../tree/parsers/latexParser");
-var numberNode_1 = require("../../tree/nodes/numbers/numberNode");
-var addNode_1 = require("../../tree/nodes/operators/addNode");
-var getDistinctQuestions_1 = require("../utils/getDistinctQuestions");
-/**
- * a±b±c±d
- */
-exports.addAndSubExercise = {
-    id: "addAndSub",
-    connector: "=",
-    instruction: "Calculer :",
-    label: "Additions et soustractions",
-    levels: ["6", "5"],
-    section: "Calculs",
-    isSingleStep: true,
-    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getAddAndSubQuestions, nb); }
-};
-function getAddAndSubQuestions() {
-    var nbOperations = (0, randint_1.randint)(2, 4);
-    var numbers = [];
-    for (var i = 0; i < nbOperations + 1; i++) {
-        numbers.push((0, randint_1.randint)(-15, 15, [0]));
-    }
-    var allNumbersNodes = numbers.map(function (nb) { return new numberNode_1.NumberNode(nb); });
-    var statementTree = new addNode_1.AddNode(allNumbersNodes[0], allNumbersNodes[1]);
-    for (var i = 2; i < allNumbersNodes.length; i++) {
-        statementTree = new addNode_1.AddNode(statementTree, allNumbersNodes[i]);
-    }
-    var answer = numbers.reduce(function (a, b) { return a + b; }) + "";
-    var question = {
-        startStatement: (0, latexParser_1.latexParser)(statementTree),
-        answer: answer
-    };
-    return question;
-}
-exports.getAddAndSubQuestions = getAddAndSubQuestions;

package/src/exercises/calcul/addAndSub.ts

@@ -1,39 +0,0 @@
-import { randint } from "../../mathutils/random/randint";
-import { latexParser } from "../../tree/parsers/latexParser";
-import { NumberNode } from "../../tree/nodes/numbers/numberNode";
-import { AddNode } from "../../tree/nodes/operators/addNode";
-import { Exercise, Question } from "../exercise";
-import { getDistinctQuestions } from "../utils/getDistinctQuestions";
-
-/**
- * a±b±c±d
- */
-export const addAndSubExercise: Exercise = {
-  id: "addAndSub",
-  connector: "=",
-  instruction: "Calculer :",
-  label: "Additions et soustractions",
-  levels: ["6", "5"],
-  section: "Calculs",
-  isSingleStep: true,
-  generator: (nb: number) => getDistinctQuestions(getAddAndSubQuestions, nb),
-};
-
-export function getAddAndSubQuestions(): Question {
-  const nbOperations = randint(2, 4);
-  const numbers = [];
-  for (let i = 0; i < nbOperations + 1; i++) {
-    numbers.push(randint(-15, 15, [0]));
-  }
-  const allNumbersNodes = numbers.map((nb) => new NumberNode(nb));
-  let statementTree = new AddNode(allNumbersNodes[0], allNumbersNodes[1]);
-  for (let i = 2; i < allNumbersNodes.length; i++) {
-    statementTree = new AddNode(statementTree, allNumbersNodes[i]);
-  }
-  const answer = numbers.reduce((a, b) => a + b) + "";
-  const question: Question = {
-    startStatement: latexParser(statementTree),
-    answer: answer,
-  };
-  return question;
-}

package/src/exercises/calcul/fractions/fractionAndIntegerDivision.js

@@ -1,35 +0,0 @@
-"use strict";
-exports.__esModule = true;
-exports.getFractionAndIntegerDivision = exports.fractionAndIntegerDivision = void 0;
-var randint_1 = require("../../../mathutils/random/randint");
-var integer_1 = require("../../../numbers/integer/integer");
-var rational_1 = require("../../../numbers/rationals/rational");
-var latexParser_1 = require("../../../tree/parsers/latexParser");
-var divideNode_1 = require("../../../tree/nodes/operators/divideNode");
-var random_1 = require("../../../utils/random");
-var getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-exports.fractionAndIntegerDivision = {
-    id: "fractionAndIntegerDivision",
-    connector: "=",
-    instruction: "Calculer la forme irréductible :",
-    label: "Division d'un entier et d'une fraction",
-    levels: ["4", "3", "2", "1"],
-    isSingleStep: false,
-    section: "Fractions",
-    generator: function (nb) { return (0, getDistinctQuestions_1.getDistinctQuestions)(getFractionAndIntegerDivision, nb); }
-};
-function getFractionAndIntegerDivision() {
-    var rational = rational_1.RationalConstructor.randomIrreductible();
-    var integer = new integer_1.Integer((0, randint_1.randint)(-10, 11, [0]));
-    var integerFirst = (0, random_1.random)([0, 1]);
-    var statementTree = integerFirst
-        ? new divideNode_1.DivideNode(integer.toTree(), rational.toTree())
-        : new divideNode_1.DivideNode(rational.toTree(), integer.toTree());
-    var answerTree = integerFirst ? integer.divide(rational).toTree() : rational.divide(integer).toTree();
-    var question = {
-        startStatement: (0, latexParser_1.latexParser)(statementTree),
-        answer: (0, latexParser_1.latexParser)(answerTree)
-    };
-    return question;
-}
-exports.getFractionAndIntegerDivision = getFractionAndIntegerDivision;