math-exercises 2.2.5 → 2.2.6

package/lib/exercises/math/calcul/digitDecimalRankNumber.d.ts

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

package/lib/exercises/math/calcul/digitDecimalRankNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"digitDecimalRankNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/digitDecimalRankNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/calcul/digitDecimalRankNumber.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.digitDecimalRankNumber = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const randint_1 = require("../../../math/utils/random/randint");
+const ordinals = ["premier", "deuxième", "troisième", "quatrième"];
+const getDigitRankNumberQuestion = () => {
+    const decimalPartSize = (0, randint_1.randint)(2, 5);
+    const nb = decimal_1.DecimalConstructor.random(0, 1000, decimalPartSize);
+    const rankAsked = (0, randint_1.randint)(0, Math.min(decimalPartSize, 3));
+    const rankAskedLabel = decimal_1.decimalDigitRanks[rankAsked];
+    const str = nb.tex;
+    const answer = str.split(".")[0] + str.split(".")[1].substring(0, rankAsked + 1);
+    const question = {
+        answer,
+        instruction: `Quel est le nombre de ${rankAskedLabel} dans le nombre $${nb
+            .toTree()
+            .toTex()}$ ?`,
+        keys: [],
+        //   hint: `Attention ! On demande le 'nombre' et non pas le 'chiffre' !`,
+        //   correction: `Le chiffre des ${rankAskedLabel} est le ${ordinals[rankAsked]} chiffre en partant de la droite. Donc le chiffre des ${rankAskedLabel} est $${answer}$.`,
+        answerFormat: "tex",
+        identifiers: { nb: nb.value, rankAsked },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nb, rankAsked }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const str = nb.toString();
+    const [intPart, fracPart] = str.split(".");
+    (0, exercise_1.tryToAddWrongProp)(propositions, fracPart[rankAsked]);
+    for (let i = 0; i < str.length; i++) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, intPart + fracPart.substring(0, i + 1));
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(0, 100) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.digitDecimalRankNumber = {
+    id: "digitDecimalRankNumber",
+    connector: "=",
+    label: "Déterminer le nombre de dixièmes, de centièmes...",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDigitRankNumberQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/digitRankNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"digitRankNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/digitRankNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"digitRankNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/digitRankNumber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/calcul/digitRankNumber.js

@@ -17,8 +17,8 @@ const getDigitRankNumberQuestion = () => {
         answer,
         instruction: `Quel est le nombre ${rankAsked === 0 ? "d'" : "de "}${rankAskedLabel} dans le nombre $${nb.toTree().toTex()}$ ?`,
         keys: [],
-        hint: `Attention ! On demande le 'nombre' et non pas le 'chiffre' !`,
-        correction: `Le chiffre des ${rankAskedLabel} est le ${ordinals[rankAsked]} chiffre en partant de la droite. Donc le chiffre des ${rankAskedLabel} est $${answer}$.`,
+        // hint: `Attention ! On demande le 'nombre' et non pas le 'chiffre' !`,
+        // correction: `Le chiffre des ${rankAskedLabel} est le ${ordinals[rankAsked]} chiffre en partant de la droite. Donc le chiffre des ${rankAskedLabel} est $${answer}$.`,
         answerFormat: "tex",
         identifiers: { nb, rankAsked },
     };
@@ -43,7 +43,7 @@ const isAnswerValid = (ans, { answer }) => {
 exports.digitRankNumber = {
     id: "digitRankNumber",
     connector: "=",
-    label: "Déterminer le rang d'un chiffre dans un nombre entier",
+    label: "Déterminer le nombre d'unités/de dizaines/de centièmes...",
     levels: [],
     isSingleStep: true,
     sections: [],
@@ -53,5 +53,4 @@ exports.digitRankNumber = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calcul/index.d.ts

@@ -9,4 +9,5 @@ export * from "./rounding";
 export * from "./digitRank";
 export * from "./digitDecimalRank";
 export * from "./digitRankNumber";
+export * from "./digitDecimalRankNumber";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/calcul/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./rounding"), exports);
 __exportStar(require("./digitRank"), exports);
 __exportStar(require("./digitDecimalRank"), exports);
 __exportStar(require("./digitRankNumber"), exports);
+__exportStar(require("./digitDecimalRankNumber"), exports);

package/lib/exercises/math/functions/basics/inverseImageFunctionTable.d.ts

@@ -2,6 +2,8 @@ import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
     xValues: number[];
     imageValues: number[];
+    isAskingImage: boolean;
+    value: number;
 };
 export declare const inverseImageFunctionTable: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/basics/inverseImageFunctionTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA8GF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"inverseImageFunctionTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgFF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/functions/basics/inverseImageFunctionTable.js

@@ -3,91 +3,71 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.inverseImageFunctionTable = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randTupleInt_1 = require("../../../../math/utils/random/randTupleInt");
 const randint_1 = require("../../../../math/utils/random/randint");
+const arrayHasSameElement_1 = require("../../../../utils/arrayHasSameElement");
 const coinFlip_1 = require("../../../../utils/coinFlip");
 const random_1 = require("../../../../utils/random");
 const getInverseImageFunctionTableQuestion = () => {
-    const exercise = generateExercise();
-    const instruction = `Ci-dessous est donné le tableau de valeurs d'une fonction $f$. Déterminer ${exercise.isAskingImage ? `l'image de` : `le ou les antécédents de`} $${exercise.questionValue}$ par $f$
-    ${exercise.exoTable.table}`;
+    const xValues = (0, randTupleInt_1.randTupleInt)(5, {
+        from: -10,
+        to: 10,
+        allDifferent: true,
+    }).sort((a, b) => a - b);
+    const yValues = (0, randTupleInt_1.randTupleInt)(5, { from: -10, to: 10 });
+    let indexAsked = (0, randint_1.randint)(0, 5);
+    const valueAsked = xValues[indexAsked];
+    //on force un meme nombre dans les deux lignes pour complexifier
+    if (!yValues.includes(valueAsked) || yValues[indexAsked] === valueAsked) {
+        yValues[(0, randint_1.randint)(0, 5, [indexAsked])] = valueAsked;
+    }
+    const isAskingImage = (0, coinFlip_1.coinFlip)();
+    const answer = (isAskingImage
+        ? yValues[indexAsked]
+        : xValues
+            .filter((el, index) => yValues[index] === valueAsked)
+            .join("\\text{ et }")) + "";
+    const instruction = `Ci-dessous est donné le tableau de valeurs d'une fonction $f$. Déterminer ${isAskingImage ? `l'image de` : `le ou les antécédents de`} $${valueAsked}$ par $f$.
+
+  |$x$|${xValues.map((value) => `$${value}$`).join("|")}|
+  |-|-|-|-|-|-|
+  |$f(x)$|${yValues.map((value) => `$${value}$`).join("|")}|
+`;
     const question = {
-        answer: `${exercise.answer}`,
+        answer,
         instruction,
-        keys: ["x", "equal"],
+        keys: ["et"],
         answerFormat: "tex",
         style: { tableHasNoHeader: true },
         identifiers: {
-            xValues: exercise.exoTable.xValues,
-            imageValues: exercise.exoTable.imageValues,
+            xValues,
+            imageValues: yValues,
+            isAskingImage,
+            value: valueAsked,
         },
     };
     return question;
 };
-const getPropositions = (n, { answer, xValues, imageValues }) => {
+const getPropositions = (n, { answer, xValues, imageValues, isAskingImage, value }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    generatePropositions(xValues, imageValues, answer).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    if (isAskingImage) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, xValues[imageValues.indexOf(value)] + "");
+    }
+    else {
+        (0, exercise_1.tryToAddWrongProp)(propositions, imageValues[xValues.indexOf(value)] + "");
+    }
     while (propositions.length < n) {
-        let randProp = (0, randint_1.randint)(+answer - 10, +answer + 11, [+answer]);
-        (0, exercise_1.tryToAddWrongProp)(propositions, randProp + "");
+        (0, exercise_1.tryToAddWrongProp)(propositions, ((0, coinFlip_1.coinFlip)() ? (0, random_1.random)(xValues) : (0, random_1.random)(imageValues)) + "");
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return [ans, ans.split("=")[1]].includes(answer);
-};
-const generateTable = (f) => {
-    const xValues = generateXValues();
-    const imageValues = xValues.map((value) => f.calculate(value));
-    return {
-        xValues,
-        imageValues,
-        table: `
-  |$x$|${xValues
-            .map((value) => `$${value}$`)
-            .reduce((prev, curr) => prev + "|" + curr)}|
-  |-|-|-|-|-|-|
-  |$f(x)$|${imageValues
-            .map((value) => `$${value}$`)
-            .reduce((prev, curr) => prev + "|" + curr)}|
-  `,
-    };
-};
-const generateXValues = () => {
-    const xValues = [];
-    for (let i = 0; i < 5; i++) {
-        let value;
-        do {
-            value = (0, randint_1.randint)(-11, 11);
-        } while (xValues.includes(value));
-        xValues.push(value);
-    }
-    xValues.sort((a, b) => {
-        return a - b;
-    });
-    return xValues;
-};
-const generateExercise = () => {
-    const polynom = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
-    const exoTable = generateTable(polynom);
-    const isAskingImage = (0, coinFlip_1.coinFlip)();
-    const questionValue = isAskingImage
-        ? (0, random_1.random)(exoTable.xValues)
-        : (0, random_1.random)(exoTable.imageValues);
-    const answer = isAskingImage
-        ? polynom.calculate(questionValue)
-        : exoTable.xValues.find((value, index) => exoTable.imageValues[index] === questionValue);
-    return { polynom, exoTable, isAskingImage, questionValue, answer };
-};
-const generatePropositions = (xValues, imageValues, answer) => {
-    const filteredXValues = xValues.filter((value) => value !== +answer);
-    const firstProp = (0, random_1.random)(filteredXValues);
-    const secondProp = (0, random_1.random)(filteredXValues
-        .concat(imageValues)
-        .filter((value) => ![firstProp, +answer].includes(value)));
-    const thirdProp = (0, random_1.random)(imageValues.filter((value) => value !== secondProp));
-    return [firstProp + "", secondProp + "", thirdProp + ""];
+const isAnswerValid = (ans, { answer, xValues, imageValues, isAskingImage, value }) => {
+    const numbers = ans.split("\\text{ et }").map((el) => Number(el));
+    if (numbers.some((n) => isNaN(n)))
+        return false;
+    const answerNumbers = answer.split("\\text{ et }").map((el) => Number(el));
+    return ans === answer || (0, arrayHasSameElement_1.arrayHasSameElements)(numbers, answerNumbers);
 };
 exports.inverseImageFunctionTable = {
     id: "inverseImageFunctionTable",

package/lib/exercises/math/probaStat/probaFromTableNoContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAkHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAmHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/math/probaStat/probaFromTableNoContext.js

@@ -62,10 +62,11 @@ const getProbaFromTableNoContextQuestion = () => {
         answer,
         instruction: `On considère deux événements $A$ et $B$. Le tableau suivant donne le nombre d'issues pour chacun des événements $A\\cap B$, $\\overline A\\cap B$, $A\\cap \\overline B$ et $\\overline A \\cap \\overline B$. Calculer la probabilité $${event}$.
     
-| | $B$ | $\\overline{B}$|
-|-|-|-|
-|$A$|${aCapB}|${aCapBBarre}|
-|$\\overline{A}$|${aBarreCapB}|${aBarreCapBBarre}|
+| | $B$ | $\\overline{B}$| Total
+|-|-|-|-|
+|$A$|${aCapB}|${aCapBBarre}|${aTotal}|
+|$\\overline{A}$|${aBarreCapB}|${aBarreCapBBarre}|${aBarreTotal}|
+|Total|${bTotal}|${bBarreTotal}|${total}|
     
     `,
         keys: [],

package/lib/index.d.ts

@@ -148,6 +148,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     nb: number;
     rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -597,6 +600,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     imageValues: number[];
+    isAskingImage: boolean;
+    value: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/utils/random/randTupleInt.d.ts

@@ -2,6 +2,7 @@ interface randTupleIntOptions {
     from: number;
     to?: number;
     excludes?: number[];
+    allDifferent?: boolean;
 }
 /**
  * @param size tuple length

package/lib/math/utils/random/randTupleInt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randTupleInt.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randTupleInt.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,SAAU,MAAM,WAAW,mBAAmB,KAAG,MAAM,EAM/E,CAAC;AAEF,eAAO,MAAM,oBAAoB,OAAQ,MAAM,QAAQ,MAAM,WAAW,mBAAmB,KAAG,MAAM,EAAE,EAUrG,CAAC"}
+{"version":3,"file":"randTupleInt.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/random/randTupleInt.ts"],"names":[],"mappings":"AAGA,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,eAAO,MAAM,YAAY,SACjB,MAAM,WACH,mBAAmB,KAC3B,MAAM,EAUR,CAAC;AAEF,eAAO,MAAM,oBAAoB,OAC3B,MAAM,QACJ,MAAM,WACH,mBAAmB,KAC3B,MAAM,EAAE,EAUV,CAAC"}

package/lib/math/utils/random/randTupleInt.js

@@ -11,7 +11,11 @@ const randint_1 = require("./randint");
 const randTupleInt = (size, options) => {
     const res = [];
     for (let i = 0; i < size; i++) {
-        res.push((0, randint_1.randint)(options.from, options.to, options.excludes));
+        let x;
+        do {
+            x = (0, randint_1.randint)(options.from, options.to, options.excludes);
+        } while (options.allDifferent && res.includes(x));
+        res.push(x);
     }
     return res;
 };

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU,YAgBtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,UAAU,YAgBtB,CAAC"}

package/lib/playground.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const affine_1 = require("./math/polynomials/affine");
+const randTupleInt_1 = require("./math/utils/random/randTupleInt");
 const addNode_1 = require("./tree/nodes/operators/addNode");
 const multiplyNode_1 = require("./tree/nodes/operators/multiplyNode");
 const random_1 = require("./utils/random");
@@ -14,6 +15,6 @@ const playground = () => {
     ];
     const operation = (0, random_1.random)(["add", "substract"]);
     const statementTree = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()));
-    console.log(statementTree.simplify().toTex());
+    console.log((0, randTupleInt_1.distinctRandTupleInt)(3, 2, { from: 1, to: 10 }));
 };
 exports.playground = playground;

package/lib/server.js

@@ -37,6 +37,7 @@ const numberNode_1 = require("./tree/nodes/numbers/numberNode");
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
 const variableNode_1 = require("./tree/nodes/variables/variableNode");
+const playground_1 = require("./playground");
 const jsonParser = body_parser_1.default.json();
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
@@ -65,7 +66,7 @@ const runServer = () => {
     console.log("math exos", mathExercises.length);
     console.log("math hints", mathExercises.filter((exo) => exo.hasHintAndCorrection).length);
     console.log("pc exos", pcExercises.length);
-    // playground();
+    (0, playground_1.playground)();
     app.get("/", (req, res) => {
         res.json(allExercises);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.5",
+  "version": "2.2.6",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [