math-exercises 2.2.3 → 2.2.5

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.efficencyOfConverter = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const measure_1 = require("../../../pc/measure/measure");
+const wattUnit_1 = require("../../../pc/units/wattUnit");
+const getEfficencyOfConverterQuestion = () => {
+    const exo = getExercise();
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        hint: exo.hint,
+        correction: exo.correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { entry: exo.entry, out: exo.out },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, entry, out }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(entry, out).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value + ""));
+    let random;
+    while (propositions.length < n) {
+        random = (0, randint_1.randint)(+answer - 10, +answer + 20, [+answer]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generatePropositions = (entry, out) => {
+    const first = Math.floor((entry * 100) / out) * 100;
+    return [first];
+};
+const getExercise = () => {
+    const entry = (0, randint_1.randint)(2, 11);
+    const entryMeasure = new measure_1.Measure(entry * 100, 0, wattUnit_1.WattUnit.W);
+    const out = (0, randint_1.randint)(1, entry) * 100;
+    const outMeasure = new measure_1.Measure(out, 0, wattUnit_1.WattUnit.W);
+    const instruction = `Un convertisseur reçoit une puissance d'entrée de $${entryMeasure.toTex({ notScientific: true })}$ et fournit une puissance exploitable de $${outMeasure.toTex({
+        notScientific: true,
+    })}$. 
+  
+  Calculez le rendement du convertisseur arrondie au centiéme. Exprimez votre réponse en pourcentage.`;
+    const answer = `${Math.floor(out / entry)}`;
+    const hint = `Un convertisseur d'énergie a pour rendement, noté $\\eta$, une grandeur sans dimension qui mesure l'efficacité de sa conversion d'énergie.
+  
+  Ce rendement est défini par la formule suivante :
+  - $\\eta = \\frac{P_{exploitable}}{P_{entrée}}$`;
+    const correction = `Appliquer la formule $\\eta = \\frac{P_{exploitable}}{P_{entrée}}$ : 
+  
+  - $\\eta = \\frac{${outMeasure.toTex({
+        notScientific: true,
+    })}}{${entryMeasure.toTex({
+        notScientific: true,
+    })}} \\times 100 \\Rightarrow \\eta=${answer}\\%$  `;
+    return {
+        instruction,
+        answer,
+        hint,
+        correction,
+        entry,
+        out,
+    };
+};
+exports.efficencyOfConverter = {
+    id: "efficencyOfConverter",
+    label: "Calcul du rendement d'un convertisseur",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEfficencyOfConverterQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/energy/efficiencyCalculation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    inputPower: number;
+    outputPower: number;
+    efficiency: number;
+    variable: "P_in" | "P_out" | "η";
+};
+export declare const efficiencyCalculation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=efficiencyCalculation.d.ts.map

package/lib/exercises/pc/energy/efficiencyCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"efficiencyCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/efficiencyCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,CAAC;CAClC,CAAC;AA8IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.efficiencyCalculation = void 0;
+const frenchify_1 = require("../../../math/utils/latex/frenchify");
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const round_1 = require("../../../math/utils/round");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const getEfficiencyCalculationQuestion = () => {
+    const inputPower = (0, round_1.round)((0, randfloat_1.randfloat)(100, 1000), 2); // Puissance d'entrée en W
+    const outputPower = (0, round_1.round)((0, randfloat_1.randfloat)(50, 900), 2); // Puissance de sortie en W
+    const efficiency = (0, round_1.round)(outputPower / inputPower, 2); // Rendement
+    const variableIndex = (0, randint_1.randint)(0, 3);
+    const variables = ["P_in", "P_out", "η"];
+    const variable = variables[variableIndex];
+    let questionText, answer;
+    switch (variable) {
+        case "P_in":
+            questionText = `Vous êtes dans un laboratoire et vous mesurez l'efficacité d'un convertisseur. La puissance de sortie est $P_{out} = ${(0, frenchify_1.frenchify)(outputPower)}\\ \\text{W}$ et le rendement est $\\eta = ${(0, frenchify_1.frenchify)(efficiency)}$. Déterminez la puissance d'entrée $P_{in}$ en $\\text{W}$.`;
+            answer = (0, round_1.round)(outputPower / efficiency, 2);
+            break;
+        case "P_out":
+            questionText = `Vous êtes dans un laboratoire et vous mesurez l'efficacité d'un convertisseur. La puissance d'entrée est $P_{in} = ${(0, frenchify_1.frenchify)(inputPower)}\\ \\text{W}$ et le rendement est $\\eta = ${(0, frenchify_1.frenchify)(efficiency)}$. Déterminez la puissance de sortie $P_{out}$ en $\\text{W}$.`;
+            answer = (0, round_1.round)(inputPower * efficiency, 2);
+            break;
+        case "η":
+            questionText = `Vous êtes dans un laboratoire et vous mesurez l'efficacité d'un convertisseur. La puissance d'entrée est $P_{in} = ${(0, frenchify_1.frenchify)(inputPower)}\\ \\text{W}$ et la puissance de sortie est $P_{out} = ${(0, frenchify_1.frenchify)(outputPower)}\\ \\text{W}$. Déterminez le rendement $\\eta$.`;
+            answer = (0, round_1.round)(outputPower / inputPower, 2);
+            break;
+    }
+    const hint = `Le rendement d'un convertisseur, noté $\\eta$, est une grandeur sans dimension qui mesure l'efficacité de sa conversion. Il est défini par la relation :
+    $$
+    \\eta = \\frac{P_{out}}{P_{in}}
+    $$
+    Réarrangez cette formule pour isoler la variable à trouver.`;
+    const correction = `La formule du rendement est :
+    $$
+    \\eta = \\frac{P_{out}}{P_{in}}
+    $$
+
+Pour résoudre ce problème, nous devons réorganiser la formule pour isoler la variable inconnue.
+
+${variable === "P_in"
+        ? `$$P_{in} = \\frac{P_{out}}{\\eta} = \\frac{${(0, frenchify_1.frenchify)(outputPower)}}{${(0, frenchify_1.frenchify)(efficiency)}} = ${(0, frenchify_1.frenchify)(answer)}\\ \\text{W}$$`
+        : variable === "P_out"
+            ? `$$P_{out} = \\eta \\times P_{in} = ${(0, frenchify_1.frenchify)(efficiency)} \\times ${(0, frenchify_1.frenchify)(inputPower)} = ${(0, frenchify_1.frenchify)(answer)}\\ \\text{W}$$`
+            : `$$\\eta = \\frac{P_{out}}{P_{in}} = \\frac{${(0, frenchify_1.frenchify)(outputPower)}}{${(0, frenchify_1.frenchify)(inputPower)}} = ${(0, frenchify_1.frenchify)(answer)}$$`}`;
+    const question = {
+        answer: answer.toTree().toTex(),
+        instruction: questionText,
+        hint,
+        correction,
+        keys: ["timesTenPower"],
+        answerFormat: "tex",
+        identifiers: {
+            inputPower,
+            outputPower,
+            efficiency,
+            variable,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, inputPower, outputPower, efficiency, variable }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const wrongAnswers = [
+        variable === "P_in"
+            ? (0, round_1.round)(outputPower * efficiency, 2)
+            : (0, round_1.round)(outputPower / efficiency, 2),
+        variable === "P_out"
+            ? (0, round_1.round)(inputPower / efficiency, 2)
+            : (0, round_1.round)(inputPower * efficiency, 2),
+        variable === "η"
+            ? (0, round_1.round)(inputPower / outputPower, 2)
+            : (0, round_1.round)(outputPower / inputPower, 2),
+    ];
+    wrongAnswers.forEach((wrongAnswer) => {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTree().toTex());
+    });
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(0.1, 1, 2).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, outputPower, inputPower, variable }) => {
+    let validanswer;
+    const efficiency = (0, round_1.round)(outputPower / inputPower, 2);
+    switch (variable) {
+        case "P_in":
+            validanswer = (0, round_1.round)(outputPower / efficiency, 2);
+            break;
+        case "P_out":
+            validanswer = (0, round_1.round)(inputPower * efficiency, 2);
+            break;
+        case "η":
+            validanswer = (0, round_1.round)(outputPower / inputPower, 2);
+            break;
+    }
+    const latexs = [
+        ...validanswer.toTree().toAllValidTexs(),
+        validanswer.toScientific(2).toTex(),
+        validanswer.toScientific(1).toTex(),
+        validanswer.toScientific(3).toTex(),
+    ];
+    return latexs.includes(ans);
+};
+exports.efficiencyCalculation = {
+    id: "efficiencyCalculation",
+    label: "Calculer les puissances d'entrée/sortie ou le rendement",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Énergie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEfficiencyCalculationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/energy/energyTransfer.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    substance: string;
+    mass: number;
+    latentHeat: number;
+    energy: number;
+};
+export declare const energyTransfer: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=energyTransfer.d.ts.map

package/lib/exercises/pc/energy/energyTransfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"energyTransfer.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/energyTransfer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAiEF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.energyTransfer = void 0;
+const frenchify_1 = require("../../../math/utils/latex/frenchify");
+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 substances = [
+    { name: "eau", latentHeat: 334 }, // kJ/kg for melting ice
+    { name: "fer", latentHeat: 276 }, // kJ/kg for melting iron
+    { name: "aluminium", latentHeat: 397 }, // kJ/kg for melting aluminium
+    { name: "or", latentHeat: 64 }, // kJ/kg for melting gold
+    { name: "argent", latentHeat: 105 }, // kJ/kg for melting silver
+    { name: "plomb", latentHeat: 24 }, // kJ/kg for melting lead
+    { name: "cuivre", latentHeat: 207 }, // kJ/kg for melting copper
+    { name: "zinc", latentHeat: 112 }, // kJ/kg for melting zinc
+    { name: "étain", latentHeat: 60 }, // kJ/kg for melting tin
+    { name: "nickel", latentHeat: 297 }, // kJ/kg for melting nickel
+];
+const getEnergyTransferQuestion = () => {
+    const substance = substances[Math.floor(Math.random() * substances.length)];
+    const mass = (0, round_1.round)((0, randfloat_1.randfloat)(0.1, 10), 2); // Mass in kilograms
+    const latentHeat = substance.latentHeat; // Latent heat in kJ/kg
+    const energy = (0, round_1.round)(mass * latentHeat, 2);
+    const instruction = `Un échantillon de $${(0, frenchify_1.frenchify)(mass)}\\ kg$ ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(substance.name) ? "d'" : "de "}${substance.name} subit un changement d'état. La chaleur latente ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(substance.name) ? "d'" : "de "}${substance.name} est de $${latentHeat}\\ kJ/kg$.
+  Calculer l'énergie transférée lors du changement d'état en $\\ kJ$`;
+    const question = {
+        answer: energy.toTree().toTex(),
+        instruction,
+        keys: ["kJ"],
+        answerFormat: "tex",
+        identifiers: { substance: substance.name, mass, latentHeat, energy },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, substance, mass, latentHeat, energy }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongEnergy = (0, round_1.round)(energy + (0, randfloat_1.randfloat)(-50, 50), 2);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongEnergy.toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, energy }) => {
+    const validanswer1 = `${energy}\\kJ`;
+    const validanswer2 = energy.toTree().toAllValidTexs();
+    let latexs = [];
+    latexs.push(validanswer1, ...validanswer2);
+    console.log(latexs);
+    return latexs.includes(ans);
+};
+exports.energyTransfer = {
+    id: "energyTransfer",
+    label: "Calculer l'énergie transférée lors d'un changement d'état",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Constitution et transformations de la matière"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEnergyTransferQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

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

@@ -0,0 +1,9 @@
+export * from "./energyTransfer";
+export * from "./kineticEnergyOrMassOrSpeed";
+export * from "./efficencyOfConverter";
+export * from "./combustionTransferEnergy";
+export * from "./calorificValue";
+export * from "./combustionTransferEnergy2";
+export * from "./thermalEnergyTransferCalculation";
+export * from "./efficiencyCalculation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC"}

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

