math-exercises 2.0.44 → 2.1.1

package/lib/exercises/math/trigonometry/remarkableValues.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remarkableValuesExercise = void 0;
+const remarkableValue_1 = require("../../../math/trigonometry/remarkableValue");
+const remarkableValues_1 = require("../../../math/trigonometry/remarkableValues");
+const cosNode_1 = require("../../../tree/nodes/functions/cosNode");
+const sinNode_1 = require("../../../tree/nodes/functions/sinNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const random_1 = require("../../../utils/random");
+const shuffle_1 = require("../../../utils/shuffle");
+const exercise_1 = require("../../exercise");
+const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+const values = [
+    "-1",
+    "-\\frac{\\sqrt 3}{2}",
+    "-\\frac{\\sqrt 2}{2}",
+    "-\\frac{1}{2}",
+    "0",
+    "\\frac{\\sqrt 3}{2}",
+    "\\frac{\\sqrt 2}{2}",
+    "\\frac{1}{2}",
+    "1",
+];
+const getRemarkableValues = () => {
+    const isCos = (0, coinFlip_1.coinFlip)();
+    const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
+    const mainValue = remarkableValue.mainAngle.evaluate({});
+    // const valueIndex = remarkableValue.index;
+    const answer = isCos
+        ? remarkableValue.cos.toTex()
+        : remarkableValue.sin.toTex();
+    const statement = isCos
+        ? new cosNode_1.CosNode(remarkableValue.angle).toTex()
+        : new sinNode_1.SinNode(remarkableValue.angle).toTex();
+    const question = {
+        instruction: `Donner la valeur exacte de : $${statement}$`,
+        startStatement: statement,
+        answer: answer,
+        keys: ["pi", "cos", "sin"],
+        answerFormat: "tex",
+        identifiers: { isCos, mainValue },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const statement = (0, random_1.random)(values);
+        (0, exercise_1.tryToAddWrongProp)(propositions, statement);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { mainValue, isCos }) => {
+    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => Math.abs(point.angle.evaluate({}) - mainValue) < 0.0001);
+    const answer = isCos ? remarkableValue.cos : remarkableValue.sin;
+    const texs = answer.toAllValidTexs({
+        allowFractionToDecimal: true,
+        allowMinusAnywhereInFraction: true,
+    });
+    return texs.includes(ans);
+};
+exports.remarkableValuesExercise = {
+    id: "remarkableValues",
+    connector: "=",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Trigonométrie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRemarkableValues, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/trigonometry/trigonometry.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    sideA: string;
+    sideB: string;
+    sideC: string;
+    randAngle: number;
+    randTrigo: number;
+};
+export declare const trigonometry: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometry.d.ts.map

package/lib/exercises/math/trigonometry/trigonometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}

