math-exercises 2.2.17 → 2.2.18

package/lib/exercises/exercise.d.ts

@@ -14,7 +14,7 @@ export type Proposition = {
 export type GeogebraAxisOptions = {
     steps?: number;
     hiddden?: boolean;
-    showNumbers?: boolean;
+    hideNumbers?: boolean;
     label?: string;
     natural?: boolean;
 };

package/lib/exercises/math/calcul/decimals/multiplyDecimalByNegativeTens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyDecimalByNegativeTens.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/multiplyDecimalByNegativeTens.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAgDF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"multiplyDecimalByNegativeTens.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/multiplyDecimalByNegativeTens.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA6DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

package/lib/exercises/math/calcul/decimals/multiplyDecimalByNegativeTens.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const decimal_1 = require("../../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../../math/utils/random/randint");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const pluralize_1 = require("../../../../utils/strings/pluralize");
 const getMultiplyDecimalByNegativeTensQuestion = () => {
     const dec = decimal_1.DecimalConstructor.random(1, 200, (0, randint_1.randint)(1, 5));
     const pow = -(0, randint_1.randint)(1, 4);
@@ -18,6 +19,13 @@ const getMultiplyDecimalByNegativeTensQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { dec: dec.value, pow },
+        hint: `Multiplier par $${factor.frenchify()}$ revient à déplacer la virgule de $${-pow}$ ${(0, pluralize_1.pluralize)("position", -pow)} vers la gauche.`,
+        correction: `On déplace la virgule de $${-pow}$ ${(0, pluralize_1.pluralize)("position", -pow)} vers la gauche : 
+    
+$$
+${statement.toTex()} = ${answer}
+$$
+    `,
     };
     return question;
 };
@@ -50,4 +58,5 @@ exports.multiplyDecimalByNegativeTens = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calcul/decimals/multiplyDecimalByTens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyDecimalByTens.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/multiplyDecimalByTens.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAsDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"multiplyDecimalByTens.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/multiplyDecimalByTens.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAqEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/calcul/decimals/multiplyDecimalByTens.js

@@ -8,6 +8,7 @@ const randint_1 = require("../../../../math/utils/random/randint");
 const divideNode_1 = require("../../../../tree/nodes/operators/divideNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const coinFlip_1 = require("../../../../utils/coinFlip");
+const pluralize_1 = require("../../../../utils/strings/pluralize");
 const getMultiplyDecimalByTensQuestion = () => {
     const dec = decimal_1.DecimalConstructor.random(1, 200, (0, randint_1.randint)(1, 5));
     const pow = (0, randint_1.randint)(1, 4);
@@ -24,6 +25,13 @@ const getMultiplyDecimalByTensQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { dec: dec.value, pow, isDivide },
+        hint: `${isDivide ? "Diviser" : "Multiplier"} par $${factor.frenchify()}$ revient à déplacer la virgule de $${pow}$ ${(0, pluralize_1.pluralize)("position", pow)} vers la ${isDivide ? "gauche" : "droite"}.`,
+        correction: `On déplace la virgule de $${pow}$ ${(0, pluralize_1.pluralize)("position", pow)} vers la ${isDivide ? "gauche" : "droite"} : 
+    
+$$
+${statement.toTex()} = ${answer}
+$$
+    `,
     };
     return question;
 };
@@ -60,4 +68,5 @@ exports.multiplyDecimalByTens = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calcul/operations/expressionNature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expressionNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/expressionNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAoLnE,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"expressionNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/expressionNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,GAAG,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAoLnE,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}

package/lib/exercises/math/calcul/operations/expressionNature.js

@@ -178,4 +178,5 @@ exports.expressionNature = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/decimalOrderingNoRelatives.d.ts

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

package/lib/exercises/math/calcul/ordering/decimalOrderingNoRelatives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimalOrderingNoRelatives.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/decimalOrderingNoRelatives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAgE1D,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

