math-exercises 2.0.44 → 2.1.0

package/lib/exercises/pc/formulaFromComposition.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formulaFromComposition = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const round_1 = require("../../math/utils/round");
+const atome_1 = require("../../pc/molecularChemistry/atome");
+const molecule_1 = require("../../pc/molecularChemistry/molecule");
+const shuffle_1 = require("../../utils/shuffle");
+const getFormulaFromComposition = () => {
+    const moleculesWith2Atoms = molecule_1.molecules.filter((molecule) => molecule.atoms.length === 2 && molecule.state !== "aqueous");
+    const randomMoleculeIndex = Math.floor(Math.random() * moleculesWith2Atoms.length);
+    const myRandomMolecule = moleculesWith2Atoms[randomMoleculeIndex];
+    const [elementName1, elementName2] = myRandomMolecule.atoms.map((el) => el.atom.symbole);
+    const [elementcount1, elementcount2] = myRandomMolecule.atoms.map((el) => el.count);
+    const elementMolarMass1 = atome_1.atomes.find((el) => el.symbole === elementName1).masseAtomique;
+    const elementMolarMass2 = atome_1.atomes.find((el) => el.symbole === elementName2).masseAtomique;
+    const percentageElement1 = (0, round_1.round)(((elementcount1 * elementMolarMass1) /
+        (elementcount1 * elementMolarMass1 + elementcount2 * elementMolarMass2)) *
+        100, 2);
+    const percentageElement2 = (0, round_1.round)(((elementcount2 * elementMolarMass2) /
+        (elementcount1 * elementMolarMass1 + elementcount2 * elementMolarMass2)) *
+        100, 2);
+    const answer = myRandomMolecule.formula;
+    const question = {
+        instruction: `Déterminer la formule brute $${elementName1}_x${elementName2}_y$ à partir de la composition centésimale $${elementName1}$ : $${percentageElement1}$ $\\%$ $${elementName2}$ : $${percentageElement2}$ $\\%$.`,
+        answer,
+        keys: [...myRandomMolecule.atoms.map((el) => el.atom.name), "underscore"],
+        answerFormat: "tex",
+        identifiers: { randomMoleculeIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randomMoleculeIndex }) => {
+    const moleculesWith2Atoms = molecule_1.molecules.filter((molecule) => molecule.atoms.length === 2 && molecule.state !== "aqueous");
+    const myRandomMolecule = moleculesWith2Atoms[randomMoleculeIndex];
+    const [elementName1, elementName2] = myRandomMolecule.atoms.map((el) => el.atom.symbole);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomElementCount1 = (0, randint_1.randint)(1, 6);
+        const randomElementCount2 = (0, randint_1.randint)(1, 6);
+        const randomElement1 = randomElementCount1 === 1
+            ? elementName1
+            : `${elementName1}_${randomElementCount1}`;
+        const randomElement2 = randomElementCount2 === 1
+            ? elementName2
+            : `${elementName2}_${randomElementCount2}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${randomElement1}${randomElement2}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.formulaFromComposition = {
+    id: "formulaFromComposition",
+    connector: "\\iff",
+    label: "Déterminer la formule brute à partir de la composition centésimale",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Chimie organique"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFormulaFromComposition, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,13 @@
+export * from "./chemicalEquations";
+export * from "./chemicalReactionsProduct";
+export * from "./delution";
+export * from "./formulaFromComposition";
+export * from "./kineticEnergy";
+export * from "./molarQuantity";
+export * from "./moleculeFormula";
+export * from "./moleculeNomenclature";
+export * from "./pH";
+export * from "./perceivedFrequency";
+export * from "./potentialEnergy";
+export * from "./snellDescartes";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC;AAC3B,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,MAAM,CAAC;AACrB,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/pc/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./chemicalEquations"), exports);
+__exportStar(require("./chemicalReactionsProduct"), exports);
+__exportStar(require("./delution"), exports);
+__exportStar(require("./formulaFromComposition"), exports);
+__exportStar(require("./kineticEnergy"), exports);
+__exportStar(require("./molarQuantity"), exports);
+__exportStar(require("./moleculeFormula"), exports);
+__exportStar(require("./moleculeNomenclature"), exports);
+__exportStar(require("./pH"), exports);
+__exportStar(require("./perceivedFrequency"), exports);
+__exportStar(require("./potentialEnergy"), exports);
+__exportStar(require("./snellDescartes"), exports);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"kineticEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/kineticEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA6CF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}

package/lib/exercises/pc/kineticEnergy.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kineticEnergy = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../math/utils/latex/frenchify");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getKineticEnergyQuestion = () => {
+    const mass = Math.floor(Math.random() * 50 + 90) * 10; // Masse de la voiture entre 900 et 1500 kg
+    const velocity = Math.floor(Math.random() * 20 + 10); // Vitesse de la voiture en m/s
+    const kineticEnergy = 0.5 * mass * velocity ** 2;
+    const instruction = `Une voiture ayant une masse de $${mass}$ kg qui se déplace le long d'une route. La voiture accélère et atteint une vitesse de $${velocity}$ m/s.
+   $\\\\$ Calculer l'énergie cinétique (en kJ) de la voiture lorsqu'elle atteint cette vitesse.`;
+    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(kineticEnergy / 1000, 2))} \\ kJ`;
+    const question = {
+        instruction,
+        startStatement: "Ec",
+        answer,
+        keys: ["kJ"],
+        answerFormat: "tex",
+        identifiers: { mass, velocity },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, mass, velocity }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const kineticEnergy = 0.5 * mass * velocity ** 2;
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)((kineticEnergy / 1000) * (0.3 + Math.random() * 1.5), 2)) + " \\ kJ");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.kineticEnergy = {
+    id: "kineticEnergy",
+    connector: "=",
+    label: "Calculer l'énergie cinétique",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Mécanique"],
+    subject: "Physique",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getKineticEnergyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

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

package/lib/exercises/pc/molarQuantity.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.molarQuantity = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../math/utils/latex/frenchify");
+const round_1 = require("../../math/utils/round");
+const atome_1 = require("../../pc/molecularChemistry/atome");
+const molecule_1 = require("../../pc/molecularChemistry/molecule");
+const shuffle_1 = require("../../utils/shuffle");
+const getMolarQuantityQuestion = () => {
+    const mG = (0, round_1.round)(Math.random() * 150 + 50, 0); // Masse de l'échantillon en g (entre 50 et 200 g)
+    const moleculesSolid = molecule_1.molecules.filter((molecule) => molecule.state === "solid");
+    const randomMoleculeIndex = Math.floor(Math.random() * moleculesSolid.length);
+    const myRandomMolecule = moleculesSolid[randomMoleculeIndex];
+    const molarMassG = (0, round_1.round)(myRandomMolecule.weight, 2); // Masse molaire en g/mol
+    const nG = mG / molarMassG;
+    const myAtoms = myRandomMolecule.atoms.map((el) => el.atom.name);
+    const myAtomsMolarMass = myAtoms.map((atome) => {
+        return atome_1.atomes.find((el) => el.name === atome)?.masseAtomique;
+    });
+    const res = myAtomsMolarMass
+        .map((molarMass, index) => `$M_{(${myRandomMolecule.atoms[index].atom.symbole})}$ = $${molarMass?.toFixed(0)}$ $g/mol$ ; `)
+        .join("");
+    const instruction = `Un échantillon de ${myRandomMolecule.name} $${myRandomMolecule.formula}$ a une masse de ${mG} g. 
+  Déterminer la quantité de matière $n$ contenue dans cet échantillon de ${myRandomMolecule.name}. 
+  $\\\\$ On donne : ${res}`;
+    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(nG, 2))}\\ mol`;
+    const question = {
+        instruction,
+        startStatement: "n",
+        answer,
+        keys: ["mol"],
+        answerFormat: "tex",
+        identifiers: { mG, randomMoleculeIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)(Math.random() * 5, 2)) + "\\ mol");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.molarQuantity = {
+    id: "molarQuantity",
+    connector: "=",
+    label: "Calculer une quantité de matière",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Constitution et transformations de la matière"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMolarQuantityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"moleculeFormula.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/moleculeFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAkDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/pc/moleculeFormula.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moleculeFormula = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const molecule_1 = require("../../pc/molecularChemistry/molecule");
+const shuffle_1 = require("../../utils/shuffle");
+const getMoleculeNFormula = () => {
+    const organicMolecule = molecule_1.molecules.filter((molecule) => molecule.isOrganic && molecule.iupact);
+    const randomMoleculeIndex = Math.floor(Math.random() * organicMolecule.length);
+    const myRandomMolecule = organicMolecule[randomMoleculeIndex];
+    const instruction = `Donner la formule brute de la molécule suivante : 
+  $\\\\$ ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/scienceAssets/molecules/${myRandomMolecule.formula}.png)`;
+    const answer = myRandomMolecule.formula;
+    const question = {
+        instruction,
+        answer,
+        keys: [...myRandomMolecule.atoms.map((el) => el.atom.name), "underscore"],
+        answerFormat: "tex",
+        identifiers: { randomMoleculeIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randomMoleculeIndex }) => {
+    const organicMolecule = molecule_1.molecules.filter((molecule) => molecule.isOrganic && molecule.iupact);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomMoleculeIndex = Math.floor(Math.random() * organicMolecule.length);
+        const myRandomMolecule = organicMolecule[randomMoleculeIndex];
+        (0, exercise_1.tryToAddWrongProp)(propositions, myRandomMolecule.formula);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.moleculeFormula = {
+    id: "moleculeFormula",
+    connector: "\\iff",
+    label: "Donner la formule brute d'une molécule à partir de sa formule développée",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Chimie organique"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMoleculeNFormula, nb, 20),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    maxAllowedQuestions: 20,
+};

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

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

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

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

package/lib/exercises/pc/moleculeNomenclature.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moleculeNomenclature = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const molecule_1 = require("../../pc/molecularChemistry/molecule");
+const shuffle_1 = require("../../utils/shuffle");
+const getMoleculeNomenclature = () => {
+    const organicMolecule = molecule_1.molecules.filter((molecule) => molecule.isOrganic && molecule.type);
+    const randomMoleculeIndex = Math.floor(Math.random() * organicMolecule.length);
+    const myRandomMolecule = organicMolecule[randomMoleculeIndex];
+    const instruction = `Donner le nom de la molécule suivante : 
+  $\\\\$ ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/scienceAssets/molecules/${myRandomMolecule.formula}.png)`;
+    const question = {
+        instruction,
+        answer: myRandomMolecule.iupact,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { randomMoleculeIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const organicMolecule = molecule_1.molecules.filter((molecule) => molecule.isOrganic && molecule.type);
+    while (propositions.length < n) {
+        const randomMoleculeIndex = Math.floor(Math.random() * organicMolecule.length);
+        const myRandomMolecule = organicMolecule[randomMoleculeIndex];
+        (0, exercise_1.tryToAddWrongProp)(propositions, myRandomMolecule.name, "raw");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.moleculeNomenclature = {
+    id: "moleculeNomenclature",
+    connector: "\\iff",
+    label: "Donner le nom d'une molécule à partir de sa formule développée",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Chimie organique"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMoleculeNomenclature, nb, 20),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    maxAllowedQuestions: 20,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAwCF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pH = 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 getpH = () => {
+    const randomNumber = (0, randint_1.randint)(1, 10);
+    const randomTenPower = (0, randint_1.randint)(2, 10);
+    const concentrationHydrogene = randomNumber * 10 ** -randomTenPower;
+    const instruction = `Calculer le pH d'une solution ayant une concentration en ions hydrogène ($H^+$) de $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.`;
+    const answer = (0, frenchify_1.frenchify)((0, round_1.round)(-Math.log10(concentrationHydrogene), 1));
+    const question = {
+        instruction,
+        startStatement: `pH`,
+        answer,
+        keys: ["log"],
+        answerFormat: "tex",
+        identifiers: { randomNumber, randomTenPower },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomNumber = (0, randint_1.randint)(1, 10);
+        const randomTenPower = (0, randint_1.randint)(2, 10);
+        const concentrationHydrogene = randomNumber * 10 ** -randomTenPower;
+        const wrongAnswer = (0, frenchify_1.frenchify)((0, round_1.round)(-Math.log10(concentrationHydrogene), 1)) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.pH = {
+    id: "pH",
+    connector: "=",
+    label: "Calculer le pH d'une solution",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Acide / Base"],
+    subject: "Chimie",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getpH, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"perceivedFrequency.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/perceivedFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/pc/perceivedFrequency.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perceivedFrequency = 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 soundSpeed = 340; // Vitesse du son dans l'air en m/s
+const observerSpeed = 0; // La vitesse de l'observateur est supposée être nulle (observateur immobile)
+const getPerceivedFrequency = () => {
+    const frequencyEmitted = (0, randint_1.randint)(200, 1500); // Fréquence émise en Hz
+    const ambulanceSpeed = Math.floor(Math.random() * 40 + 10); // Vitesse de l'ambulance entre 10 et 50 m/s
+    const perceivedFrequency = (frequencyEmitted * (soundSpeed + observerSpeed)) /
+        (soundSpeed - ambulanceSpeed);
+    const instruction = `Une ambulance émet un son d'une fréquence de $${frequencyEmitted}$ Hz lorsqu'elle
+  s'approche d'un observateur à une vitesse de $${ambulanceSpeed}$ m/s. Si la vitesse du son
+  dans l'air est de $340$ m/s, calculer la fréquence perçue par l'observateur.`;
+    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(perceivedFrequency, 0))} \\ Hz`;
+    const question = {
+        instruction,
+        answer,
+        keys: ["Hz"],
+        answerFormat: "tex",
+        identifiers: { ambulanceSpeed, frequencyEmitted },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, ambulanceSpeed, frequencyEmitted }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const perceivedFrequency = (frequencyEmitted * (soundSpeed + observerSpeed)) /
+        (soundSpeed - ambulanceSpeed);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)(perceivedFrequency * (0.3 + Math.random() * 1.5), 0)) +
+            " \\ Hz");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.perceivedFrequency = {
+    id: "perceivedFrequency",
+    connector: "\\iff",
+    label: "Calculer une fréquence perçue par un observateur",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Ondes"],
+    subject: "Physique",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPerceivedFrequency, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/pc/potentialEnergy.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.potentialEnergy = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../math/utils/latex/frenchify");
+const round_1 = require("../../math/utils/round");
+const shuffle_1 = require("../../utils/shuffle");
+const getPotentialEnergy = () => {
+    const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+    const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
+    const gravitationalAcceleration = 9.81; // Accélération due à la gravité en m/s²
+    const potentialEnergy = mass * 9.81 * height;
+    const instruction = `Un objet de masse ${mass} kg est suspendu à une hauteur de ${height} mètres. Il est ensuite relâché et tombe librement.
+  $\\\\$ Calculer l'énergie potentielle de l'objet. (Supposons que l'accélération due à la gravité est de 9,81 m/s²)`;
+    const answer = `${(0, frenchify_1.frenchify)((0, round_1.round)(potentialEnergy, 2))}  \\ J`;
+    const question = {
+        instruction,
+        startStatement: "Ep",
+        answer,
+        keys: ["J"],
+        answerFormat: "tex",
+        identifiers: { height, mass },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, height, mass }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const potentialEnergy = mass * 9.81 * height;
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)((0, round_1.round)(potentialEnergy * (0.3 + Math.random() * 1.5), 2)) +
+            " \\ J");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.potentialEnergy = {
+    id: "potentialEnergy",
+    connector: "=",
+    label: "Calculer l'énergie potentielle",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Mécanique"],
+    subject: "Physique",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPotentialEnergy, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"snellDescartes.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/snellDescartes.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,0BAA0B,CAAC;AA2DlC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,uBAAuB,EAAE,MAAM,CAAC;CACjC,CAAC;AA+CF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}