package/lib/exercises/math/trigonometry/trigonometry.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometry = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const lengthNode_1 = require("../../../tree/nodes/geometry/lengthNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getTrigonometry = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.7,
+        maxRapport: 1.3,
+        names: vertices,
+    });
+    const sideA = triangle.getSideAName();
+    const sideB = triangle.getSideBName();
+    const sideC = triangle.getSideCName();
+    const trigo = ["le cosinus", "le sinus", "la tangente"];
+    const randTrigo = (0, randint_1.randint)(0, 3);
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    let quotient;
+    switch (randAngle) {
+        case 0:
+            quotient = [
+                `\\frac{${sideC}}{${sideA}}`,
+                `\\frac{${sideB}}{${sideA}}`,
+                `\\frac{${sideB}}{${sideC}}`,
+            ];
+            break;
+        case 1:
+            quotient = [
+                `\\frac{${sideB}}{${sideA}}`,
+                `\\frac{${sideC}}{${sideA}}`,
+                `\\frac{${sideC}}{${sideB}}`,
+            ];
+            break;
+        default:
+            quotient = [""];
+    }
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = quotient[randTrigo];
+    const question = {
+        instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angle[randAngle]}}$?`,
+        answer,
+        keys: [...vertices, "equal"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { sideA, sideB, sideC, randAngle, randTrigo },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, sideA, sideB, sideC }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const wrongQuotients = [
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+    ];
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongQuotients[(0, randint_1.randint)(0, 12)]);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { randAngle, randTrigo, sideA, sideB, sideC }) => {
+    let quotients = [];
+    if (randAngle === 0)
+        quotients = [
+            [sideC, sideA],
+            [sideB, sideA],
+            [sideB, sideC],
+        ];
+    else
+        quotients = [
+            [sideB, sideA],
+            [sideC, sideA],
+            [sideC, sideB],
+        ];
+    const quotient = quotients[randTrigo];
+    const answer = new fractionNode_1.FractionNode(new lengthNode_1.LengthNode(quotient[0]), new lengthNode_1.LengthNode(quotient[1]));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometry = {
+    id: "trigonometry",
+    connector: "=",
+    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometry, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSides: number[];
+};
+export declare const trigonometryAngleCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometryAngleCalcul.d.ts.map

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA8EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometryAngleCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const shuffle_1 = require("../../../utils/shuffle");
+const getTrigonometryAngleCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSides = (0, shuffle_1.shuffle)([0, 1, 2]);
+    const answer = randAngle === 0
+        ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
+        : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
+    const answerTex = answer + "^{\\circ}";
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(triangle.generateCommands({ highlightedAngle: angle[randAngle] }), {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSides[0]]} = ${(sideLengths[randSides[0]] + "").replace(".", ",")}$ cm et $${sides[randSides[1]]} = ${(sideLengths[randSides[1]] + "").replace(".", ",")}$ cm. Calculer $\\widehat{${angle[randAngle]}}$ à $1^\\circ$ près.`,
+        answer: answerTex,
+        keys: ["degree"],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, sideLengths, randSides },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(20, 80) + "°");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("^")[0]].includes(ans);
+};
+exports.trigonometryAngleCalcul = {
+    id: "trigonometryAngleCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un angle",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    randAngle: number;
+    randSide: number;
+    randSideQuestion: number;
+};
+export declare const trigonometrySideCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4FF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trigonometrySideCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getTrigonometrySideCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.5,
+        maxRapport: 1.5,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSide = (0, randint_1.randint)(0, 3); // valeurs possible : 0 1 2
+    const randSideQuestion = (0, randint_1.randint)(0, 3, [randSide]); // si rand = 0, valeurs possible 1 2
+    const angleValue = [
+        (0, round_1.round)((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI, 1),
+        (0, round_1.round)((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI, 1),
+    ];
+    const commands = [
+        ...triangle.generateCommands({
+            highlightedAngle: angle[randAngle],
+            colorHighlightedAngle: "Black",
+            showLabels: [sides[randSideQuestion]],
+            setCaptions: ["?"],
+            highlightedSide: sides[randSideQuestion],
+        }),
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const answer = `${((0, round_1.round)(sideLengths[randSideQuestion], 1) + "").replace(".", ",")}`;
+    const question = {
+        instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { randAngle, randSide, randSideQuestion, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${((0, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1) + "").replace(".", ",")}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.trigonometrySideCalcul = {
+    id: "trigonometrySideCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un côté",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Trigonométrie", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/pc/chemicalEquations.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../exercises/exercise";
+import { ReactionSpecies } from "../../pc/molecularChemistry/reaction";
+type Identifiers = {
+    reactionArray: ReactionSpecies[];
+};
+export declare const chemicalEquations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=chemicalEquations.d.ts.map

package/lib/exercises/pc/chemicalEquations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chemicalEquations.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/chemicalEquations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAGL,eAAe,EAChB,MAAM,sCAAsC,CAAC;AAG9C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAkCF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/pc/chemicalEquations.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chemicalEquations = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const reaction_1 = require("../../pc/molecularChemistry/reaction");
+const shuffle_1 = require("../../utils/shuffle");
+const getChemicalEquations = () => {
+    const reaction = reaction_1.ReactionConstructor.randomReaction();
+    const answer = reaction.getReactionString();
+    const question = {
+        instruction: "Equilibrez la réaction suivante :$\\\\$ " +
+            reaction.getReactionWithoutCoef(),
+        answer,
+        keys: [...reaction.getSpeciesName(), "rightarrow"],
+        answerFormat: "tex",
+        identifiers: { reactionArray: reaction.reactionArray },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, reactionArray }) => {
+    const propositions = [];
+    const reaction = new reaction_1.Reaction(reactionArray);
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, reaction.getReactionWithWrongCoef());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.chemicalEquations = {
+    id: "chemicalEquations",
+    connector: "\\iff",
+    label: "Équilibrer une réaction chimique",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Réaction chimique"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getChemicalEquations, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/pc/chemicalReactionsProduct.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../exercises/exercise";
+import { ReactionSpecies } from "../../pc/molecularChemistry/reaction";
+type Identifiers = {
+    reactionArray: ReactionSpecies[];
+    randomSpacieIndex: number;
+};
+export declare const chemicalReactionsProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=chemicalReactionsProduct.d.ts.map

package/lib/exercises/pc/chemicalReactionsProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chemicalReactionsProduct.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/chemicalReactionsProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAEL,eAAe,EAEhB,MAAM,sCAAsC,CAAC;AAG9C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAyCF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}

package/lib/exercises/pc/chemicalReactionsProduct.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chemicalReactionsProduct = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const reaction_1 = require("../../pc/molecularChemistry/reaction");
+const shuffle_1 = require("../../utils/shuffle");
+const getChemicalReactionsProduct = () => {
+    const reaction = reaction_1.ReactionConstructor.randomReaction();
+    const randomSpacieIndex = (0, randint_1.randint)(0, reaction.reactionArray.length);
+    const randomSpacie = reaction.reactionArray[randomSpacieIndex];
+    const randomSpacieFormula = randomSpacie.species?.formula;
+    const randomSpacieCoef = Math.abs(randomSpacie.coefficient) === 1
+        ? ""
+        : Math.abs(randomSpacie.coefficient);
+    const answer = randomSpacieCoef + "" + randomSpacieFormula;
+    const question = {
+        instruction: "Completer la réaction suivante en donnant l'élement manquant : $\\\\$ " +
+            reaction.getReactionWithQuestionMark(randomSpacieIndex),
+        answer,
+        keys: [...reaction.getUniqueAtomNames(), "underscore"],
+        answerFormat: "tex",
+        identifiers: { reactionArray: reaction.reactionArray, randomSpacieIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, reaction_1.molecules[(0, randint_1.randint)(0, reaction_1.molecules.length)].formula);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.chemicalReactionsProduct = {
+    id: "chemicalReactionsProduct",
+    connector: "\\iff",
+    label: "Identifier le produit ou le réactif manquant d'une réaction chimique donnée",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Réaction chimique"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getChemicalReactionsProduct, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/pc/delution.d.ts

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

package/lib/exercises/pc/delution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delution.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/delution.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAgEF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

package/lib/exercises/pc/delution.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delution = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../math/utils/latex/frenchify");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getDelution = () => {
+    const concentrationMere = (0, round_1.round)(Math.random() * 0.4 + 0.1, 2); // entre 0.1 et 0.5 mol/L pour C1
+    const volumeFille = (0, round_1.round)(Math.random() * 200 + 50, 0); // entre 50 et 250 mL pour V2
+    const concentrationFille = (0, round_1.round)(Math.random() * 0.05 + 0.01, 2); // entre 0.01 et 0.06 mol/L pour C2
+    const volumeMere = (0, round_1.round)((volumeFille * concentrationFille) / concentrationMere, 2);
+    const instruction = `Soit une solution mère de concentration $C_1$ = $${concentrationMere}$ mol/L. On souhaite préparer
+  une solution fille de volume $V_2$ = $${volumeFille}$ mL de concentration $C_2$ = $${concentrationFille}$ mol/L.
+  $\\\\$ Calculer le volume $V_1$ à prélever.`;
+    const answer = (0, frenchify_1.frenchify)(volumeMere) + " \\ mL";
+    const question = {
+        instruction,
+        startStatement: `V_1`,
+        answer,
+        keys: ["mL"],
+        answerFormat: "tex",
+        identifiers: { concentrationFille, concentrationMere, volumeFille },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, concentrationFille, concentrationMere, volumeFille }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const volumeMere = (0, round_1.round)((volumeFille * concentrationFille) / concentrationMere, 2);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)((volumeFille * concentrationMere) / concentrationFille, 2)) + " \\ mL");
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)(concentrationMere / (volumeFille * concentrationFille), 2)) + " \\ mL");
+    while (propositions.length < n) {
+        const wrongAnswer = volumeMere + (0, randint_1.randint)(-volumeMere, 11, [0]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)(wrongAnswer.toFixed(2)) + " \\ mL");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.delution = {
+    id: "delution",
+    connector: "=",
+    label: "Déterminer le volume d'une solution après dilution.",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Chimie des solutions"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDelution, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/pc/formulaFromComposition.d.ts

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

package/lib/exercises/pc/formulaFromComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formulaFromComposition.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/formulaFromComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAwFF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}