package/lib/exercises/math/calcul/ordering/decimalOrderingNoRelatives.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimalOrderingNoRelatives = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const getDecimalOrderingNoRelativesQuestion = () => {
+    const type = (0, randint_1.randint)(1, 5);
+    let a = 0;
+    let b = 0;
+    while (b == a) {
+        switch (type) {
+            case 1:
+                //x vs x.y
+                a = (0, randint_1.randint)(0, 100);
+                b = (0, randfloat_1.randfloat)(Math.floor(a), Math.floor(a) + 1, (0, randint_1.randint)(1, 3));
+                break;
+            case 2:
+                //x.y vs x.y
+                a = (0, randfloat_1.randfloat)(0, 100, 1);
+                b = (0, randfloat_1.randfloat)(Math.floor(a), Math.floor(a) + 1, 1);
+                break;
+            case 3:
+                //x.yy vs x.yy
+                a = (0, randfloat_1.randfloat)(0, 100, 2);
+                b = (0, randfloat_1.randfloat)(Math.floor(a), Math.floor(a) + 1, 2);
+                break;
+            case 4:
+            default:
+                //x.yy vs x ou x.y
+                a = (0, randfloat_1.randfloat)(0, 100, 2);
+                b = (0, coinFlip_1.coinFlip)()
+                    ? Math.floor(a)
+                    : (0, randfloat_1.randfloat)(Math.floor(a), Math.floor(a) + 1, 1);
+                break;
+        }
+    }
+    const answer = a < b ? "<" : a === b ? "=" : ">";
+    const question = {
+        answer,
+        instruction: `Compléter par le bon symbole : 
+    
+$$${a.frenchify()}\\ ...... \\ ${b.frenchify()}$$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, a, b },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "<");
+    (0, exercise_1.tryToAddWrongProp)(propositions, ">");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "=");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.decimalOrderingNoRelatives = {
+    id: "decimalOrderingNoRelatives",
+    connector: "\\iff",
+    label: "Comparer des nombres décimaux (sans relatifs)",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDecimalOrderingNoRelativesQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    answerType: "QCU",
+};

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

@@ -1,4 +1,5 @@
 export * from "./integerOrdering";
 export * from "./decimalOrdering";
 export * from "./framing";
+export * from "./decimalOrderingNoRelatives";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,8BAA8B,CAAC"}

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./integerOrdering"), exports);
 __exportStar(require("./decimalOrdering"), exports);
 __exportStar(require("./framing"), exports);
+__exportStar(require("./decimalOrderingNoRelatives"), exports);

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

@@ -19,7 +19,7 @@ const getImageFunction = () => {
     const flip = (0, coinFlip_1.coinFlip)();
     const statement = `Soit $f(x) = ${(rand ? polynome1 : polynome2)
         .toTree()
-        .toTex()}. Calculer ${flip ? `l'image de $${xValue}$ par $f$.` : `$f(${xValue})$.`}`;
+        .toTex()}$. Calculer ${flip ? `l'image de $${xValue}$ par $f$.` : `$f(${xValue})$.`}`;
     const answer = rand
         ? polynome1.calculate(xValue) + ""
         : polynome2.calculate(xValue) + "";

package/lib/exercises/math/geometry/areas/triangleArea.js

@@ -7,7 +7,7 @@ const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor"
 const triangles_1 = require("../../../../math/geometry/triangles");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../../math/utils/random/randint");
-const randomLetter_1 = require("../../../../utils/randomLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getTriangleArea = () => {
     const vertices = [];

package/lib/exercises/math/geometry/cartesian/index.d.ts

@@ -6,4 +6,5 @@ export * from "./directionVector";
 export * from "./directionVectorEquation";
 export * from "./drawAlineInGGB";
 export * from "./placeAPoint";
+export * from "./pointCoordinatesNoAxisNumbers";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/cartesian/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/geometry/cartesian/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./directionVector"), exports);
 __exportStar(require("./directionVectorEquation"), exports);
 __exportStar(require("./drawAlineInGGB"), exports);
 __exportStar(require("./placeAPoint"), exports);
+__exportStar(require("./pointCoordinatesNoAxisNumbers"), exports);
+// export * from "./pointCoordinatesNoOrthonorm";

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoAxisNumbers.d.ts

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

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoAxisNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointCoordinatesNoAxisNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/pointCoordinatesNoAxisNumbers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoAxisNumbers.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointCoordinatesNoAxisNumbers = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const point_1 = require("../../../../math/geometry/point");
+const randint_1 = require("../../../../math/utils/random/randint");
+const getPointCoordinatesNoAxisNumbersQuestion = () => {
+    const x = (0, randint_1.randint)(-10, 10);
+    const y = (0, randint_1.randint)(-10, 10);
+    let xMin = x - 2;
+    let xMax = x + 2;
+    let yMin = y - 2;
+    let yMax = y + 2;
+    yMax = yMax < 2 ? 2 : yMax;
+    yMin = yMin > -2 ? -2 : yMin;
+    xMin = xMin > -2 ? -2 : xMin;
+    xMax = xMax < 2 ? 2 : xMax;
+    const instruction = `Lire les coordonnées du point $A$ représenté dans le repère ci-dessous : `;
+    const commands = [
+        `A = (${x}, ${y})`,
+        `ShowLabel(A, true)`,
+        // `SetPointStyle(A, 0)`,
+        `SetPointSize(A, 4)`,
+        `SetFixed(A, true)`,
+        "O = (0,0)",
+        `SetFixed(O, true)`,
+        `ShowLabel(O, true)`,
+        `SetPointSize(O, 4)`,
+        "I = (1,0)",
+        `SetFixed(I, true)`,
+        `ShowLabel(I, true)`,
+        `SetPointSize(I, 4)`,
+        "J = (0,1)",
+        `SetFixed(J, true)`,
+        `ShowLabel(J, true)`,
+        `SetPointSize(J, 4)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    const A = new point_1.Point("A", x.toTree(), y.toTree());
+    const question = {
+        answer: A.toCoords(),
+        instruction,
+        ggbOptions: ggb.getOptions({
+            coords: ggb.getAdaptedCoords({
+                xMin,
+                xMax,
+                yMin,
+                yMax,
+                forceShowAxes: true,
+            }),
+        }),
+        keys: ["x", "y", "semicolon"],
+        answerFormat: "tex",
+        identifiers: { x, y },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, x, y }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const points = [
+        new point_1.Point("A", (x + 1).toTree(), (y + 1).toTree()),
+        new point_1.Point("A", (x - 1).toTree(), (y - 1).toTree()),
+        new point_1.Point("A", (x - 1).toTree(), (y + 1).toTree()),
+        new point_1.Point("A", (x + 1).toTree(), (x - 1).toTree()),
+    ];
+    points.forEach((point) => (0, exercise_1.tryToAddWrongProp)(propositions, point.toCoords()));
+    while (propositions.length < n) {
+        const wrongAnswer = new point_1.Point("A", (0, randint_1.randint)(-10, 10).toTree(), (0, randint_1.randint)(-10, 10).toTree());
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toCoords(), "tex");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, x, y }) => {
+    const valid = new point_1.Point("A", x.toTree(), y.toTree()).toCoords();
+    return ans === valid;
+};
+exports.pointCoordinatesNoAxisNumbers = {
+    id: "pointCoordinatesNoAxisNumbers",
+    label: "Lire les coordonnées d'un point (sans nombres sur les axes)",
+    levels: ["1rePro"],
+    isSingleStep: true,
+    sections: ["Géométrie cartésienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointCoordinatesNoAxisNumbersQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+};

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoOrthonorm.d.ts

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

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoOrthonorm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointCoordinatesNoOrthonorm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/pointCoordinatesNoOrthonorm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}

package/lib/exercises/math/geometry/cartesian/pointCoordinatesNoOrthonorm.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointCoordinatesNoOrthonorm = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const point_1 = require("../../../../math/geometry/point");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/random");
+const getPointCoordinatesNoAxisNumbersQuestion = () => {
+    const x = (0, randint_1.randint)(-10, 10);
+    const y = (0, randint_1.randint)(-10, 10);
+    let xMin = x - 2;
+    let xMax = x + 2;
+    let yMin = y - 2;
+    let yMax = y + 2;
+    yMax = yMax < 2 ? 2 : yMax;
+    yMin = yMin > -2 ? -2 : yMin;
+    xMin = xMin > -2 ? -2 : xMin;
+    xMax = xMax < 2 ? 2 : xMax;
+    const instruction = `Lire les coordonnées du point $A$ représenté dans le repère ci-dessous : `;
+    const commands = [
+        `A = (${x}, ${y})`,
+        `ShowLabel(A, true)`,
+        // `SetPointStyle(A, 0)`,
+        `SetPointSize(A, 4)`,
+        `SetFixed(A, true)`,
+        "O = (0,0)",
+        `SetFixed(O, true)`,
+        `ShowLabel(O, true)`,
+        `SetPointSize(O, 4)`,
+        "I = (1,0)",
+        `SetFixed(I, true)`,
+        `ShowLabel(I, true)`,
+        `SetPointSize(I, 4)`,
+        "J = (0,1)",
+        `SetFixed(J, true)`,
+        `ShowLabel(J, true)`,
+        `SetPointSize(J, 4)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+        lockedAxesRatio: (0, random_1.random)([0.5, 2]),
+    });
+    const A = new point_1.Point("A", x.toTree(), y.toTree());
+    const question = {
+        answer: A.toCoords(),
+        instruction,
+        ggbOptions: ggb.getOptions({
+            coords: ggb.getAdaptedCoords({
+                xMin,
+                xMax,
+                yMin,
+                yMax,
+                forceShowAxes: true,
+            }),
+        }),
+        keys: ["x", "y", "semicolon"],
+        answerFormat: "tex",
+        identifiers: { x, y },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, x, y }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const points = [
+        new point_1.Point("A", (x + 1).toTree(), (y + 1).toTree()),
+        new point_1.Point("A", (x - 1).toTree(), (y - 1).toTree()),
+        new point_1.Point("A", (x - 1).toTree(), (y + 1).toTree()),
+        new point_1.Point("A", (x + 1).toTree(), (x - 1).toTree()),
+    ];
+    points.forEach((point) => (0, exercise_1.tryToAddWrongProp)(propositions, point.toCoords()));
+    while (propositions.length < n) {
+        const wrongAnswer = new point_1.Point("A", (0, randint_1.randint)(-10, 10).toTree(), (0, randint_1.randint)(-10, 10).toTree());
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toCoords(), "tex");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, x, y }) => {
+    const valid = new point_1.Point("A", x.toTree(), y.toTree()).toCoords();
+    return ans === valid;
+};
+exports.pointCoordinatesNoOrthonorm = {
+    id: "pointCoordinatesNoOrthonorm",
+    label: "Lire les coordonnées d'un point (repère non-orthonormé)",
+    levels: ["1rePro"],
+    isSingleStep: true,
+    sections: ["Géométrie cartésienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointCoordinatesNoAxisNumbersQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+};

package/lib/exercises/math/geometry/vectors/scalarProductViaCos.js

@@ -8,7 +8,7 @@ const remarkableValues_1 = require("../../../../math/trigonometry/remarkableValu
 const randint_1 = require("../../../../math/utils/random/randint");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
-const randomLetter_1 = require("../../../../utils/randomLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
 const shuffle_1 = require("../../../../utils/shuffle");
 //|u| |v| cos(u,v)
 const getScalarProductViaCosQuestion = () => {

package/lib/exercises/math/geometry/vectors/vectorCoordinatesFromTwoPoints.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randint_1 = require("../../../../math/utils/random/randint");
 const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
 const alignTex_1 = require("../../../../utils/alignTex");
-const randomLetter_1 = require("../../../../utils/randomLetter");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
 const getVectorCoordinatesFromTwoPointsQuestion = () => {
     const A = [(0, randint_1.randint)(-9, 9), (0, randint_1.randint)(-9, 9)];
     const B = [(0, randint_1.randint)(-9, 9), (0, randint_1.randint)(-9, 9)];

package/lib/exercises/math/percent/htToTTC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htToTTC.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/htToTTC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAgCF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"htToTTC.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/htToTTC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6CF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}

package/lib/exercises/math/percent/htToTTC.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberParser_1 = require("../../../tree/parsers/numberParser");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const random_1 = require("../../../utils/random");
 const getHtToTtcQuestion = () => {
@@ -18,6 +19,19 @@ const getHtToTtcQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { TVA, ht },
+        hint: `Pour augmenter un prix de $t\\%$, on le multiplie par $1 + \\frac{t}{100}$.`,
+        correction: `Pour augmenter $${ht.frenchify()}$ de $${TVA.frenchify()}\\%$, on le multiplie par :
+    
+$$
+1 + \\frac{${TVA.frenchify()}}{100} = ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()}
+$$ 
+
+Le prix TTC est donc : 
+
+$$
+${ht.frenchify()} \\times ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()} = ${answer}
+$$
+`,
     };
     return question;
 };
@@ -32,7 +46,7 @@ const getPropositions = (n, { answer, TVA, ht }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberParser_1.numberParser)(ans) === answer;
 };
 exports.htToTTC = {
     id: "htToTTC",
@@ -47,4 +61,5 @@ exports.htToTTC = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/percent/ttcToHT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuCF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}

package/lib/exercises/math/percent/ttcToHT.js

@@ -6,6 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberParser_1 = require("../../../tree/parsers/numberParser");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const random_1 = require("../../../utils/random");
 const getTtcToHtQuestion = () => {
@@ -18,6 +19,19 @@ const getTtcToHtQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { TTC, TVA },
+        hint: `Pour retrouver le prix HT d'un objet après une hausse de $t\\%$, on divise le prix TTC par $1 + \\frac{t}{100}$.`,
+        correction: `Pour retrouver le prix HT après une hausse de  $${TVA.frenchify()}\\%$, on divise le prix TTC par :
+    
+$$
+1 + \\frac{${TVA.frenchify()}}{100} = ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()}
+$$ 
+
+Le prix HT est donc : 
+
+$$
+${TTC.frenchify()} \\div ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()} \\approx ${answer}
+$$
+`,
     };
     return question;
 };
@@ -32,7 +46,7 @@ const getPropositions = (n, { answer, TTC, TVA }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberParser_1.numberParser)(ans) === answer;
 };
 exports.ttcToHT = {
     id: "ttcToHT",
@@ -47,4 +61,5 @@ exports.ttcToHT = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/averageList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"averageList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/averageList.js

@@ -6,6 +6,8 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
 const round_1 = require("../../../../math/utils/round");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const operatorComposition_1 = require("../../../../tree/utilities/operatorComposition");
 const average_1 = require("../../../../utils/average");
 const getAverageListQuestion = () => {
     let randomValues = [];
@@ -13,7 +15,9 @@ const getAverageListQuestion = () => {
     for (let i = 0; i < length; i++)
         randomValues.push((0, randint_1.randint)(1, 20));
     const sortedValues = randomValues.sort((a, b) => a - b);
+    const avg = (0, average_1.average)(sortedValues);
     const answer = (0, round_1.round)((0, average_1.average)(sortedValues), 2).frenchify();
+    const hasRounded = avg.frenchify() !== answer;
     const question = {
         answer,
         instruction: `On considère la liste suivante : $${randomValues.join(";\\ ")}.$
@@ -21,6 +25,22 @@ const getAverageListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { sortedValues },
+        hint: "La moyenne d'une liste de valeurs est la somme de ses valeurs divisé par le nombre de valeurs.",
+        correction: `
+On additionne toutes les valeurs :
+
+$$
+${(0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, sortedValues.map((e) => e.toTree())).toTex()} = ${sortedValues.reduce((acc, curr) => acc + curr)}
+$$
+
+puis on divise par le nombre de valeurs : 
+
+$$
+${sortedValues.reduce((acc, curr) => acc + curr)}\\div ${sortedValues.length} ${hasRounded ? "\\approx" : "="} ${answer}
+$$
+
+La moyenne ${hasRounded ? "arrondie au centième" : ""} est donc $${answer}$.
+    `,
     };
     return question;
 };
@@ -49,4 +69,5 @@ exports.averageList = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/etendueList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"etendueList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueList.js

@@ -18,6 +18,14 @@ const getEtendueListQuestion = () => {
         keys: [],
         answerFormat: "tex",
         identifiers: { sortedValues },
+        hint: "L'étendue d'une liste de valeurs est la différence entre la valeur maximale et la valeur minimale.",
+        correction: `
+On calcule la différence entre la valeur maximale et la valeur minimale : 
+
+$$
+${sortedValues[sortedValues.length - 1]} - ${sortedValues[0]} = ${answer}
+$$
+    `,
     };
     return question;
 };
@@ -46,4 +54,5 @@ exports.etendueList = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/calibrationCurveOfSolution.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../math/utils/random/randint");
 const molecule_1 = require("../../pc/constants/molecularChemistry/molecule");
 const arrayEqual_1 = require("../../utils/arrayEqual");
 const random_1 = require("../../utils/random");
-const requiresApostropheBefore_1 = require("../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../utils/strings/requiresApostropheBefore");
 const getPointFromGGB_1 = require("../utils/geogebra/getPointFromGGB");
 const isGGBPoint_1 = require("../utils/geogebra/isGGBPoint");
 const toolBarConstructor_1 = require("../utils/geogebra/toolBarConstructor");

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getAtomicStructureOfNucleusQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(0, 50));
     const mass = (0, round_1.round)(atom.masseAtomique, 0);

package/lib/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.js

@@ -8,7 +8,7 @@ const round_1 = require("../../../math/utils/round");
 const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const randint_1 = require("../../../math/utils/random/randint");
 const getCalculateProtonsNumberFromMassQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(0, 50));

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.js

@@ -10,7 +10,7 @@ const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
 const measure_1 = require("../../../pc/measure/measure");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const massUnits_1 = require("../../../pc/units/massUnits");
 const getFindAtomEntitiesNumberFromMassQuestion = () => {
     const atom = (0, random_1.random)(atome_1.atomes.slice(5, 30));

package/lib/exercises/pc/chemicalElements/findAtomicStructureElement.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const possibleElements = [
     "proton",
     "neutron",

package/lib/exercises/pc/chemicalElements/findValenceElectronsNumberFromElectronicConfiguration.js

@@ -8,7 +8,7 @@ const getElectronicConfigurationFromShells_1 = require("../../../exercises/utils
 const randint_1 = require("../../../math/utils/random/randint");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getFindValenceElectronsNumberFromElectronicConfigurationQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3));
     const configurationTex = (0, getElectronicConfigurationFromShells_1.getElectronicConfigurationFromShells)(atom.electronsShells);

package/lib/exercises/pc/chemicalElements/findValenceElectronsNumberFromTable.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getFindValenceElectronsNumberFromTableQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3));
     const instruction = `

package/lib/exercises/pc/chemicalElements/identifyRightElectronicConfiguration.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const getElectronicConfigurationFromShells_1 = require("../../../exercises/utils/getElectronicConfigurationFromShells");
 const atome_1 = require("../../../pc/constants/molecularChemistry/atome");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getIdentifyRightElectronicConfigurationQuestion = () => {
     const atom = (0, random_1.random)((0, getAtoms_1.getAtoms)(3).slice(2));
     const question = {

package/lib/exercises/pc/chemicalElements/massOrVolumeProportion.js

@@ -7,7 +7,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const random_1 = require("../../../utils/random");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const coinFlip_1 = require("../../../utils/coinFlip");
 const round_1 = require("../../../math/utils/round");
 const getMassOrVolumeProportionQuestion = () => {

package/lib/exercises/pc/chemicalReactions/calculateCombustionEnergy.js

@@ -6,7 +6,7 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const combustibles = [
     { name: "bois", value: 15 },
     { name: "éthanol", value: 29 },

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -6,7 +6,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const round_1 = require("../../../math/utils/round");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");

package/lib/exercises/pc/energy/energyTransfer.js

@@ -6,7 +6,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const substances = [
     { name: "eau", latentHeat: 334 }, // kJ/kg for melting ice
     { name: "fer", latentHeat: 276 }, // kJ/kg for melting iron

package/lib/exercises/pc/identifyAtomicMassOrAtomicNb.js

@@ -7,7 +7,7 @@ const randint_1 = require("../../math/utils/random/randint");
 const round_1 = require("../../math/utils/round");
 const coinFlip_1 = require("../../utils/coinFlip");
 const random_1 = require("../../utils/random");
-const requiresApostropheBefore_1 = require("../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../utils/strings/requiresApostropheBefore");
 const getAtoms_1 = require("../utils/getAtoms");
 const getIdentifyAtomicMassOrAtomicNbQuestion = () => {
     const exo = generateExercise();

package/lib/exercises/pc/mole/molarMass.js

@@ -7,7 +7,7 @@ const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
 const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const random_1 = require("../../../utils/random");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getMolarMassQuestion = () => {
     const molecule = (0, random_1.random)(molecule_1.molecules.slice(0, 50).filter((m) => m.atoms.length > 1));
     const article = (0, requiresApostropheBefore_1.requiresApostropheBefore)(molecule.name) ? "de l'" : "du ";

package/lib/exercises/pc/mole/moleculeCountFromMassAndAvogadro.js

@@ -9,7 +9,7 @@ const molecule_1 = require("../../../pc/constants/molecularChemistry/molecule");
 const random_1 = require("../../../utils/random");
 const randint_1 = require("../../../math/utils/random/randint");
 const atoms_1 = require("../../../pc/constants/molecularChemistry/atoms");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const getMoleculeCountFromMassAndAvogadroQuestion = () => {
     const molecule = (0, random_1.random)(molecule_1.molecules);
     const sampleMass = (0, randfloat_1.randfloat)(0.1, 2, 2); // Sample mass in grams

package/lib/exercises/pc/motion/motionReference.js

@@ -5,7 +5,7 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
 const coinFlip_1 = require("../../../utils/coinFlip");
-const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const requiresApostropheBefore_1 = require("../../../utils/strings/requiresApostropheBefore");
 const situations = [
     {
         object1: "avion de chasse",

package/lib/geogebra/geogebraConstructor.js

@@ -18,7 +18,7 @@ class GeogebraConstructor {
         this.yAxis = options?.yAxis;
     }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, }) {
-        const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
+        const showAxes = forceShowAxes ?? (this.hideAxes ? false : true);
         const xDelta = xMax - xMin;
         const yDelta = yMax - yMin;
         if (this.is3D && zMin !== undefined && zMax !== undefined) {

package/lib/index.d.ts

@@ -149,6 +149,10 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     nbIds: any;
     nbValue: number;
     pow: number;
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    a: number;
+    b: number;
 }> | import("./exercises/exercise").Exercise<{
     dec: number;
     pow: number;
@@ -808,6 +812,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     x: number;
     y: number;
+}> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
 }> | import("./exercises/exercise").Exercise<{
     coin: boolean;
     radius: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/tree/nodes/inequations/inequationNode.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InequationNode = void 0;
 const inequation_1 = require("../../../math/inequations/inequation");
 const cartesianProducts_1 = require("../../../utils/cartesianProducts");
-const isLetter_1 = require("../../../utils/isLetter");
+const isLetter_1 = require("../../../utils/strings/isLetter");
 const node_1 = require("../node");
 const infiniteNode_1 = require("../numbers/infiniteNode");
 const closure_1 = require("../sets/closure");

package/lib/tree/parsers/numberParser.d.ts

@@ -0,0 +1,2 @@
+export declare const numberParser: (ans: string) => string | false;
+//# sourceMappingURL=numberParser.d.ts.map

package/lib/tree/parsers/numberParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/numberParser.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,YAAY,QAAS,MAAM,mBAIvC,CAAC"}

package/lib/tree/parsers/numberParser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberParser = void 0;
+//to use when the answer is a pure number (int / float etc)
+const numberParser = (ans) => {
+    const nb = ans.unfrenchify();
+    if (isNaN(nb))
+        return false;
+    return nb.frenchify();
+};
+exports.numberParser = numberParser;

package/lib/utils/strings/isLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const isLetter: (str: string) => false | RegExpMatchArray | null;
+//# sourceMappingURL=isLetter.d.ts.map

package/lib/utils/strings/isLetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isLetter.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/isLetter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,QAAS,MAAM,oCAEnC,CAAC"}

package/lib/utils/strings/isLetter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLetter = void 0;
+const isLetter = (str) => {
+    return str.length === 1 && str.match(/[a-z]/i);
+};
+exports.isLetter = isLetter;

package/lib/utils/strings/pluralize.d.ts

@@ -0,0 +1,2 @@
+export declare const pluralize: (word: string, count: number, suffix?: string) => string;
+//# sourceMappingURL=pluralize.d.ts.map

package/lib/utils/strings/pluralize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralize.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/pluralize.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,SAAU,MAAM,SAAS,MAAM,4BAMpD,CAAC"}

package/lib/utils/strings/pluralize.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluralize = void 0;
+const pluralize = (word, count, suffix = "s") => {
+    if (count > 1) {
+        return word + suffix;
+    }
+    else {
+        return word;
+    }
+};
+exports.pluralize = pluralize;

package/lib/utils/strings/randomLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const randomLetter: (isMaj?: boolean, excludes?: string[]) => string;
+//# sourceMappingURL=randomLetter.d.ts.map

package/lib/utils/strings/randomLetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomLetter.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/randomLetter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,WAChB,OAAO,aACJ,MAAM,EAAE,WASnB,CAAC"}

package/lib/utils/strings/randomLetter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomLetter = void 0;
+const randomLetter = (isMaj = false, excludes = []) => {
+    let letter = "";
+    do {
+        letter = String.fromCharCode((isMaj ? 65 : 97) + Math.floor(Math.random() * 26));
+    } while (excludes.includes(letter));
+    return letter;
+};
+exports.randomLetter = randomLetter;

package/lib/utils/strings/requiresApostropheBefore.d.ts

@@ -0,0 +1,2 @@
+export declare const requiresApostropheBefore: (string: string) => RegExpMatchArray | null;
+//# sourceMappingURL=requiresApostropheBefore.d.ts.map

package/lib/utils/strings/requiresApostropheBefore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requiresApostropheBefore.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/requiresApostropheBefore.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,WAAY,MAAM,4BAEtD,CAAC"}

package/lib/utils/strings/requiresApostropheBefore.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requiresApostropheBefore = void 0;
+const requiresApostropheBefore = (string) => {
+    return string[0].toLowerCase().match(/[a,e,i,o,u,y,h,é,è]/);
+};
+exports.requiresApostropheBefore = requiresApostropheBefore;

package/package.json

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