math-exercises 2.2.2 → 2.2.4

package/lib/exercises/pc/electricity/calculateIntensityInSerieOrParallel.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateIntensityInSerieOrParallel = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/random");
+const getCalculateIntensityInSerieOrParallelQuestion = () => {
+    const exo = generateExercise();
+    const schemaIllu = exo.circuit === "Série"
+        ? " https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/electricCircuit3.png"
+        : "https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/electricCircuit2.png";
+    const question = {
+        answer: exo.answer + "",
+        instruction: exo.instruction + `![](${schemaIllu})`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            l1: exo.l1,
+            l2: exo.l2,
+            isAsking: exo.isAsking,
+            circuit: exo.circuit,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isAsking, circuit, l1, l2 }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(l1, l2, isAsking, circuit).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value + ""));
+    while (propositions.length < n) {
+        let random = (0, randint_1.randint)(+answer - Math.min(5, +answer - 1), +answer + 6, [+answer]) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, random);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateExercise = () => {
+    const l1 = (0, randint_1.randint)(10, 60);
+    const isAsking = (0, random_1.random)(["L", "L1", "L2"]);
+    const circuit = (0, random_1.random)(["Série", "Parallèle", "Parallèle"]);
+    const l2 = circuit === "Série" ? l1 : (0, randint_1.randint)(10, 60);
+    const l = circuit === "Série" ? l1 : l1 + l2;
+    const values = [l, l1, l2];
+    const instruction = getInstruction(isAsking, circuit, l1, l2, l);
+    const answer = circuit === "Série"
+        ? l1
+        : values[["L", "L1", "L2"].findIndex((value) => value === isAsking)];
+    return {
+        instruction,
+        answer,
+        l1,
+        l2,
+        l,
+        isAsking,
+        circuit,
+    };
+};
+const getInstruction = (isAsking, circuit, l1, l2, l) => {
+    if (circuit === "Série")
+        return `Pour ce circuit schématisé, l'intensité du courant qui traverse la lampe $L_1$ est de $${l1}$ $mA$, celle traversant la lampe $L_2$ est de $${l2}$ $mA$. \n \\
+  Calculer l'intensité du courant qui traverse la pile en $mA$.`;
+    switch (isAsking) {
+        case "L":
+            return `Pour ce circuit schématisé, l'intensité du courant qui traverse la lampe $L_1$ est de $${l1}$ $mA$, celle traversant la lampe $L_2$ est de $${l2}$ $mA$. \n \\
+  Calculer l'intensité du courant qui traverse la pile en $mA$.`;
+        case "L1":
+            return `Pour ce circuit schématisé, l'intensité du courant qui traverse la lampe $L_2$ est de $${l2}$ $mA$, celle traversant la pile est de $${l}$ $mA$. \n \\
+  Calculer l'intensité du courant qui traverse la lampe $L_1$ en $mA$.`;
+        case "L2":
+            return `Pour ce circuit schématisé, l'intensité du courant qui traverse la lampe $L_1$ est de $${l1}$ $mA$, celle traversant la pile est de $${l}$ $mA$. \n \\
+    Calculer l'intensité du courant qui traverse la lampe $L_2$ en $mA$.`;
+        default:
+            return "";
+    }
+};
+const generatePropositions = (l1, l2, isAsking, circuit) => {
+    if (circuit === "Série")
+        return [l1 + l2, Math.floor(l1 / 2)];
+    switch (isAsking) {
+        case "L":
+            return [l1, l2, Math.abs(l1 - l2)];
+        case "L1":
+            return [l2, l1 + l2, l1 + l2 + l2];
+        case "L2":
+            return [l1, l1 + l2, l2 + l1 + l1];
+        default:
+            return [];
+    }
+};
+exports.calculateIntensityInSerieOrParallel = {
+    id: "calculateIntensityInSerieOrParallel",
+    label: "Calcul d'intnsité dans un circuit électrique en série/parallèle",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculateIntensityInSerieOrParallelQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/electricity/calculateVoltage.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    E: number;
+    I: number;
+    r: number;
+    R: number;
+    isAsking: string;
+};
+export declare const calculateVoltage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateVoltage.d.ts.map

