math-exercises 1.3.41 → 1.3.42

package/lib/exercises/geometry/cartesian/derivativeNumberReading2.js

@@ -0,0 +1,91 @@
+"use strict";
+/*import { Exercise, Question } from '../../../exercises/exercise';
+import { getDistinctQuestions } from '../../../exercises/utils/getDistinctQuestions';
+import { DroiteConstructor } from '../../../math/geometry/droite';
+import { Point } from '../../../math/geometry/point';
+import { Polynomial } from '../../../math/polynomials/polynomial';
+import { randint } from '../../../math/utils/random/randint';
+import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
+import { evaluate } from 'mathjs';
+
+export const derivativeNumberReading2: Exercise = {
+  id: 'derivativeNumberReading2',
+  connector: '=',
+  instruction: '',
+  label: 'Lecture de nombre dérivé 2',
+  levels: ['3', '2', '1'],
+  isSingleStep: false,
+  section: 'Géométrie cartésienne',
+  generator: (nb: number) => getDistinctQuestions(getDerivativeNumberReading, nb),
+};
+
+export function getDerivativeNumberReading(): Question {
+  function computePolynomial(
+    x0: number,
+    y0: number,
+    m: number,
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number,
+    x3: number,
+    y3: number,
+  ): [number, number, number, number] {
+    const a = (-2 * x0 * x1 * x2 + x0 * x1 * x3 + x0 * x2 * x3 + x1 * x2 * x3) / ((x0 - x1) * (x0 - x2) * (x0 - x3));
+    const b =
+      ((y0 - y1) / ((x0 - x1) * (x0 - x1)) -
+        (y0 - y2) / ((x0 - x2) * (x0 - x2)) +
+        (y0 - y3) / ((x0 - x3) * (x0 - x3))) /
+      (x0 - x1);
+    const c =
+      ((m - 2 * a * x0 - b) * (x0 - x1) * (x0 - x2) * (x0 - x3) -
+        (y0 - y1) / ((x0 - x1) * (x0 - x1)) +
+        a * (x1 * x1 * (x0 - x2) + x2 * x2 * (x0 - x1) - 2 * x1 * x2 * x0) +
+        b * (x1 + x2 - 2 * x0)) /
+      ((x0 - x2) * (x0 - x3));
+    const d = y0 - a * x0 * x0 * x0 - b * x0 * x0 - c * x0;
+    return [a, b, c, d];
+  }
+
+  function generatePolynomial(
+    x0: number,
+    y0: number,
+    m: number,
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number,
+    x3: number,
+    y3: number,
+  ): Polynomial {
+    const [a, b, c, d] = computePolynomial(x0, y0, m, x1, y1, x2, y2, x3, y3);
+    return new Polynomial([d, c, b, a]);
+  }
+
+  const [x1, y1, x2, y2, x3, y3] = [1, 2, 3, 4, 5, 6].map((el) => randint(-5, 6));
+
+  let xA: number, yA, xB, yB: number;
+  let pointA, pointB: Point;
+  do {
+    [xA, yA] = [1, 2].map((el) => randint(-5, 6));
+    xB = xA > 0 ? randint(xA - 4, 6) : randint(-4, xA + 5); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+    pointA = new Point('A', new NumberNode(xA), new NumberNode(yA));
+    pointB = new Point('B', new NumberNode(xB), new NumberNode(yB));
+  } while (xB - xA === 0);
+
+  const droite = DroiteConstructor.fromTwoPoints(pointA, pointB, 'D');
+
+  const polynome = generatePolynomial(xA, yA, evaluate(droite.a.toMathString()), x1, y1, x2, y2, x3, y3);
+
+  let instruction = `$f(x) = ${polynome.toTex()}$, $${pointA.toTexWithCoords()}$, $${pointB.toTexWithCoords()}$, $f'(${xA}) = ${droite.getLeadingCoefficient()}$`;
+
+  const question: Question = {
+    instruction,
+    //startStatement: pointA.toTexWithCoords() + ' ' + pointB.toTexWithCoords(),
+    answer: droite.a.toTex(),
+  };
+
+  return question;
+}
+*/

