math-exercises 2.2.2 → 2.2.4

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.averageSpeed = 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 measure_1 = require("../../../pc/measure/measure");
+const distanceUnits_1 = require("../../../pc/units/distanceUnits");
+const timeUnits_1 = require("../../../pc/units/timeUnits");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const timeUnits = [timeUnits_1.TimeUnit.h, timeUnits_1.TimeUnit.mi];
+const distanceUnitValues = [distanceUnits_1.DistanceUnit.km, distanceUnits_1.DistanceUnit.m];
+const getAverageSpeedQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.answer.toTex(),
+        instruction: exo.instruction,
+        keys: [],
+        hint: "Rappel : vitesse moyenne = $\\frac{\\text{distance}}{\\text{temps}}$ $m \\cdot s^{-1}$",
+        correction: exo.correction,
+        answerFormat: "tex",
+        identifiers: { distance: exo.distance, time: exo.time },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, distance, time }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const distanceMeasure = new measure_1.Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
+    const timeMeasure = new measure_1.Measure(time.value, 0, timeUnits[time.unitIndex]);
+    genearatePropositions(distanceMeasure, timeMeasure).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    const division = distanceMeasure
+        .convert("m")
+        .divide(timeMeasure.convert("s"));
+    const divisionValue = division.significantPart * division.exponent;
+    while (propositions.length < n) {
+        let random = (0, randfloat_1.randfloat)(divisionValue - 10, divisionValue + 11);
+        (0, exercise_1.tryToAddWrongProp)(propositions, new measure_1.Measure(random, 0, division.getUnit()).toSignificant(2).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const genearatePropositions = (distance, time) => {
+    const distanceInMeter = distance.convert("m");
+    const timeInSeconds = time.convert("s");
+    return [
+        distanceInMeter.times(timeInSeconds).toSignificant(2).toTex(),
+        distanceInMeter.divide(time).toSignificant(2).toTex(),
+        distance.divide(timeInSeconds).toSignificant(2).toTex(),
+        distance.divide(time).toSignificant(2).toTex(),
+    ];
+};
+const isAnswerValid = (ans, { answer, distance, time }) => {
+    const distanceMeasure = new measure_1.Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
+    const timeMeasure = new measure_1.Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
+    return [
+        answer,
+        distanceMeasure
+            .divide(timeMeasure)
+            .toSignificant(2)
+            .toTex({ hideUnit: true }),
+    ].includes(ans);
+};
+const generateExercise = () => {
+    const distance = { value: (0, randint_1.randint)(70, 151), unitIndex: (0, randint_1.randint)(0, 2) };
+    const time = { value: (0, randint_1.randint)(10, 61), unitIndex: (0, randint_1.randint)(0, 2) };
+    const distanceMeasure = new measure_1.Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
+    const timeMeasure = new measure_1.Measure(time.value, 0, timeUnits[time.unitIndex]);
+    const instruction = `Soit un objet parcourant $${distanceMeasure.toTex({
+        notScientific: true,
+    })}$ en $${timeMeasure.toTex({ notScientific: true })}$. \n \\
+  Caculer la vitesse moyenne de cet objet en $${distanceUnits_1.DistanceUnit.m.toTex()} \\cdot ${timeUnits_1.TimeUnit.s.toTex()}^{-1}$.
+  `;
+    const answer = distanceMeasure
+        .convert("m")
+        .divide(timeMeasure.convert("s"))
+        .toSignificant(2);
+    const correction = getCorrection(distance, time);
+    return {
+        instruction,
+        answer,
+        distance,
+        time,
+        correction,
+    };
+};
+const getCorrection = (distance, time) => {
+    let correction = ``;
+    let step = 1;
+    const distanceMeasure = new measure_1.Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
+    const timeMeasure = new measure_1.Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
+    const calcul = new fractionNode_1.FractionNode(new variableNode_1.VariableNode(distanceMeasure.toSignificant(2).toTex()), new variableNode_1.VariableNode(timeMeasure.toSignificant(2).toTex()));
+    const answer = distanceMeasure.divide(timeMeasure).toSignificant(2).toTex();
+    if (distance.unitIndex === 0)
+        correction = `${step++}. Convertir les $km$ en $m$ : $1km=1000m$.`;
+    switch (time.unitIndex) {
+        case 0:
+            correction = `${correction}
+${step++}. Convertir les heures en secondes : $1h = 3600s$.`;
+            break;
+        case 1:
+            correction = `${correction}
+${step++}. Convertir les minutes en secondes : $1m = 60s$.`;
+    }
+    return `${correction}
+${step}. Appliquer la règle de calcul pour la vitesse moyenne : $${calcul.toTex()} = ${answer}$`;
+};
+exports.averageSpeed = {
+    id: "averageSpeed",
+    label: "Caclul de vitesse moyenne",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAverageSpeedQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/motion/averageSpeedCalculation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    speed: number;
+    distance: number;
+    deltaTime: number;
+    target: "vitesse moyenne" | "distance" | "temps";
+};
+export declare const AverageSpeedCalculationExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=averageSpeedCalculation.d.ts.map

package/lib/exercises/pc/motion/averageSpeedCalculation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA4MF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AverageSpeedCalculationExercise = 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 divideUnit_1 = require("../../../pc/units/divideUnit");
+const timeUnits_1 = require("../../../pc/units/timeUnits");
+const distanceUnits_1 = require("../../../pc/units/distanceUnits");
+const measure_1 = require("../../../pc/measure/measure");
+const getAverageSpeedQuestion = () => {
+    const speed = (0, round_1.round)((0, randfloat_1.randfloat)(900, 1400), 2); // Vitesse en km/h
+    const distance = (0, round_1.round)((0, randfloat_1.randfloat)(100, 2000), 2); // Distance en km
+    const deltaTime = (0, round_1.round)(distance / speed, 2); // Temps en heures
+    const variables = [
+        {
+            name: "vitesse moyenne",
+            value: new measure_1.Measure(speed, 0, new divideUnit_1.DivideUnit(distanceUnits_1.DistanceUnit.km, timeUnits_1.TimeUnit.h)),
+            symbol: "v",
+        },
+        {
+            name: "distance",
+            value: new measure_1.Measure(distance, 0, distanceUnits_1.DistanceUnit.km),
+            symbol: "d",
+        },
+        {
+            name: "temps",
+            value: new measure_1.Measure(deltaTime, 0, timeUnits_1.TimeUnit.h),
+            symbol: "\\Delta t",
+        },
+    ];
+    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 mission d'entraînement, un avion de chasse Rafale a été chronométré et mesuré. Voici les données recueillies :
+  - ${knownVariables[0].name.charAt(0).toUpperCase() +
+        knownVariables[0].name.slice(1)} : $${knownVariables[0].symbol} = ${knownVariables[0].value.toTex({
+        notScientific: true,
+    })}$
+  - ${knownVariables[1].name.charAt(0).toUpperCase() +
+        knownVariables[1].name.slice(1)} : $${knownVariables[1].symbol} = ${knownVariables[1].value.toTex({
+        notScientific: true,
+    })}$. \n
+  Utilisez ces informations pour calculer ${targetVariable.name === "distance" ||
+        targetVariable.name === "vitesse moyenne"
+        ? "la"
+        : "le"} ${targetVariable.name} en $${targetVariable.value.getUnit().toTex()}$.`;
+    const hint = targetVariable.name === "vitesse moyenne"
+        ? `Rappelez-vous la formule de la vitesse moyenne : $v = \\frac{d}{\\Delta t}$.`
+        : targetVariable.name === "distance"
+            ? `Rappelez-vous la formule de la distance : $d = v \\times \\Delta t$.`
+            : `Rappelez-vous la formule du temps : $\\Delta t = \\frac{d}{v}$.`;
+    const correction = targetVariable.name === "vitesse moyenne"
+        ? `La vitesse moyenne est calculée en utilisant la formule $v = \\frac{d}{\\Delta t}$. Donc, $v = \\frac{${(0, round_1.round)(distance, 2)
+            .toTree()
+            .toTex()}}{${(0, round_1.round)(deltaTime, 2).toTree().toTex()}} = ${new measure_1.Measure((0, round_1.round)(distance / deltaTime, 2), 0, targetVariable.value.getUnit()).toTex({ notScientific: true })}$.`
+        : targetVariable.name === "distance"
+            ? `La distance est calculée en utilisant la formule $d = v \\times \\Delta t$. Donc, $d = ${(0, round_1.round)(speed, 2)
+                .toTree()
+                .toTex()} \\times ${(0, round_1.round)(deltaTime, 2)
+                .toTree()
+                .toTex()} = ${new measure_1.Measure((0, round_1.round)(speed * deltaTime, 2), 0, distanceUnits_1.DistanceUnit.km).toTex({ notScientific: true })}$.`
+            : `Le temps est calculé en utilisant la formule $\\Delta t = \\frac{d}{v}$. Donc, $t = \\frac{${(0, round_1.round)(distance, 2)
+                .toTree()
+                .toTex()}}{${(0, round_1.round)(speed, 2).toTree().toTex()}} = ${new measure_1.Measure((0, round_1.round)(distance / speed, 2), 0, timeUnits_1.TimeUnit.h).toTex({ notScientific: true })}$.`;
+    const question = {
+        answer: getCorrectAns(targetVariable.name, speed, distance, deltaTime).toTex({
+            notScientific: true,
+            hideUnit: true,
+        }),
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            speed,
+            distance,
+            deltaTime,
+            target: targetVariable.name,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, speed, distance, deltaTime, target }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    if (target === "vitesse moyenne") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(speed * (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(speed / (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+    }
+    else if (target === "distance") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(distance * (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(distance / (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+    }
+    else if (target === "temps") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(deltaTime * (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(deltaTime / (0, randfloat_1.randfloat)(0.5, 1.5), 2)
+            .toTree()
+            .toTex(), "tex");
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(100, 2000, 2).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getCorrectAns = (targetVariable, speed, distance, deltaTime) => {
+    switch (targetVariable) {
+        case "distance":
+            return new measure_1.Measure((0, round_1.round)(speed * deltaTime, 2), 0, distanceUnits_1.DistanceUnit.km);
+        case "vitesse moyenne":
+            return new measure_1.Measure((0, round_1.round)(distance / deltaTime, 2), 0, new divideUnit_1.DivideUnit(distanceUnits_1.DistanceUnit.km, timeUnits_1.TimeUnit.h));
+        case "temps":
+            return new measure_1.Measure((0, round_1.round)(distance / speed, 2), 0, timeUnits_1.TimeUnit.h);
+    }
+    return new measure_1.Measure(0);
+};
+exports.AverageSpeedCalculationExercise = {
+    id: "averageSpeedCalculation",
+    label: "Calculer la vitesse moyenne, la distance ou le temps d'un objet en mouvement",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAverageSpeedQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.d.ts

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

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"characteristicsOfVelocityVector.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/characteristicsOfVelocityVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.characteristicsOfVelocityVector = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getCharacteristicsOfVelocityVectorQuestion = () => {
+    const exo = generateExercise();
+    const question = {
+        answer: exo.answer.frenchify(),
+        instruction: exo.instruction,
+        keys: [],
+        commands: exo.ggb.commands,
+        coords: exo.ggbCoords,
+        answerFormat: "tex",
+        identifiers: { norm: exo.answer },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, norm }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        let random = (0, randfloat_1.randfloat)(norm - 3, norm + 4, 2, [norm]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateExercise = () => {
+    const delta = (0, randint_1.randint)(2, 11);
+    const ggb = getGgb(delta);
+    const instruction = `
+  Un objet en mouvement rectiligne uniforme est suivi par une chronographie. \n \\
+  Les points marqués par la chronographie sur la bande de papier sont espacés uniformément en temps, avec un intervalle de $${delta}$ seconde entre chaque point. \n \\
+  Calculer la norme du vecteur vitesse $\\overrightarrow{M}$
+  `;
+    const answer = ggb.speedVector.norm;
+    return {
+        instruction,
+        ggb: new geogebraConstructor_1.GeogebraConstructor(ggb.commands, { isAxesRatioFixed: true }),
+        ggbCoords: ggb.coords,
+        answer,
+    };
+};
+const getGgb = (delta) => {
+    const commands = [];
+    const constant = (0, randint_1.randint)(3, 8);
+    const step = (0, randint_1.randint)(3, 8);
+    let speedVector = null;
+    for (let x = 0; x < 4 * step; x += step) {
+        if ((speedVector === null && (0, coinFlip_1.coinFlip)()) || x === 2 * step)
+            speedVector = {
+                x1: x,
+                y1: constant,
+                x2: x + step,
+                y2: constant,
+                norm: +(step / delta).toFixed(2),
+            };
+        commands.push(`Point({${x},${constant}})`);
+    }
+    commands.push(` M = Vector((${speedVector.x1},${speedVector.y1}),(${speedVector.x2},${speedVector.y2}))`, `Text("$\\overrightarrow{\\mathit{M}}$",(${speedVector.x1},${speedVector.y1 + 2}),false,true)`);
+    return {
+        commands,
+        speedVector,
+        coords: [-1, Math.max(step * 5, 20), -2, 10],
+    };
+};
+exports.characteristicsOfVelocityVector = {
+    id: "characteristicsOfVelocityVector",
+    label: "calculer la norme d'un vecteur vitesse",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCharacteristicsOfVelocityVectorQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

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

@@ -0,0 +1,7 @@
+export * from "./characteristicsOfVelocityVector";
+export * from "./typeOfMovement";
+export * from "./averageSpeed";
+export * from "./typeOfAcceleration";
+export * from "./motionReference";
+export * from "./averageSpeedCalculation";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC"}

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

@@ -0,0 +1,22 @@
+"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("./characteristicsOfVelocityVector"), exports);
+__exportStar(require("./typeOfMovement"), exports);
+__exportStar(require("./averageSpeed"), exports);
+__exportStar(require("./typeOfAcceleration"), exports);
+__exportStar(require("./motionReference"), exports);
+__exportStar(require("./averageSpeedCalculation"), exports);

package/lib/exercises/pc/motion/motionReference.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    object1: string;
+    object2: string;
+    reference: "à l'autre" | "au sol";
+};
+export declare const MotionReferenceExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=motionReference.d.ts.map

package/lib/exercises/pc/motion/motionReference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,CAAC;AA0LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

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

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MotionReferenceExercise = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const requiresApostropheBefore_1 = require("../../../utils/requiresApostropheBefore");
+const situations = [
+    {
+        object1: "avion de chasse",
+        object2: "ravitailleur",
+        context: "Vous observez un ravitaillement en vol. Un avion de chasse et un ravitailleur maintiennent une position relative constante pendant le ravitaillement.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "Les deux avions maintiennent une position relative constante.",
+            "au sol": "Les deux avions se déplacent ensemble dans le ciel.",
+        },
+        corrections: {
+            "à l'autre": "Les avions ne sont pas en mouvement l'un par rapport à l'autre car ils maintiennent une position relative constante pendant le ravitaillement. Cela signifie que leur vitesse et direction sont les mêmes.",
+            "au sol": "Les avions sont en mouvement par rapport au sol, car ils volent dans le ciel. Même s'ils restent proches l'un de l'autre, ils se déplacent tous les deux par rapport à la Terre.",
+        },
+    },
+    {
+        object1: "passager",
+        object2: "train",
+        context: "Un passager est assis à l'intérieur d'un train qui roule à une vitesse constante sur une ligne droite.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "Le passager est à l'intérieur du train en mouvement.",
+            "au sol": "Le train se déplace sur les rails.",
+        },
+        corrections: {
+            "à l'autre": "Le passager n'est pas en mouvement par rapport au train car il est assis à l'intérieur du train en mouvement. Pour un observateur à l'intérieur du train, le passager reste immobile.",
+            "au sol": "Le train est en mouvement par rapport au sol car il roule sur les rails. Pour un observateur extérieur au train, il est évident que le train se déplace.",
+        },
+    },
+    {
+        object1: "conducteur",
+        object2: "voiture",
+        context: "Un conducteur est au volant d'une voiture qui circule sur une autoroute.",
+        gender1: "masculin",
+        gender2: "féminin",
+        hints: {
+            "à l'autre": "Le conducteur est au volant de la voiture en mouvement.",
+            "au sol": "La voiture roule sur l'autoroute.",
+        },
+        corrections: {
+            "à l'autre": "Le conducteur n'est pas en mouvement par rapport à la voiture car il est au volant de celle-ci. Pour lui, il reste à la même place dans la voiture, même si celle-ci se déplace.",
+            "au sol": "La voiture est en mouvement par rapport au sol car elle roule sur l'autoroute. Cela signifie que la voiture change de position par rapport à la route et au paysage environnant.",
+        },
+    },
+    {
+        object1: "enfant",
+        object2: "manège",
+        context: "Un enfant est assis dans un manège qui tourne à une vitesse constante.",
+        gender1: "masculin",
+        gender2: "masculin",
+        hints: {
+            "à l'autre": "L'enfant est assis dans le manège en mouvement.",
+            "au sol": "Le manège tourne sur place.",
+        },
+        corrections: {
+            "à l'autre": "L'enfant n'est pas en mouvement par rapport au manège car il est assis dedans. Pour un observateur sur le manège, l'enfant reste à la même place.",
+            "au sol": "Le manège est en mouvement par rapport au sol car il tourne sur place. Même si l'enfant reste assis au même endroit dans le manège, le manège tout entier tourne par rapport au sol.",
+        },
+    },
+    {
+        object1: "Terre",
+        object2: "Lune",
+        context: "Vous observez la Terre et la Lune depuis l'espace. La Terre tourne sur elle-même et autour du Soleil, tandis que la Lune tourne autour de la Terre.",
+        gender1: "féminin",
+        gender2: "féminin",
+        hints: {
+            "à l'autre": "La Lune tourne autour de la Terre.",
+            "au sol": "La Terre et la Lune sont en mouvement dans l'espace.",
+        },
+        corrections: {
+            "à l'autre": "La Lune est en mouvement par rapport à la Terre car elle tourne autour de celle-ci. Pour un observateur sur la Terre, la position de la Lune change continuellement dans le ciel.",
+            "au sol": "La Terre et la Lune sont en mouvement par rapport au sol, car elles se déplacent dans l'espace. La Terre tourne sur elle-même et autour du Soleil, et la Lune tourne autour de la Terre.",
+        },
+    },
+];
+const references = ["à l'autre", "au sol"];
+const determineCorrectAnswer = (situation, reference) => {
+    if (reference === "à l'autre") {
+        if ((situation.object1 === "Terre" && situation.object2 === "Lune") ||
+            (situation.object1 === "Lune" && situation.object2 === "Terre")) {
+            return "Oui";
+        }
+        return "Non";
+    }
+    else if (reference === "au sol") {
+        if (situation.object1 === "Terre" && situation.object2 === "Lune") {
+            return "Non";
+        }
+        else if (situation.object1 === "Lune" && situation.object2 === "Terre") {
+            return "Oui";
+        }
+        return "Oui";
+    }
+    return "On ne peut pas savoir";
+};
+const getMotionReferenceQuestion = () => {
+    const situationIndex = (0, randint_1.randint)(0, situations.length);
+    const situation = situations[situationIndex];
+    const referenceIndex = (0, randint_1.randint)(0, references.length);
+    const reference = references[referenceIndex];
+    const objectToCheckIndex = (0, coinFlip_1.coinFlip)();
+    const objectToCheck = objectToCheckIndex
+        ? situation.object1
+        : situation.object2;
+    const otherObject = situation.object1 === objectToCheck ? situation.object2 : situation.object1;
+    const referenceText = reference === "à l'autre" ? otherObject : "sol";
+    const isMasculine = objectToCheckIndex
+        ? situation.gender1 === "masculin"
+        : situation.gender2 === "masculin";
+    const genderPronoun = isMasculine ? "il" : "elle";
+    const instruction = `Considérez la situation suivante :\n
+  ${situation.context}\n
+  ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(objectToCheck) ? "L'" : "Le "}${objectToCheck} est-${genderPronoun} en mouvement par rapport ${(0, requiresApostropheBefore_1.requiresApostropheBefore)(referenceText) ? "à l'" : "au "}${referenceText} ?`;
+    const correctAnswer = determineCorrectAnswer(situation, reference);
+    const hint = situation.hints[reference];
+    const correction = situation.corrections[reference];
+    const question = {
+        answer: correctAnswer,
+        instruction,
+        hint,
+        correction,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            object1: situation.object1,
+            object2: situation.object2,
+            reference,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.MotionReferenceExercise = {
+    id: "motionReference",
+    label: "Déterminer le mouvement relatif entre deux objets",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Mécanique"],
+    answerType: "QCU",
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMotionReferenceQuestion, nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    maxAllowedQuestions: 10,
+};

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts

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

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmFtB,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}