math-exercises 2.0.0 → 2.0.2

package/lib/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.js

@@ -14,10 +14,10 @@ const getGeometricRecurrenceFormulaUsage = () => {
     const question = {
         instruction: `$(u_n)$ est une suite définie par $u_{n+1} = ${reason}\\times u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`,
         startStatement: `u_{${askedRank}}`,
-        answer: (firstValue * reason).toString(),
-        keys: ['q', 'n', 'u', 'underscore'],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, firstValue, reason },
+        answer,
+        keys: ["q", "n", "u", "underscore"],
+        answerFormat: "tex",
+        identifiers: { firstValue, reason, firstRank },
     };
     return question;
 };
@@ -27,19 +27,23 @@ const getPropositions = (n, { answer, firstValue, reason }) => {
     if (firstValue + reason !== 4)
         (0, exercise_1.tryToAddWrongProp)(propositions, (firstValue + reason).toString());
     while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, firstValue * (reason + (0, randint_1.randint)(-reason + 1, 6, [0])) + '');
+        (0, exercise_1.tryToAddWrongProp)(propositions, firstValue * (reason + (0, randint_1.randint)(-reason + 1, 6, [0])) + "");
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
 exports.geometricRecurrenceFormulaUsage = {
-    id: 'geometricRecurrenceFormulaUsage',
-    connector: '=',
+    id: "geometricRecurrenceFormulaUsage",
+    connector: "=",
     label: "Utiliser la formule de récurrence d'une suite géométrique",
-    levels: ['1reESM', '1reSpé', '1reTech', '1rePro', 'TermTech', 'TermPro'],
-    sections: ['Suites'],
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
     isSingleStep: false,
     qcmTimer: 60,
     freeTimer: 60,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricRecurrenceFormulaUsage, nb),
     getPropositions,
+    isAnswerValid,
 };

package/lib/exercises/sequences/geometric/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./geometricExplicitFormulaUsage";
+export * from "./geometricFindExplicitFormula";
+export * from "./geometricFindReason";
+export * from "./geometricFirstTermsSum";
+export * from "./geometricReasonUsage";
+export * from "./geometricRecurrenceFormulaUsage";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/sequences/geometric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC"}

package/lib/exercises/sequences/geometric/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./geometricExplicitFormulaUsage"), exports);
+__exportStar(require("./geometricFindExplicitFormula"), exports);
+__exportStar(require("./geometricFindReason"), exports);
+__exportStar(require("./geometricFirstTermsSum"), exports);
+__exportStar(require("./geometricReasonUsage"), exports);
+__exportStar(require("./geometricRecurrenceFormulaUsage"), exports);

package/lib/exercises/sequences/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./arithmetic";
+export * from "./geometric";
+export * from "./explicitFormulaUsage";
+export * from "./genericSequenceVariations";
+export * from "./recurrenceFormulaUsage";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/sequences/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC"}

package/lib/exercises/sequences/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arithmetic"), exports);
+__exportStar(require("./geometric"), exports);
+__exportStar(require("./explicitFormulaUsage"), exports);
+__exportStar(require("./genericSequenceVariations"), exports);
+__exportStar(require("./recurrenceFormulaUsage"), exports);

package/lib/exercises/sequences/recurrenceFormulaUsage.d.ts

@@ -1,11 +1,9 @@
-import { MathExercise } from '../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
     rank: number;
     u0: number;
     coeffs: number[];
 };
-type VEAProps = {};
-export declare const recurrenceFormulaUsage: MathExercise<QCMProps, VEAProps>;
+export declare const recurrenceFormulaUsage: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=recurrenceFormulaUsage.d.ts.map