package/lib/exercises/geometry/cartesian/distanceBetweenTwoPoints.d.ts

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const distanceBetweenTwoPoints: Exercise;
-export declare function getDistanceBetweenTwoPoints(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const distanceBetweenTwoPoints: Exercise;
+export declare function getDistanceBetweenTwoPoints(): Question;
 //# sourceMappingURL=distanceBetweenTwoPoints.d.ts.map

package/lib/exercises/geometry/cartesian/distanceBetweenTwoPoints.js

@@ -1,101 +1,101 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDistanceBetweenTwoPoints = exports.distanceBetweenTwoPoints = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const point_1 = require("../../../math/geometry/point");
-const squareRoot_1 = require("../../../math/numbers/reals/squareRoot");
-const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
-const round_1 = require("../../../math/utils/round");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const shuffle_1 = require("../../../utils/shuffle");
-const uuid_1 = require("uuid");
-exports.distanceBetweenTwoPoints = {
-    id: 'distanceBetweenTwoPoints',
-    connector: '=',
-    instruction: '',
-    label: 'Distance entre deux points',
-    levels: ['2', '1'],
-    isSingleStep: false,
-    section: 'Géométrie cartésienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDistanceBetweenTwoPoints, nb),
-    keys: [],
-};
-function getDistanceBetweenTwoPoints() {
-    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
-    let A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
-    let B = new point_1.Point('B', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
-    const answer = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
-    const getPropositions = (n) => {
-        const res = [];
-        let isDuplicate;
-        let temp = n;
-        res.push({
-            id: (0, uuid_1.v4)() + '',
-            statement: answer,
-            isRightAnswer: true,
-        });
-        temp--;
-        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
-        B = new point_1.Point('B', new numberNode_1.NumberNode(-coords2[0]), new numberNode_1.NumberNode(-coords2[1]));
-        let wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
-        isDuplicate = res.some((p) => p.statement === wrongStatement);
-        if (!isDuplicate) {
-            res.push({
-                id: (0, uuid_1.v4)() + '',
-                statement: wrongStatement,
-                isRightAnswer: false,
-            });
-            temp--;
-        }
-        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[1]), new numberNode_1.NumberNode(coords1[0]));
-        B = new point_1.Point('B', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
-        wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
-        isDuplicate = res.some((p) => p.statement === wrongStatement);
-        if (n > 0 && !isDuplicate) {
-            res.push({
-                id: (0, uuid_1.v4)() + '',
-                statement: wrongStatement,
-                isRightAnswer: false,
-            });
-            temp--;
-        }
-        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords2[0]));
-        B = new point_1.Point('B', new numberNode_1.NumberNode(coords1[1]), new numberNode_1.NumberNode(coords2[1]));
-        wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
-        isDuplicate = res.some((p) => p.statement === wrongStatement);
-        if (n > 0 && !isDuplicate) {
-            res.push({
-                id: (0, uuid_1.v4)() + '',
-                statement: wrongStatement,
-                isRightAnswer: false,
-            });
-            temp--;
-        }
-        for (let i = 0; i < temp; i++) {
-            let proposition;
-            do {
-                const [tempCoords1, tempsCoords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
-                const A = new point_1.Point('A', new numberNode_1.NumberNode(tempCoords1[0]), new numberNode_1.NumberNode(tempCoords1[1]));
-                const B = new point_1.Point('B', new numberNode_1.NumberNode(tempsCoords2[0]), new numberNode_1.NumberNode(tempsCoords2[1]));
-                proposition = {
-                    id: (0, uuid_1.v4)() + '',
-                    statement: new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex(),
-                    isRightAnswer: false,
-                };
-                isDuplicate = res.some((p) => p.statement === proposition.statement);
-            } while (isDuplicate);
-            res.push(proposition);
-            temp--;
-        }
-        return (0, shuffle_1.shuffle)(res);
-    };
-    const question = {
-        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Calculer la distance $AB$.`,
-        startStatement: 'AB',
-        answer,
-        keys: [],
-        getPropositions,
-    };
-    return question;
-}
-exports.getDistanceBetweenTwoPoints = getDistanceBetweenTwoPoints;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDistanceBetweenTwoPoints = exports.distanceBetweenTwoPoints = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const point_1 = require("../../../math/geometry/point");
+const squareRoot_1 = require("../../../math/numbers/reals/squareRoot");
+const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
+const round_1 = require("../../../math/utils/round");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const uuid_1 = require("uuid");
+exports.distanceBetweenTwoPoints = {
+    id: 'distanceBetweenTwoPoints',
+    connector: '=',
+    instruction: '',
+    label: 'Distance entre deux points',
+    levels: ['2', '1'],
+    isSingleStep: false,
+    section: 'Géométrie cartésienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDistanceBetweenTwoPoints, nb),
+    keys: [],
+};
+function getDistanceBetweenTwoPoints() {
+    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
+    let A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+    let B = new point_1.Point('B', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+    const answer = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
+    const getPropositions = (n) => {
+        const res = [];
+        let isDuplicate;
+        let temp = n;
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: answer,
+            isRightAnswer: true,
+        });
+        temp--;
+        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+        B = new point_1.Point('B', new numberNode_1.NumberNode(-coords2[0]), new numberNode_1.NumberNode(-coords2[1]));
+        let wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
+        isDuplicate = res.some((p) => p.statement === wrongStatement);
+        if (!isDuplicate) {
+            res.push({
+                id: (0, uuid_1.v4)() + '',
+                statement: wrongStatement,
+                isRightAnswer: false,
+            });
+            temp--;
+        }
+        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[1]), new numberNode_1.NumberNode(coords1[0]));
+        B = new point_1.Point('B', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+        wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
+        isDuplicate = res.some((p) => p.statement === wrongStatement);
+        if (n > 0 && !isDuplicate) {
+            res.push({
+                id: (0, uuid_1.v4)() + '',
+                statement: wrongStatement,
+                isRightAnswer: false,
+            });
+            temp--;
+        }
+        A = new point_1.Point('A', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords2[0]));
+        B = new point_1.Point('B', new numberNode_1.NumberNode(coords1[1]), new numberNode_1.NumberNode(coords2[1]));
+        wrongStatement = new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex();
+        isDuplicate = res.some((p) => p.statement === wrongStatement);
+        if (n > 0 && !isDuplicate) {
+            res.push({
+                id: (0, uuid_1.v4)() + '',
+                statement: wrongStatement,
+                isRightAnswer: false,
+            });
+            temp--;
+        }
+        for (let i = 0; i < temp; i++) {
+            let proposition;
+            do {
+                const [tempCoords1, tempsCoords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
+                const A = new point_1.Point('A', new numberNode_1.NumberNode(tempCoords1[0]), new numberNode_1.NumberNode(tempCoords1[1]));
+                const B = new point_1.Point('B', new numberNode_1.NumberNode(tempsCoords2[0]), new numberNode_1.NumberNode(tempsCoords2[1]));
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: new squareRoot_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0)).simplify().toTree().toTex(),
+                    isRightAnswer: false,
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+            temp--;
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    const question = {
+        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Calculer la distance $AB$.`,
+        startStatement: 'AB',
+        answer,
+        keys: [],
+        getPropositions,
+    };
+    return question;
+}
+exports.getDistanceBetweenTwoPoints = getDistanceBetweenTwoPoints;

