math-exercises 2.1.24 → 2.1.26

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

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    value1: number;
+    reason: number;
+    rank1: number;
+};
+export declare const geometricFindReason: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFindReason.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindReason.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0CF,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,WAAW,CAYzD,CAAC"}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricFindReason = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getGeometricFindReason = () => {
+    const rank1 = (0, randint_1.randint)(0, 10);
+    const rank2 = rank1 + 1;
+    const reason = (0, randint_1.randint)(2, 10);
+    const value1 = (0, randint_1.randint)(1, 10);
+    const value2 = reason * value1;
+    const answer = reason.toString();
+    const question = {
+        instruction: `$(u_n)$ est une suite géométrique. On sait que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. Quelle est la raison de la suite $(u_n)$ ?`,
+        startStatement: "q",
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { value1, rank1, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, value1, rank1, reason }) => {
+    const value2 = reason * value1;
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (value2 - value1 !== 2)
+        (0, exercise_1.tryToAddWrongProp)(propositions, value2 - value1 + "");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, Number(answer) + (0, randint_1.randint)(1, 10) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.geometricFindReason = {
+    id: "geometricFindReason",
+    connector: "=",
+    label: "Déterminer la raison d'une suite géométrique",
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricFindReason, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    raison: number;
+    final: number;
+};
+export declare const geometricFirstTermsSum: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFirstTermsSum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2CF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAqB5D,CAAC"}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricFirstTermsSum = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getGeometricFirstTermsSumQuestion = () => {
+    const raison = (0, randint_1.randint)(2, 8);
+    const final = (0, randint_1.randint)(5, 10);
+    const answer = (raison ** (final + 1) - 1) / (raison - 1) + "";
+    const question = {
+        answer: answer,
+        instruction: `Calculer la somme suivante : $1 + ${raison} + ${raison}^2 + \\ldots + ${raison}^{${final}}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { raison, final },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, raison, final }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (raison ** (final + 1) - 1).toString());
+    (0, exercise_1.tryToAddWrongProp)(propositions, ((raison ** final - 1) / (raison - 1)).toString());
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(1000, 10000) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.geometricFirstTermsSum = {
+    id: "geometricFirstTermsSum",
+    connector: "=",
+    label: "Somme des termes d'une suite géométrique",
+    levels: [
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermSpé",
+        "TermTech",
+    ],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricFirstTermsSumQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    reason: number;
+    startRank: number;
+    startValue: number;
+};
+export declare const geometricReasonUsage: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricReasonUsage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8CF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAY1D,CAAC"}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricReasonUsage = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getGeometricReasonUsage = () => {
+    const reason = (0, randint_1.randint)(2, 10);
+    const startRank = (0, randint_1.randint)(0, 20);
+    const askedRank = startRank + 1;
+    const startValue = (0, randint_1.randint)(1, 10);
+    const answer = (startValue * reason).toString();
+    const question = {
+        instruction: `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`,
+        startStatement: `u_{${askedRank}}`,
+        answer,
+        keys: ["u", "underscore", "equal"],
+        answerFormat: "tex",
+        identifiers: { startValue, reason, startRank },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, startValue, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (startValue + reason !== 4)
+        (0, exercise_1.tryToAddWrongProp)(propositions, (startValue + reason).toString());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, startValue * (reason + (0, randint_1.randint)(-reason + 1, 6, [0])) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer, startRank }) => {
+    return [
+        answer,
+        `u_{${startRank}}=${answer}`,
+        `u_${startRank}=${answer}`,
+    ].includes(ans);
+};
+exports.geometricReasonUsage = {
+    id: "geometricReasonUsage",
+    connector: "=",
+    label: "Utiliser la raison d'une suite géométrique",
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricReasonUsage, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    firstValue: number;
+    reason: number;
+    firstRank: number;
+};
+export declare const geometricRecurrenceFormulaUsage: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricRecurrenceFormulaUsage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkDF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricRecurrenceFormulaUsage = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getGeometricRecurrenceFormulaUsage = () => {
+    const firstRank = (0, randint_1.randint)(1, 20);
+    const firstValue = (0, randint_1.randint)(1, 10);
+    const reason = (0, randint_1.randint)(2, 10);
+    const askedRank = firstRank + 1;
+    const answer = (firstValue * reason).toString();
+    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,
+        keys: ["u", "underscore", "equal"],
+        answerFormat: "tex",
+        identifiers: { firstValue, reason, firstRank },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, firstValue, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    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])) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer, firstRank }) => {
+    return [
+        answer,
+        `u_{${firstRank + 1}}=${answer}`,
+        `u_${firstRank + 1}=${answer}`,
+    ].includes(ans);
+    return ans === answer;
+};
+exports.geometricRecurrenceFormulaUsage = {
+    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"],
+    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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recurrenceFormulaUsage = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+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 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 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: ["u", "underscore", "equal"],
+        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) + "");
+    while (propositions.length < n) {
+        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, rank }) => {
+    return [answer, `u_{${rank}}=${answer}`, `u_${rank}=${answer}`].includes(ans);
+};
+exports.recurrenceFormulaUsage = {
+    id: "recurrenceFormulaUsage",
+    connector: "=",
+    label: "Utiliser la formule de récurrence d'une suite",
+    levels: ["1reESM", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    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

@@ -0,0 +1,11 @@
+import { MathExercise } from "../../../exercises/exercise";
+import { ClosureType } from "../../../tree/nodes/sets/closure";
+type Identifiers = {
+    isIntervalToInequality: boolean;
+    intervalMin: number;
+    intervalMax: number;
+    intervalClosure: ClosureType;
+};
+export declare const inequalityToInterval: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=inequalityToInterval.d.ts.map

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

@@ -0,0 +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;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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",
+        identifiers: {
+            isIntervalToInequality: isIntervalToInequality,
+            intervalMin: interval.min,
+            intervalMax: interval.max,
+            intervalClosure: interval.closure,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isIntervalToInequality, intervalClosure, intervalMax, intervalMin }) => {
+    const reverseBracket = (bracket) => {
+        return bracket === "[" ? "]" : "[";
+    };
+    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";
+    };
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const xNode = new variableNode_1.VariableNode("x");
+    if (isIntervalToInequality) {
+        let wrongIneqs = [];
+        if (interval.min === -Infinity) {
+            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) {
+            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 {
+            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 {
+        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);
+        });
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, isIntervalToInequality }) => {
+    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure).toTree();
+    console.log("int", interval.toTex());
+    const inequality = interval.toInequality();
+    const answer = isIntervalToInequality
+        ? inequality
+        : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
+            allowRawRightChildAsSolution: true,
+        });
+    console.log("ans", answer);
+    const texs = answer.toAllValidTexs();
+    console.log("texs", texs);
+    return texs.includes(ans);
+};
+exports.inequalityToInterval = {
+    id: "inequalityToInterval",
+    connector: "=",
+    label: "Traduire une inégalité en intervalle",
+    levels: ["2ndPro", "2nde", "CAP", "1reESM"],
+    isSingleStep: true,
+    sections: ["Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getInequalityToIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1 @@
+//# sourceMappingURL=intervalBelonging.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intervalBelonging.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sets/intervals/intervalBelonging.ts"],"names":[],"mappings":""}