package/lib/exercises/sequences/recurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../src/exercises/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAuCnB,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWnE,CAAC"}
+{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../src/exercises/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA8CF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/sequences/recurrenceFormulaUsage.js

@@ -7,45 +7,49 @@ const polynomial_1 = require("../../math/polynomials/polynomial");
 const randint_1 = require("../../math/utils/random/randint");
 const getRecurrenceFormulaUsageQuestion = () => {
     const coeffs = [(0, randint_1.randint)(-5, 6), (0, randint_1.randint)(-5, 6), (0, randint_1.randint)(-3, 4, [0])];
-    const u = new polynomial_1.Polynomial(coeffs, 'u_n');
+    const u = new polynomial_1.Polynomial(coeffs, "u_n");
     const u0 = (0, randint_1.randint)(-2, 3, [0]);
     const rank = (0, randint_1.randint)(1, 4);
     let currentValue = u0;
     for (let i = 0; i < rank; i++) {
         currentValue = u.calculate(currentValue);
     }
-    const answer = currentValue + '';
+    const answer = currentValue + "";
     const question = {
         answer,
         instruction: `Soit $u$ la suite définie par $u_0 = ${u0}$ et pour tout $n\\geq 1$, $u_{n+1} = ${u
             .toTree()
             .toTex()}$. Calculer $u_${rank}$.`,
         keys: [],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, rank, u0, coeffs },
+        answerFormat: "tex",
+        identifiers: { rank, u0, coeffs },
     };
     return question;
 };
 const getPropositions = (n, { answer, rank, u0, coeffs }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const u = new polynomial_1.Polynomial(coeffs, 'u_n');
-    (0, exercise_1.tryToAddWrongProp)(propositions, u.calculate(rank) + '');
+    const u = new polynomial_1.Polynomial(coeffs, "u_n");
+    (0, exercise_1.tryToAddWrongProp)(propositions, u.calculate(rank) + "");
     while (propositions.length < n) {
-        const wrongAnswer = (0, randint_1.randint)(-100, 100) + '';
+        const wrongAnswer = (0, randint_1.randint)(-100, 100) + "";
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
 exports.recurrenceFormulaUsage = {
-    id: 'recurrenceFormulaUsage',
-    connector: '=',
+    id: "recurrenceFormulaUsage",
+    connector: "=",
     label: "Utiliser la formule de récurrence d'une suite",
-    levels: ['1reESM', '1reSpé', '1reTech'],
+    levels: ["1reESM", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ['Suites'],
+    sections: ["Suites"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecurrenceFormulaUsageQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
+    isAnswerValid,
 };

package/lib/exercises/sets/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./intervals";
+export * from "./setBelonging";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/sets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}

package/lib/exercises/sets/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./intervals"), exports);
+__exportStar(require("./setBelonging"), exports);

package/lib/exercises/sets/intervals/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./inequalityToInterval";
+export * from "./intervalsIntersection";
+export * from "./intervalsUnion";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/sets/intervals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/sets/intervals/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./inequalityToInterval"), exports);
+__exportStar(require("./intervalsIntersection"), exports);
+__exportStar(require("./intervalsUnion"), exports);

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts

@@ -1,10 +1,8 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
     isIntervalToInequality: boolean;
     intervalTex: string;
 };
-type VEAProps = {};
-export declare const inequalityToInterval: MathExercise<QCMProps, VEAProps>;
+export declare const inequalityToInterval: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=inequalityToInterval.d.ts.map

package/lib/exercises/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AA2BlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA+DnB,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWjE,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAkBlC,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmKF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/sets/intervals/inequalityToInterval.js

@@ -4,95 +4,142 @@ exports.inequalityToInterval = void 0;
 const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../math/sets/intervals/intervals");
+const inequationNode_1 = require("../../../tree/nodes/inequations/inequationNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const belongsNode_1 = require("../../../tree/nodes/sets/belongsNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const shuffle_1 = require("../../../utils/shuffle");
 const getInequalityToIntervalQuestion = () => {
     const isIntervalToInequality = (0, coinFlip_1.coinFlip)();
     const interval = intervals_1.IntervalConstructor.random();
     const inequalityString = interval.toInequality();
-    const answer = isIntervalToInequality ? inequalityString : `x\\in${interval.toTex()}`;
+    const answer = isIntervalToInequality
+        ? inequalityString
+        : `x\\in${interval.toTex()}`;
     const instruction = isIntervalToInequality
         ? `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`
         : `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
     const question = {
         answer,
         instruction: instruction,
-        keys: ['x', 'belongs', 'inf', 'sup', 'geq', 'leq', 'lbracket', 'rbracket', 'semicolon', 'infty'],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, isIntervalToInequality: isIntervalToInequality, intervalTex: interval.tex },
+        keys: [
+            "x",
+            "belongs",
+            "inf",
+            "sup",
+            "geq",
+            "leq",
+            "lbracket",
+            "rbracket",
+            "semicolon",
+            "infty",
+        ],
+        answerFormat: "tex",
+        identifiers: {
+            isIntervalToInequality: isIntervalToInequality,
+            intervalTex: interval.tex,
+        },
     };
     return question;
 };
 const getPropositions = (n, { answer, isIntervalToInequality, intervalTex }) => {
     const reverseBracket = (bracket) => {
-        return bracket === '[' ? ']' : '[';
+        return bracket === "[" ? "]" : "[";
     };
-    const switchInequality = (symbol) => {
-        if (symbol === '\\le')
-            return '<';
-        if (symbol === '<')
-            return '\\le';
-        if (symbol === '>')
-            return '\\ge';
-        return '>';
+    const switchInclusion = (symbol) => {
+        if (symbol === "\\le")
+            return "<";
+        if (symbol === "<")
+            return "\\le";
+        if (symbol === ">")
+            return "\\ge";
+        return ">";
     };
     const reverseInequality = (symbol) => {
-        if (symbol === '\\le')
-            return '\\ge';
-        if (symbol === '<')
-            return '>';
-        if (symbol === '>')
-            return '<';
-        return '\\le';
+        if (symbol === "\\le")
+            return "\\ge";
+        if (symbol === "<")
+            return ">";
+        if (symbol === ">")
+            return "<";
+        return "\\le";
     };
     const interval = new intervals_1.Interval(intervalTex);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    let wrongStatements = [];
+    const xNode = new variableNode_1.VariableNode("x");
     if (isIntervalToInequality) {
+        let wrongIneqs = [];
         if (interval.min === -Infinity) {
-            wrongStatements = [
-                `x${switchInequality(interval.rightInequalitySymbol)}${interval.maxTex}`,
-                `-\\infty\\le x${switchInequality(interval.rightInequalitySymbol)}${interval.maxTex}`,
-                `-\\infty <x${switchInequality(interval.rightInequalitySymbol)}${interval.maxTex}`,
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], switchInclusion(interval.rightInequalitySymbol)),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(switchInclusion(interval.rightInequalitySymbol))),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(interval.rightInequalitySymbol)),
             ];
         }
         else if (interval.max === Infinity) {
-            wrongStatements = [
-                `x ${switchInequality(reverseInequality(interval.leftInequalitySymbol))} ${interval.minTex}`,
-                `${interval.minTex} ${switchInequality(interval.leftInequalitySymbol)} x \\le +\\infty`,
-                `${interval.minTex} ${switchInequality(interval.leftInequalitySymbol)} x \\le +\\infty`,
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], switchInclusion(interval.leftInequalitySymbol)),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(switchInclusion(interval.leftInequalitySymbol))),
+                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(interval.leftInequalitySymbol)),
             ];
         }
         else {
-            wrongStatements = [
-                `${interval.minTex} ${switchInequality(interval.leftInequalitySymbol)} x ${interval.rightInequalitySymbol} ${interval.maxTex}`,
-                `${interval.minTex} ${interval.leftInequalitySymbol} x ${switchInequality(interval.rightInequalitySymbol)} ${interval.maxTex}`,
-                `${interval.minTex} ${switchInequality(interval.leftInequalitySymbol)} x ${switchInequality(interval.rightInequalitySymbol)} ${interval.maxTex}`,
+            wrongIneqs = [
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    switchInclusion(interval.leftInequalitySymbol),
+                    interval.rightInequalitySymbol,
+                ]),
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    interval.leftInequalitySymbol,
+                    switchInclusion(interval.rightInequalitySymbol),
+                ]),
+                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
+                    switchInclusion(interval.leftInequalitySymbol),
+                    switchInclusion(interval.rightInequalitySymbol),
+                ]),
             ];
         }
+        wrongIneqs.forEach((ineq) => {
+            (0, exercise_1.addWrongProp)(propositions, ineq.toTex());
+        });
     }
     else {
-        wrongStatements = [
-            `x \\in ${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
-            `x \\in ${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
-            `x \\in ${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+        const wrongStatements = [
+            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
+            `x\\in${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
         ];
+        wrongStatements.forEach((ineq) => {
+            (0, exercise_1.addWrongProp)(propositions, ineq);
+        });
     }
-    wrongStatements.forEach((statement) => {
-        (0, exercise_1.addWrongProp)(propositions, statement);
-    });
     return (0, shuffle_1.shuffle)(propositions);
 };
+const isAnswerValid = (ans, { intervalTex, isIntervalToInequality }) => {
+    const interval = new intervals_1.Interval(intervalTex).toTree();
+    console.log(interval.toTex());
+    const inequality = interval.toInequality();
+    const answer = isIntervalToInequality
+        ? inequality
+        : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
+            allowRawRightChildAsSolution: true,
+        });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
 exports.inequalityToInterval = {
-    id: 'inequalityToInterval',
-    connector: '=',
-    label: 'Traduire une inégalité en intervalle',
-    levels: ['2ndPro', '2nde', 'CAP', '1reESM'],
+    id: "inequalityToInterval",
+    connector: "=",
+    label: "Traduire une inégalité en intervalle",
+    levels: ["2ndPro", "2nde", "CAP", "1reESM"],
     isSingleStep: true,
-    sections: ['Ensembles et intervalles'],
+    sections: ["Ensembles et intervalles"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInequalityToIntervalQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
+    isAnswerValid,
 };

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts

@@ -1,10 +1,8 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
     int1Tex: string;
     int2Tex: string;
 };
-type VEAProps = {};
-export declare const intervalsIntersection: MathExercise<QCMProps, VEAProps>;
+export declare const intervalsIntersection: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=intervalsIntersection.d.ts.map

package/lib/exercises/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAqBlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAiBnB,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWlE,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/sets/intervals/intervalsIntersection.js

@@ -12,9 +12,17 @@ const getIntervalsIntersectionQuestion = () => {
     const question = {
         answer,
         instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
-        keys: ['infty', 'emptyset', 'lbracket', 'rbracket', 'semicolon', 'cup', 'cap'],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, int1Tex: int1.tex, int2Tex: int2.tex },
+        keys: [
+            "infty",
+            "emptyset",
+            "lbracket",
+            "rbracket",
+            "semicolon",
+            "cup",
+            "cap",
+        ],
+        answerFormat: "tex",
+        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
     };
     return question;
 };
@@ -30,15 +38,19 @@ const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
 exports.intervalsIntersection = {
-    id: 'intervalsIntersection',
-    connector: '=',
+    id: "intervalsIntersection",
+    connector: "=",
     label: "Déterminer l'intersection de deux intervalles",
-    levels: ['2nde', '1reESM'],
+    levels: ["2nde", "1reESM"],
     isSingleStep: true,
-    sections: ['Ensembles et intervalles'],
+    sections: ["Ensembles et intervalles"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalsIntersectionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
+    isAnswerValid,
 };

package/lib/exercises/sets/intervals/intervalsUnion.d.ts

@@ -1,10 +1,8 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
     int1Tex: string;
     int2Tex: string;
 };
-type VEAProps = {};
-export declare const intervalsUnion: MathExercise<QCMProps, VEAProps>;
+export declare const intervalsUnion: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=intervalsUnion.d.ts.map

package/lib/exercises/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAkClC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAEnB,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW3D,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsCF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/sets/intervals/intervalsUnion.js

@@ -12,9 +12,9 @@ const getIntervalsUnionQuestion = () => {
     const question = {
         answer,
         instruction: `Soit $I = ${int1.tex}$ et $J = ${int2.tex}$. Déterminer $I\\cup J$.`,
-        keys: ['infty', 'lbracket', 'rbracket', 'semicolon', 'cup', 'cap'],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, int1Tex: int1.tex, int2Tex: int2.tex },
+        keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
+        answerFormat: "tex",
+        identifiers: { int1Tex: int1.tex, int2Tex: int2.tex },
     };
     return question;
 };
@@ -30,15 +30,19 @@ const getPropositions = (n, { answer, int1Tex, int2Tex }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
 exports.intervalsUnion = {
-    id: 'intervalsUnion',
-    connector: '=',
+    id: "intervalsUnion",
+    connector: "=",
     label: "Déterminer l'union de deux intervalles",
-    levels: ['2nde', '2ndPro', '1reTech', 'CAP'],
+    levels: ["2nde", "2ndPro", "1reTech", "CAP"],
     isSingleStep: true,
-    sections: ['Ensembles et intervalles'],
+    sections: ["Ensembles et intervalles"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIntervalsUnionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
+    isAnswerValid,
 };

package/lib/exercises/sets/setBelonging.d.ts

@@ -1,8 +1,8 @@
-import { MathExercise } from '../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    type: number;
+    nb: string;
 };
-type VEAProps = {};
-export declare const setBelonging: MathExercise<QCMProps, VEAProps>;
+export declare const setBelonging: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=setBelonging.d.ts.map

package/lib/exercises/sets/setBelonging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setBelonging.d.ts","sourceRoot":"","sources":["../../../src/exercises/sets/setBelonging.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA0DnB,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWzD,CAAC"}
+{"version":3,"file":"setBelonging.d.ts","sourceRoot":"","sources":["../../../src/exercises/sets/setBelonging.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuEF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAYlD,CAAC"}