package/lib/exercises/geometry/cartesian/imageFunction.d.ts

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const imageFunction: Exercise;
+export declare function getImageFunction(): Question;
+//# sourceMappingURL=imageFunction.d.ts.map

package/lib/exercises/geometry/cartesian/imageFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/cartesian/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQ3E,eAAO,MAAM,aAAa,EAAE,QAU3B,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,QAAQ,CAkD3C"}

package/lib/exercises/{calculLitteral/equation/evaluateExpression.js → geometry/cartesian/imageFunction.js}

@@ -1,61 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEvaluateExpression = exports.evaluateExpression = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const polynomial_1 = require("../../../math/polynomials/polynomial");
-const randint_1 = require("../../../math/utils/random/randint");
-const coinFlip_1 = require("../../../utils/coinFlip");
-const shuffle_1 = require("../../../utils/shuffle");
-const uuid_1 = require("uuid");
-exports.evaluateExpression = {
-    id: 'evaluateExpression',
-    connector: '=',
-    instruction: '',
-    label: 'Evaluer une expression',
-    levels: ['4', '3', '2'],
-    section: 'Équations',
-    isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEvaluateExpression, nb),
-    keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
-};
-function getEvaluateExpression() {
-    const rand = (0, coinFlip_1.coinFlip)();
-    const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
-    const polynome2 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-4, 5, [0])]);
-    const xValue = (0, randint_1.randint)(-9, 10);
-    const statement = rand
-        ? `Calculer $${polynome1.toTree().toTex()}$ pour x = $${xValue}$`
-        : `Calculer $${polynome2.toTree().toTex()}$ pour x = $${xValue}$`;
-    const answer = rand ? polynome1.calculate(xValue) : polynome2.calculate(xValue);
-    const getPropositions = (n) => {
-        const res = [];
-        res.push({
-            id: (0, uuid_1.v4)() + '',
-            statement: answer + '',
-            isRightAnswer: true,
-        });
-        for (let i = 0; i < n - 1; i++) {
-            let isDuplicate;
-            let proposition;
-            do {
-                const wrongAnswer = answer + (0, randint_1.randint)(-10, 11, [0]);
-                proposition = {
-                    id: (0, uuid_1.v4)() + '',
-                    statement: wrongAnswer + '',
-                    isRightAnswer: false,
-                };
-                isDuplicate = res.some((p) => p.statement === proposition.statement);
-            } while (isDuplicate);
-            res.push(proposition);
-        }
-        return (0, shuffle_1.shuffle)(res);
-    };
-    const question = {
-        instruction: statement,
-        answer: answer + '',
-        keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
-        getPropositions,
-    };
-    return question;
-}
-exports.getEvaluateExpression = getEvaluateExpression;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImageFunction = exports.imageFunction = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const uuid_1 = require("uuid");
+exports.imageFunction = {
+    id: 'imageFunction',
+    connector: '=',
+    instruction: '',
+    label: "Image d'une fonction",
+    levels: ['4', '3', '2'],
+    section: 'Géométrie cartésienne',
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getImageFunction, nb),
+    keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
+};
+function getImageFunction() {
+    const rand = (0, coinFlip_1.coinFlip)();
+    const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+    const polynome2 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-4, 5, [0])]);
+    const xValue = (0, randint_1.randint)(-9, 10);
+    const statement = rand
+        ? `Soit $f(x) = ${polynome1.toTree().toTex()}$. Calculer $f(${xValue})$.`
+        : `Soit $f(x) = ${polynome2.toTree().toTex()}$. Calculer $f(${xValue})$.`;
+    const answer = rand ? polynome1.calculate(xValue) : polynome2.calculate(xValue);
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: answer + '',
+            isRightAnswer: true,
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = answer + (0, randint_1.randint)(-10, 11, [0]);
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: wrongAnswer + '',
+                    isRightAnswer: false,
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    const question = {
+        instruction: statement,
+        startStatement: `f(${xValue})`,
+        answer: answer + '',
+        keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
+        getPropositions,
+    };
+    return question;
+}
+exports.getImageFunction = getImageFunction;