package/lib/exercises/pc/electricity/calculateVoltage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateVoltage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/calculateVoltage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiKF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/pc/electricity/calculateVoltage.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateVoltage = 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 random_1 = require("../../../utils/random");
+const getCalculateVoltageQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.answer,
+        instruction: exo.instruction,
+        keys: [],
+        correction: exo.correction,
+        hint: exo.hint,
+        answerFormat: "tex",
+        identifiers: {
+            E: exo.E,
+            I: exo.I,
+            r: exo.r,
+            R: exo.R,
+            isAsking: exo.isAsking,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, E, I, R, r, isAsking }) => {
+    const propositions = [];
+    const correctAns = +getCorrectAnswer(isAsking, E, I, r, R).toFixed(0);
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(E, I, r, R, isAsking).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    while (propositions.length < n) {
+        let random = (0, randint_1.randint)(correctAns - 10, correctAns + 11, [correctAns]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, isAsking, E, I, r, R }) => {
+    const scientificAns = getCorrectAnswer(isAsking, E, I, r, R).toScientific(0);
+    return [answer, scientificAns].includes(ans);
+};
+const generatePropositions = (E, I, r, R, isAsking) => {
+    const first = E.frenchify();
+    let second = (0).frenchify();
+    switch (isAsking) {
+        case "du générateur":
+            second = (+getCorrectAnswer("de la résistance", E, I, r, R).toFixed(0)).frenchify();
+            break;
+        case "de la résistance":
+            second = (+getCorrectAnswer("du générateur", E, I, r, R).toFixed(0)).frenchify();
+            break;
+        case "de la diode":
+            second = (+(getCorrectAnswer("de la résistance", E, I, r, R) +
+                getCorrectAnswer("du générateur", E, I, r, R)).toFixed(0)).frenchify();
+            break;
+    }
+    return [first, second];
+};
+const generateExercise = () => {
+    const R = (0, randint_1.randint)(1, 21);
+    const I = (0, randfloat_1.randfloat)(0.1, 4, 1);
+    const r = (0, randint_1.randint)(1, 6);
+    const EMin = Math.floor(r * I + R * I);
+    const E = (0, randint_1.randint)(EMin + 5, EMin + 51);
+    const isAsking = (0, random_1.random)(["du générateur", "de la résistance", "de la diode"]);
+    const instruction = `Dans un circuit électrique, on trouve : 
+  
+  - Une source de tension $E=${E}$ volts, avec une résistance interne $r=${r}\\ \\Omega$. 
+
+  - Un conducteur ohmique de résistance $R=${R}\\ \\Omega$. 
+  
+  - Un courant $I=${I.frenchify()}\\ A$ circule à travers la résistance. 
+  
+  Calculez la tension U aux bornes ${isAsking} en $V$, arrondie à l'unité   
+  ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/electricCircuit1NoLetters.png)`;
+    const answer = getCorrectAnswer(isAsking, E, I, r, R).toFixed(0);
+    const correction = getCorrection(isAsking, answer);
+    const hint = getHint(isAsking);
+    return {
+        instruction,
+        answer: answer,
+        correction,
+        hint,
+        isAsking,
+        E,
+        I,
+        r,
+        R,
+    };
+};
+const getCorrectAnswer = (isAsking, E, I, r, R) => {
+    switch (isAsking) {
+        case "du générateur":
+            return E - r * I;
+        case "de la résistance":
+            return R * I;
+        case "de la diode":
+            const U1 = E - r * I;
+            const U2 = R * I;
+            return U1 - U2;
+        default:
+            return 0;
+    }
+};
+const getHint = (isAsking) => {
+    switch (isAsking) {
+        case "de la diode":
+            return `Calculer d'abord la tension aux bornes du conducteur ohmique et du générateur, puis appliquer la loi des mailles.`;
+        case "du générateur":
+            return `Appliquer la formule qui met en relation la tension $U$ aux bornes du générateur, la résistance interne du générateur $r$ et l'intensité $I$.`;
+        case "de la résistance":
+            return `Appliquer la loi d'ohm.`;
+        default:
+            return "";
+    }
+};
+const getCorrection = (isAsking, answer) => {
+    switch (isAsking) {
+        case "du générateur":
+            return `Appliquer la formule qui met en relation la tension $U$ aux bornes du générateur, la résistance interne du générateur $r$ et l'intensité $I$.\n
+$U=E-r \\cdot I\\ \\Rightarrow\\ U=${answer}\\ V$`;
+        case "de la résistance":
+            return `Appliquer la loi d'ohm : $U=R \\cdot I\\ \\Rightarrow\\ U=${answer}\\ V$`;
+        case "de la diode":
+            return `1 - Calculer la tension aux bornes du générateur $U=E-r \\cdot I$.\n
+2 - Calculer la tension aux bornes du conducteur ohmique $U_1=R \\cdot I$.\n
+3 - Appliquer la loi des mailles $U=U_1+U_2\\ \\Rightarrow\\ U_2=U-U_1\\ \\Rightarrow\\ U_2=${answer}\\ V$`;
+    }
+};
+exports.calculateVoltage = {
+    id: "calculateVoltage",
+    label: "Calcul de tension au borne d'une résistance",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculateVoltageQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/electricity/electricPowerOrEnergyCalculation.d.ts

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

package/lib/exercises/pc/electricity/electricPowerOrEnergyCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electricPowerOrEnergyCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/electricPowerOrEnergyCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAwFtE,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/pc/electricity/electricPowerOrEnergyCalculation.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.electricPowerOrEnergyCalculation = 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 random_1 = require("../../../utils/random");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const powers = [15, 18, 50, 25, 65, 66, 7.5, 10]; // Puissances en watts
+const durations = [60, 3600, 86400, 604800]; // Durées en secondes (1 min, 1 h, 1 jour, 1 semaine)
+const getElectricPowerOrEnergyQuestion = () => {
+    const power = (0, random_1.random)(powers);
+    const seconds = (0, random_1.random)(durations);
+    const energy = power * seconds;
+    const isCalculatingEnergy = (0, coinFlip_1.coinFlip)();
+    const questionText = isCalculatingEnergy
+        ? `Un appareil a une puissance de $P = ${(0, frenchify_1.frenchify)(power)}\\ \\text{W}$ et fonctionne pendant $t = ${(0, frenchify_1.frenchify)(seconds)}\\ \\text{s}$. Calculez l'énergie électrique $E$ en $\\text{J}$ fournie par cet appareil.`
+        : `Un appareil consomme une énergie $E = ${(0, frenchify_1.frenchify)(energy)}\\ \\text{J}$ en $t = ${(0, frenchify_1.frenchify)(seconds)}\\ \\text{s}$. Calculez la puissance $P$ en $\\text{W}$ de cet appareil.`;
+    const answer = isCalculatingEnergy ? energy : (0, round_1.round)(energy / seconds, 2);
+    const hint = `La relation entre l'énergie électrique, la puissance et le temps est donnée par la formule :
+    $$
+    E = P \\times t
+    $$
+    Réarrangez cette formule pour isoler la variable à trouver.`;
+    const correction = `La relation entre l'énergie électrique, la puissance et le temps est :
+    $$
+    E = P \\times t
+    $$
+
+Pour résoudre ce problème, nous devons réorganiser la formule pour isoler la variable inconnue.
+
+${isCalculatingEnergy
+        ? `$$E = P \\times t = ${(0, frenchify_1.frenchify)(power)} \\times ${(0, frenchify_1.frenchify)(seconds)} = ${(0, frenchify_1.frenchify)(answer)}\\ \\text{J}$$`
+        : `$$P = \\frac{E}{t} = \\frac{${(0, frenchify_1.frenchify)(energy)}}{${(0, frenchify_1.frenchify)(seconds)}} = ${(0, frenchify_1.frenchify)(answer)}\\ \\text{W}$$`}`;
+    const question = {
+        answer: answer.toTree().toTex(),
+        instruction: questionText,
+        hint,
+        correction,
+        keys: ["P", "E", "t"],
+        answerFormat: "tex",
+        identifiers: { power, seconds, energy },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, power, seconds, energy }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const wrongAnswers = [
+        (0, round_1.roundSignificant)(power * seconds * 0.5, 2),
+        (0, round_1.roundSignificant)(energy * 0.1, 2),
+        (0, round_1.roundSignificant)(seconds / power, 2),
+        (0, round_1.roundSignificant)(power / seconds, 2),
+    ];
+    wrongAnswers.forEach((wrongAnswer) => {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    });
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(0.1, 5, 2).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.electricPowerOrEnergyCalculation = {
+    id: "electricPowerOrEnergyCalculation",
+    label: "Calculer la puissance ou l'énergie électrique",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getElectricPowerOrEnergyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

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

@@ -1,3 +1,10 @@
 export * from "./electricChargeFromIntensity";
 export * from "./electricEnergyFromPower";
+export * from "./calculateVoltage";
+export * from "./ohmicConductorOrGenerator";
+export * from "./kirchhoffVoltageLaw";
+export * from "./calculateIntensityInSerieOrParallel";
+export * from "./calculateIntensity";
+export * from "./ohmLaw";
+export * from "./electricPowerOrEnergyCalculation";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uCAAuC,CAAC;AACtD,cAAc,sBAAsB,CAAC;AACrC,cAAc,UAAU,CAAC;AACzB,cAAc,oCAAoC,CAAC"}

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

@@ -16,3 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./electricChargeFromIntensity"), exports);
 __exportStar(require("./electricEnergyFromPower"), exports);
+__exportStar(require("./calculateVoltage"), exports);
+__exportStar(require("./ohmicConductorOrGenerator"), exports);
+__exportStar(require("./kirchhoffVoltageLaw"), exports);
+__exportStar(require("./calculateIntensityInSerieOrParallel"), exports);
+__exportStar(require("./calculateIntensity"), exports);
+__exportStar(require("./ohmLaw"), exports);
+__exportStar(require("./electricPowerOrEnergyCalculation"), exports);

package/lib/exercises/pc/electricity/kirchhoffVoltageLaw.d.ts

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

package/lib/exercises/pc/electricity/kirchhoffVoltageLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kirchhoffVoltageLaw.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/kirchhoffVoltageLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAoHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/pc/electricity/kirchhoffVoltageLaw.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kirchhoffVoltageLaw = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/random");
+const getKirchhoffVoltageLawQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.answer + "",
+        instruction: exo.instruction +
+            `![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/electricCircuit1.png)`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            isAsking: exo.isAsking,
+            uAB: exo.uAB,
+            uED: exo.uED,
+            uDC: exo.uDC,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, isAsking, uAB, uDC, uED }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generateProposition(isAsking, uAB, uED, uDC).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value + ""));
+    while (propositions.length < n) {
+        let random = (0, randint_1.randint)(+answer - Math.min(5, +answer), +answer + 6, [
+            +answer,
+        ]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateProposition = (isAsking, uAB, uED, uDC) => {
+    switch (isAsking) {
+        case "UAB":
+            return [uDC + uED, Math.abs(uDC - uED)];
+        case "UED":
+            return [uAB + uDC, uAB, uDC];
+        case "UDC":
+            return [uAB + uED, uAB, uED];
+    }
+    return [uAB - uED, uAB - uDC, uED + uDC];
+};
+const generateExercise = () => {
+    const uED = (0, randint_1.randint)(1, 60);
+    const uDC = (0, randint_1.randint)(1, 60);
+    const uAB = uED + uDC;
+    const isAsking = (0, random_1.random)(["UAB", "UDC", "UED"]);
+    const instruction = getInstruction(isAsking, uAB, uDC, uED);
+    const answer = getAnswer(isAsking, uAB, uDC, uED);
+    return {
+        instruction,
+        answer,
+        isAsking,
+        uAB,
+        uED,
+        uDC,
+    };
+};
+const getInstruction = (isAsking, uAB, uDC, uED) => {
+    switch (isAsking) {
+        case "UAB":
+            return `Un circuit est alimenté par une pile. \n \\
+      La tension $U_{DC}$ aux bornes de la diode est $${uDC}$ $V$. \n \\
+      La tension $U_{ED}$ aux bornes du conducteur ohmique est $${uED}$ $V$. \n \\
+      Cacluler la tension de la pile $U_{AB}$.`;
+        case "UED":
+            return `Un circuit est alimenté par une pile de $${uAB}$ $V$. \n \\
+      La tension $U_{DC}$ aux bornes de la diode est $${uDC}$ $V$. \n \\
+      Calculer la tension $U_{ED}$ aux bornes du conducteur ohmique.`;
+        case "UDC":
+            return `Un circuit est alimenté par une pile de $${uAB}$ $V$. \n \\
+      La tension $U_{ED}$ aux bornes du conducteur ohmique est $${uED}$ $V$. \n \\
+      Calculer la tension $U_{DC}$ aux bornes de la diode.`;
+        default:
+            return "";
+    }
+};
+const getAnswer = (isAsking, uAB, uDC, uED) => {
+    switch (isAsking) {
+        case "UAB":
+            return uDC + uED;
+        case "UED":
+            return uAB - uDC;
+        case "UDC":
+            return uAB - uED;
+        default:
+            return 0;
+    }
+};
+exports.kirchhoffVoltageLaw = {
+    id: "kirchhoffVoltageLaw",
+    label: "Application de la loi de maille",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getKirchhoffVoltageLawQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/electricity/ohmLaw.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    voltage: number;
+    current: number;
+    resistance: number;
+    target: string;
+    targetValue: number;
+};
+export declare const OhmLawExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=ohmLaw.d.ts.map

package/lib/exercises/pc/electricity/ohmLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ohmLaw.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/ohmLaw.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}

package/lib/exercises/pc/electricity/ohmLaw.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OhmLawExercise = void 0;
+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 getOhmLawQuestion = () => {
+    const resistance = (0, randint_1.randint)(1, 50);
+    const current = (0, round_1.round)((0, randfloat_1.randfloat)(0.1, 4, 2), 2);
+    const voltage = (0, round_1.round)(resistance * current, 2);
+    const variables = [
+        { name: "résistance", value: resistance, unit: " \\ \\Omega", symbol: "R" },
+        { name: "courant", value: current, unit: "\\ A", symbol: "I" },
+        { name: "tension", value: voltage, unit: "\\ V", symbol: "U" },
+    ];
+    const randomIndex = (0, randint_1.randint)(0, variables.length);
+    const targetVariable = variables[randomIndex];
+    const knownVariables = variables.filter((_, index) => index !== randomIndex);
+    const instruction = `Lors d'une expérience en classe de physique, vous devez étudier le comportement d'un conducteur ohmique. Vous avez connecté le conducteur à un circuit électrique et mesuré les valeurs suivantes :
+  - ${knownVariables[0].name.charAt(0).toUpperCase() +
+        knownVariables[0].name.slice(1)} : $${knownVariables[0].symbol} = ${(0, round_1.round)(knownVariables[0].value, 2)
+        .toTree()
+        .toTex()} ${knownVariables[0].unit}$
+  - ${knownVariables[1].name.charAt(0).toUpperCase() +
+        knownVariables[1].name.slice(1)} : $${knownVariables[1].symbol} = ${(0, round_1.round)(knownVariables[1].value, 2)
+        .toTree()
+        .toTex()} ${knownVariables[1].unit}$. \n
+  Déterminez ${targetVariable.name === "tension" || targetVariable.name === "résistance"
+        ? "la"
+        : "le"} ${targetVariable.name} ${targetVariable.name === "tension"
+        ? "aux bords du"
+        : targetVariable.name === "courant"
+            ? "qui traverse le"
+            : "du"} conducteur.`;
+    const hint = `Rappelez-vous la loi d'Ohm : $U = R \\cdot I$.`;
+    const correction = `La loi d'Ohm est donnée par :
+  $U = R \\cdot I$. En utilisant les valeurs fournies pour ${knownVariables[0].name} et ${knownVariables[1].name}, vous pouvez résoudre pour ${targetVariable.name === "tension" || targetVariable.name === "résistance"
+        ? "la"
+        : "le"} ${targetVariable.name} :
+  $${targetVariable.symbol} = ${(0, round_1.round)(knownVariables[0].value, 2)
+        .toTree()
+        .toTex()} \\times ${(0, round_1.round)(knownVariables[1].value, 2)
+        .toTree()
+        .toTex()} = ${(0, round_1.round)(targetVariable.value, 2).toTree().toTex()}\\ ${targetVariable.unit}$. \n
+  Donc, ${targetVariable.name === "tension" || targetVariable.name === "résistance"
+        ? "la"
+        : "le"} ${targetVariable.name} est $${(0, round_1.round)(targetVariable.value, 2)
+        .toTree()
+        .toTex()}\\ ${targetVariable.unit}$.`;
+    const question = {
+        answer: (0, round_1.round)(targetVariable.value, 2).toTree().toTex(),
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            voltage,
+            current,
+            resistance,
+            target: targetVariable.name,
+            targetValue: targetVariable.value,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, voltage, current, resistance, target }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    if (target === "tension") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(voltage * (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(voltage / (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+    }
+    else if (target === "courant") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(current * (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(current / (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+    }
+    else if (target === "résistance") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(resistance * (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(resistance / (0, randfloat_1.randfloat)(0.1, 2), 2)
+            .toTree()
+            .toTex());
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(10, 100, 2).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, targetValue }) => {
+    const validAnswer1 = (0, round_1.round)(targetValue, 2).toTree().toTex();
+    const validAnswer2 = targetValue.toScientific(2).toTex();
+    const validAnswer3 = targetValue.toScientific(1).toTex();
+    const validAnswer4 = targetValue.toScientific(3).toTex();
+    let latexs = [];
+    latexs.push(validAnswer1, validAnswer2, validAnswer3, validAnswer4);
+    return latexs.includes(ans);
+};
+exports.OhmLawExercise = {
+    id: "ohmLaw",
+    label: "Utiliser la loi d'Ohm pour calculer tension, courant ou résistance",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Électricité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getOhmLawQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/electricity/ohmicConductorOrGenerator.d.ts

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

package/lib/exercises/pc/electricity/ohmicConductorOrGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ohmicConductorOrGenerator.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/ohmicConductorOrGenerator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG,EAAE,CAAC;AA6FtB,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}