@@ -0,0 +1,24 @@
+"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("./energyTransfer"), exports);
+__exportStar(require("./kineticEnergyOrMassOrSpeed"), exports);
+__exportStar(require("./efficencyOfConverter"), exports);
+__exportStar(require("./combustionTransferEnergy"), exports);
+__exportStar(require("./calorificValue"), exports);
+__exportStar(require("./combustionTransferEnergy2"), exports);
+__exportStar(require("./thermalEnergyTransferCalculation"), exports);
+__exportStar(require("./efficiencyCalculation"), exports);

package/lib/exercises/pc/energy/kineticEnergyOrMassOrSpeed.d.ts

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

package/lib/exercises/pc/energy/kineticEnergyOrMassOrSpeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kineticEnergyOrMassOrSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/kineticEnergyOrMassOrSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kineticEnergyOrMassOrSpeed = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const frenchify_1 = require("../../../math/utils/latex/frenchify");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const measure_1 = require("../../../pc/measure/measure");
+const distanceUnits_1 = require("../../../pc/units/distanceUnits");
+const divideUnit_1 = require("../../../pc/units/divideUnit");
+const energyUnit_1 = require("../../../pc/units/energyUnit");
+const massUnits_1 = require("../../../pc/units/massUnits");
+const timeUnits_1 = require("../../../pc/units/timeUnits");
+const random_1 = require("../../../utils/random");
+const shuffle_1 = require("../../../utils/shuffle");
+const speedUnit = new divideUnit_1.DivideUnit(distanceUnits_1.DistanceUnit.m, timeUnits_1.TimeUnit.s);
+const getKineticEnergyOrMassOrSpeedQuestion = () => {
+    const exercise = getExericse();
+    const question = {
+        instruction: exercise.instruction,
+        answer: exercise.answer,
+        hint: exercise.hint,
+        correction: exercise.correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            isAsking: exercise.isAsking,
+            mass: exercise.mass,
+            velocity: exercise.velocity,
+            kineticEnergy: exercise.kineticEnergy,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isAsking, mass, velocity, kineticEnergy }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const nbAnswer = getAnswer(isAsking, mass, velocity, kineticEnergy);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, frenchify_1.frenchify)(Number.isInteger(nbAnswer)
+            ? (0, randint_1.randint)(nbAnswer - 10, nbAnswer + 11, [nbAnswer])
+            : (0, randfloat_1.randfloat)(nbAnswer - 10, nbAnswer + 11, 2, [nbAnswer])) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getExericse = () => {
+    const mass = (0, randint_1.randint)(9, 16) * 100;
+    const massMeasure = new measure_1.Measure(mass, 0, massUnits_1.MassUnit.kg);
+    const velocity = Math.floor(Math.random() * 20 + 10);
+    const velocityMeasure = new measure_1.Measure(velocity, 0, speedUnit);
+    const kineticEnergy = (0, round_1.round)((0.5 * mass * velocity ** 2) / 1000, 2);
+    const kineticEnergyMeasure = new measure_1.Measure(kineticEnergy, 0, energyUnit_1.EnergyUnit.kJ);
+    const isAsking = (0, random_1.random)(["la masse", "l'énergie cinétique", "la vitesse"]);
+    const hint = `L'énergie cinétique $(E_c)$ d'un objet en mouvement est donnée par la formule, $E_c=\\frac{1}{2}m \\times v^2$ :
+- $m$ est la masse de l'objet en $(${massUnits_1.MassUnit.kg.toTex()})$
+- $v$ est la vitesse de l'objet en $(${new divideUnit_1.DivideUnit(distanceUnits_1.DistanceUnit.m, timeUnits_1.TimeUnit.s).toTex()})$
+- $E_c$ est l'énergie cinétique de l'objet en $(${energyUnit_1.EnergyUnit.J.toTex()})$`;
+    const correction = getCorrection(isAsking, kineticEnergyMeasure, massMeasure, velocityMeasure);
+    const instruction = getInstruction(isAsking, massMeasure, velocityMeasure, kineticEnergyMeasure);
+    const answer = (0, frenchify_1.frenchify)((0, round_1.round)(getAnswer(isAsking, mass, velocity, kineticEnergy), 2));
+    return {
+        instruction,
+        answer,
+        hint,
+        correction,
+        mass,
+        velocity,
+        kineticEnergy,
+        isAsking,
+    };
+};
+const getAnswer = (isAsking, mass, velocity, kineticEnergy) => {
+    switch (isAsking) {
+        case "l'énergie cinétique":
+            return (0.5 * mass * velocity ** 2) / 1000;
+        case "la masse":
+            return (kineticEnergy * 1000 * 2) / velocity ** 2;
+        case "la vitesse":
+            return Math.sqrt((kineticEnergy * 1000 * 2) / mass);
+    }
+    return 0;
+};
+const getInstruction = (isAsking, massMeasure, velocityMeasure, kineticEnergyMeasure) => {
+    switch (isAsking) {
+        case "l'énergie cinétique":
+            return `Une voiture ayant une masse de $${massMeasure.toTex({
+                notScientific: true,
+            })}$ qui se déplace le long d'une route. La voiture accélère et atteint une vitesse de $${velocityMeasure.toTex({ notScientific: true })}$.
+      $\\\\$Calculer l'énergie cinétique (en $${energyUnit_1.EnergyUnit.kJ.toTex()}$) de la voiture lorsqu'elle atteint cette vitesse.`;
+        case "la masse":
+            return `Une voiture ayant une énergie cinétique de $${kineticEnergyMeasure.toTex({ notScientific: true })}$ qui se déplace le long d'une route. La voiture accélère et atteint une vitesse de $${velocityMeasure.toTex({ notScientific: true })}$.
+      $\\\\$Calculer la masse (en $${massUnits_1.MassUnit.kg.toTex()}$) de la voiture lorsqu'elle atteint cette vitesse.`;
+        case "la vitesse":
+            return `Une voiture ayant une masse de $${massMeasure.toTex({
+                notScientific: true,
+            })}$ qui se déplace le long d'une route. L'énergie cinétique de la voiture est de $${kineticEnergyMeasure.toTex({ notScientific: true })}$.
+      $\\\\$Calculer la vitesse (en $${speedUnit.toTex()}$) de la voiture.`;
+    }
+    return "";
+};
+const getCorrection = (isAsking, kineticEnergyMeasure, massMeasure, velocityMeasure) => {
+    const kineticEnergyJ = kineticEnergyMeasure.convert("J");
+    switch (isAsking) {
+        case "l'énergie cinétique":
+            return `Utiliser la formule de l'énergie cinétique, $E_c=\\frac{1}{2}m \\times v^2$:
+1. $E_c=\\frac{1}{2} ${massMeasure.toTex({
+                notScientific: true,
+                hideUnit: true,
+            })} \\times ${velocityMeasure.toTex({
+                hideUnit: true,
+                notScientific: true,
+            })}^2\\ \\Rightarrow E_c=${kineticEnergyJ.toTex({
+                notScientific: true,
+            })}$
+2. Convertir les $${energyUnit_1.EnergyUnit.J.toTex()}$ en $${energyUnit_1.EnergyUnit.kJ.toTex()}$, $E_c=\\frac{${kineticEnergyJ.toTex({
+                notScientific: true,
+            })}}{1000} \\Rightarrow E_c=${kineticEnergyMeasure.toTex({
+                notScientific: true,
+            })}$`;
+        case "la masse":
+            return `Utiliser la formule de l'énergie cinétique, $E_c=\\frac{1}{2}m \\times v^2$:
+1. Convertir les $${energyUnit_1.EnergyUnit.kJ.toTex()}$ en $${energyUnit_1.EnergyUnit.J.toTex()}$, $${kineticEnergyMeasure.toTex({
+                notScientific: true,
+            })}\\Rightarrow ${kineticEnergyJ.toTex({ notScientific: true })}$ 
+2. $m=\\frac{2E_c}{v^2} \\Rightarrow m=\\frac{2 \\times ${kineticEnergyJ.toTex({
+                hideUnit: true,
+                notScientific: true,
+            })}}{${velocityMeasure.toTex({
+                notScientific: true,
+                hideUnit: true,
+            })}^2}\\ \\Rightarrow m=${massMeasure.toTex({
+                notScientific: true,
+            })}$`;
+        case "la vitesse":
+            return `Utiliser la formule de l'énergie cinétique, $E_c=\\frac{1}{2}m \\times v^2$:
+1. Convertir les $${energyUnit_1.EnergyUnit.kJ.toTex()}$ en $${energyUnit_1.EnergyUnit.J.toTex()}$, $${kineticEnergyMeasure.toTex({
+                notScientific: true,
+            })}\\Rightarrow ${kineticEnergyJ.toTex({ notScientific: true })}$ 
+2. $v=\\sqrt{\\frac{2E_c}{m}} \\Rightarrow v=\\sqrt{\\frac{2 \\times ${kineticEnergyJ.toTex({
+                hideUnit: true,
+                notScientific: true,
+            })}}{${massMeasure.toTex({
+                hideUnit: true,
+                notScientific: true,
+            })}}}\\ \\Rightarrow v=${velocityMeasure.toTex({
+                notScientific: true,
+            })}$`;
+    }
+};
+exports.kineticEnergyOrMassOrSpeed = {
+    id: "kineticEnergyOrMassOrSpeed",
+    label: "Calculer l'énergie cinétique",
+    levels: ["4ème", "3ème", "2nde", "1reSpé"],
+    sections: ["Mécanique"],
+    subject: "Physique",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getKineticEnergyOrMassOrSpeedQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    mass: number;
+    specificHeat: number;
+    initialTemp: number;
+    finalTemp: number;
+    variable: "E_th" | "m" | "c" | "deltaT";
+};
+export declare const thermalEnergyTransferCalculation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=thermalEnergyTransferCalculation.d.ts.map

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thermalEnergyTransferCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/thermalEnergyTransferCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC;CACzC,CAAC;AA4NF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}