package/lib/exercises/geometry/cartesian/inverseImageFunction.d.ts

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const inverseImageFunction: Exercise;
+export declare function getInverseImageFunction(): Question;
+//# sourceMappingURL=inverseImageFunction.d.ts.map

package/lib/exercises/geometry/cartesian/inverseImageFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inverseImageFunction.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/cartesian/inverseImageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAO3E,eAAO,MAAM,oBAAoB,EAAE,QAUlC,CAAC;AAEF,wBAAgB,uBAAuB,IAAI,QAAQ,CA6ClD"}

package/lib/exercises/geometry/cartesian/inverseImageFunction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInverseImageFunction = exports.inverseImageFunction = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const uuid_1 = require("uuid");
+exports.inverseImageFunction = {
+    id: 'inverseImageFunction',
+    connector: '\\iff',
+    instruction: '',
+    label: "Image d'une fonction",
+    levels: ['4', '3', '2'],
+    section: 'Géométrie cartésienne',
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInverseImageFunction, nb),
+    keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
+};
+function getInverseImageFunction() {
+    const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
+    const xValue = (0, randint_1.randint)(-9, 10);
+    const answer = polynome1.calculate(xValue);
+    const statement = `Soit $f(x) = ${polynome1.toTree().toTex()}$. Calculer x pour $f(x) = ${answer}$.`;
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: xValue + '',
+            isRightAnswer: true,
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = xValue + (0, randint_1.randint)(-10, 11, [0]);
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: wrongAnswer + '',
+                    isRightAnswer: false,
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    const question = {
+        instruction: statement,
+        startStatement: `f(x) = ${answer}`,
+        answer: xValue + '',
+        keys: ['x', 'S', 'equal', 'lbrace', 'rbrace', 'semicolon', 'emptyset'],
+        getPropositions,
+    };
+    return question;
+}
+exports.getInverseImageFunction = getInverseImageFunction;

package/lib/exercises/geometry/cartesian/leadingCoefficient.d.ts

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const leadingCoefficient: Exercise;
-export declare function getLeadingCoefficientQuestion(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const leadingCoefficient: Exercise;
+export declare function getLeadingCoefficientQuestion(): Question;
 //# sourceMappingURL=leadingCoefficient.d.ts.map