math-exercises 2.1.0 → 2.1.2

package/lib/exercises/pc/math/isolateVariables.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isolateVariables = 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");
+// m = t*v
+// P = m*g
+// v = d/t
+// U = RI
+// F = t_m / t_f
+// F = V_f / V_m
+// t_m/t_f = V_f/V_m
+const formulas = [];
+const getIsolateVariablesQuestion = () => {
+    let varAsked = "";
+    let answer = "";
+    const formulaType = (0, randint_1.randint)(1, 8);
+    let formulaAsked = "";
+    let vars = [];
+    let formulas = [];
+    switch (formulaType) {
+        case 1:
+            vars = ["m", "t", "v"];
+            formulas = ["m=tv", "t=\\frac{m}{v}", "v=\\frac{m}{t}"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el[0] !== varAsked));
+            break;
+        case 2:
+            vars = ["P", "m", "g"];
+            formulas = ["P=mg", "m=\\frac{P}{g}", "g=\\frac{P}{m}"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el[0] !== varAsked));
+            break;
+        case 3:
+            vars = ["U", "R", "I"];
+            formulas = ["U=RI", "R=\\frac{U}{I}", "I=\\frac{U}{R}"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el[0] !== varAsked));
+            break;
+        case 4:
+            vars = ["v", "d", "t"];
+            formulas = ["v=\\frac{d}{t}", "d=vt", "t=\\frac{d}{v}"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el[0] !== varAsked));
+            break;
+        case 5:
+            vars = ["F", "t_m", "t_f"];
+            formulas = ["F=\\frac{t_m}{t_f}", "t_m=Ft_f", "t_f=\\frac{t_m}{F}"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el.split("=")[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el.split("=")[0] !== varAsked));
+            break;
+        case 6:
+            vars = ["F", "V_m", "V_f"];
+            formulas = ["F=\\frac{V_f}{V_m}", "V_m=\\frac{V_f}{F}", "V_f=FV_m"];
+            varAsked = (0, random_1.random)(vars);
+            answer = formulas.find((el) => el.split("=")[0] === varAsked);
+            formulaAsked = (0, random_1.random)(formulas.filter((el) => el.split("=")[0] !== varAsked));
+            break;
+        case 7:
+            vars = ["t_m", "t_f", "V_m", "V_f"];
+            formulas = ["\\frac{t_m}{t_f}=\\frac{V_f}{V_m}", "t_mV_m=t_fV_f"];
+            varAsked = (0, random_1.random)(vars);
+            answer =
+                varAsked === "t_m"
+                    ? "t_m=\\frac{V_ft_f}{V_m}"
+                    : varAsked === "t_f"
+                        ? "t_f=\\frac{t_mV_m}{t_f}"
+                        : varAsked === "V_m"
+                            ? "V_m=\\frac{t_fV_f}{t_m}"
+                            : "V_f=\\frac{t_mV_m}{t_f}";
+            formulaAsked = (0, random_1.random)(formulas);
+            break;
+    }
+    const keys = [
+        "equal",
+        ...vars.map((v) => v === "V_f"
+            ? "volumeFille"
+            : v === "V_m"
+                ? "volumeMere"
+                : v === "t_f"
+                    ? "concentrationFille"
+                    : v === "t_m"
+                        ? "concentrationMere"
+                        : v),
+    ];
+    const question = {
+        answer,
+        instruction: `Isoler la grandeur $${varAsked}$ dans l'expression suivante : $${formulaAsked}$`,
+        keys: keys,
+        answerFormat: "tex",
+        identifiers: { varAsked, formulaType },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, formulaType, varAsked }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    switch (formulaType) {
+        case 1:
+            if (varAsked === "m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=\\frac{t}{v}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=\\frac{v}{t}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=t+v");
+            }
+            if (varAsked === "t") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=\\frac{v}{m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=mv");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=m-v");
+            }
+            if (varAsked === "v") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=\\frac{t}{m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=mt");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=m-t");
+            }
+            break;
+        case 2:
+            if (varAsked === "P") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "P=\\frac{m}{g}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "P=\\frac{g}{m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "P=m+g");
+            }
+            if (varAsked === "m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=\\frac{g}{P}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=Pg");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "m=P-g");
+            }
+            if (varAsked === "g") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "g=\\frac{m}{P}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "g=Pm");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "g=P-m");
+            }
+            break;
+        case 3:
+            if (varAsked === "U") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "U=\\frac{R}{I}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "U=\\frac{I}{R}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "U=R+I");
+            }
+            if (varAsked === "R") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "R=\\frac{I}{U}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "R=UI");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "R=U-I");
+            }
+            if (varAsked === "I") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "I=\\frac{R}{U}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "I=RU");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "I=U-R");
+            }
+            break;
+        case 4:
+            if (varAsked === "v") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=\\frac{t}{d}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=dt");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "v=d+t");
+            }
+            if (varAsked === "d") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "d=\\frac{t}{v}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "d=\\frac{v}{t}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "d=v+t");
+            }
+            if (varAsked === "t") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=\\frac{v}{d}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=vd");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t=v+d");
+            }
+            break;
+        case 5:
+            //F = t_m / t_f
+            if (varAsked === "F") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=\\frac{t_f}{t_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=t_mt_f");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=t_f+t_m");
+            }
+            if (varAsked === "t_m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=\\frac{F}{t_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=\\frac{t_f}{F}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=F+t_f");
+            }
+            if (varAsked === "t_f") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=\\frac{F}{t_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=Ft_m");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=F+t_m");
+            }
+            break;
+        case 6:
+            //F = V_f / V_m
+            if (varAsked === "F") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=\\frac{V_m}{V_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=V_mV_f");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "F=V_f+V_m");
+            }
+            if (varAsked === "V_f") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=\\frac{F}{V_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=\\frac{V_m}{F}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=F+V_m");
+            }
+            if (varAsked === "V_m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=\\frac{F}{V_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=FV_f");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=F+V_f");
+            }
+            break;
+        case 7:
+            //t_mV_m = V_f t_f
+            if (varAsked === "t_m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=\\frac{V_f}{V_mt_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=\\frac{V_fV_m}{t_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_m=\\frac{V_mt_f}{V_f}");
+            }
+            if (varAsked === "V_f") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=\\frac{t_m}{t_fV_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=\\frac{t_mt_f}{V_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_f=\\frac{t_fV_m}{t_m}");
+            }
+            if (varAsked === "V_m") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=\\frac{t_m}{V_ft_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=\\frac{V_ft_m}{t_f}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "V_m=\\frac{V_f}{t_mt_f}");
+            }
+            if (varAsked === "t_f") {
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=\\frac{V_m}{V_ft_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=\\frac{V_fV_m}{t_m}");
+                (0, exercise_1.tryToAddWrongProp)(propositions, "t_f=\\frac{V_f}{V_mt_m}");
+            }
+            break;
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, formulaType, varAsked }) => {
+    const texs = [answer];
+    switch (formulaType) {
+        case 1:
+            // formulas = ["m=t\\times v", "t=\\frac{m}{v}", "v=\\frac{m}{t}"];
+            if (varAsked === "m")
+                texs.push("m=vt");
+            break;
+        case 2:
+            // formulas = ["P=m\\times g", "m=\\frac{P}{g}", "g=\\frac{P}{m}"];
+            if (varAsked === "P")
+                texs.push("P=gm");
+            break;
+        case 3:
+            // formulas = ["U=R\\times I", "R=\\frac{U}{I}", "I=\\frac{U}{R}"];
+            if (varAsked === "U")
+                texs.push("U=IR");
+            break;
+        case 4:
+            // formulas = ["v=\\frac{d}{t}", "d=v\\times t", "t=\\frac{d}{v}"];
+            if (varAsked === "d")
+                texs.push("d=tv");
+            break;
+        case 5:
+            // formulas = [
+            //   "F=\\frac{t_m}{t_f}",
+            //   "t_m=F\\times t_f",
+            //   "t_f=\\frac{t_m}{F}",
+            // ];
+            if (varAsked === "t_m")
+                texs.push("t_m=t_fF");
+            break;
+        case 6:
+            // formulas = [
+            //   "F=\\frac{V_f}{V_m}",
+            //   "V_m=\\frac{V_f}{F}",
+            //   "V_f=F\\times V_m",
+            // ];
+            if (varAsked === "V_f")
+                texs.push("V_f=V_mF");
+            break;
+        case 7:
+            // formulas = ["\\frac{t_m}{t_f}=\\frac{V_f}{V_m}", "t_mV_m = t_fV_f"];
+            if (varAsked === "t_m")
+                texs.push("t_m=\\frac{t_fV_f}{V_m}");
+            if (varAsked === "t_f")
+                texs.push("t_f=\\frac{V_mt_m}{t_f}");
+            if (varAsked === "V_m")
+                texs.push("V_m=\\frac{V_ft_f}{t_m}");
+            if (varAsked === "V_f")
+                texs.push("V_f=\\frac{V_mt_m}{t_f}");
+            break;
+    }
+    return texs.includes(ans) || texs.includes(ans.replace("\\times ", ""));
+};
+exports.isolateVariables = {
+    id: "isolateVariables",
+    connector: "=",
+    label: "Isoler une grandeur",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIsolateVariablesQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+};
+export declare const proportionnalityCoeffFromLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proportionnalityCoeffFromLine.d.ts.map

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0EF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proportionnalityCoeffFromLine = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getProportionnalityCoeffFromLineQuestion = () => {
+    let xA, yA, xB, yB;
+    [xA, yA] = [1, 2].map((el) => (0, randint_1.randint)(-5, 6));
+    xB = xA > 0 ? (0, randint_1.randint)(xA - 4, 6, [xA]) : (0, randint_1.randint)(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? (0, randint_1.randint)(yA - 4, 6) : (0, randint_1.randint)(-4, yA + 5);
+    const a = new rational_1.Rational(yB - yA, xB - xA).simplify();
+    const b = a.opposite().multiply(new integer_1.Integer(xA)).add(new integer_1.Integer(yA));
+    const aTree = a.toTree();
+    const bTree = b.toTree();
+    const aString = aTree.toMathString();
+    const bString = bTree.toMathString();
+    const xMin = Math.min(xA, xB);
+    const xMax = Math.max(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const yMax = Math.max(yA, yB);
+    const commands = [
+        `f(x) = (${aString}) * x + (${bString})`,
+        `SetColor(f, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        axisLabels: ["$x$", "$y$"],
+    });
+    const answer = aTree.toTex();
+    const question = {
+        instruction: "Déterminer le coefficient de proportionnalité entre $y$ et $x$ : ",
+        answer,
+        keys: [],
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        options: ggb.getOptions(),
+        answerFormat: "tex",
+        identifiers: { xA, xB, yA, yB },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    if (yB - yA !== 0)
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational(xB - xA, yB - yA).simplify().toTree().toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = new numberNode_1.NumberNode((0, randint_1.randint)(-4, 5, [0]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
+    const leadingCoeff = new rational_1.Rational(yB - yA, xB - xA)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const texs = leadingCoeff.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.proportionnalityCoeffFromLine = {
+    id: "proportionnalityCoeffFromLine",
+    connector: "=",
+    label: "Déterminer le coefficient de proportionnalité à l'aide d'une droite",
+    levels: ["3ème", "2nde", "1reESM", "2ndPro", "1rePro", "1reTech"],
+    isSingleStep: false,
+    sections: ["Droites", "Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProportionnalityCoeffFromLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Physique",
+};

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

@@ -0,0 +1 @@
+//# sourceMappingURL=recognizeFreeFall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeFreeFall.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/recognizeFreeFall.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,53 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+// } from "../../../exercises/exercise";
+// import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions";
+// type Identifiers = {};
+// const getRecognizeFreeFallQuestion: QuestionGenerator<Identifiers> = () => {
+//   const yStart = 10;
+//   const freeFallPoints = [];
+//   const commands = [];
+//   const question: Question<Identifiers> = {
+//     answer,
+//     instruction: ``,
+//     keys: [],
+//     answerFormat: "tex",
+//     identifiers: {},
+//   };
+//   return question;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     throw Error("QCM not implemented");
+//   }
+//   return shuffleProps(propositions, n);
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   throw Error("VEA not implemented");
+// };
+// export const recognizeFreeFall: Exercise<Identifiers> = {
+//   id: "recognizeFreeFall",
+//   connector: "",
+//   label: "",
+//   levels: [],
+//   isSingleStep: true,
+//   sections: [],
+//   generator: (nb: number) =>
+//     getDistinctQuestions(getRecognizeFreeFallQuestion, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+// };

package/lib/exercises/pc/sound/findPeriodFromGraph.d.ts

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

package/lib/exercises/pc/sound/findPeriodFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findPeriodFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findPeriodFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAkEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/pc/sound/findPeriodFromGraph.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPeriodFromGraph = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
+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 getFindPeriodFromGraphQuestion = () => {
+    const period = (0, randint_1.randint)(2, 5);
+    const yStart = (0, randint_1.randint)(0, 4);
+    const splinePoints = [[0, yStart]];
+    const isFirstNegative = (0, coinFlip_1.coinFlip)();
+    const quarter = period / 4;
+    splinePoints.push([
+        quarter,
+        yStart + (isFirstNegative ? (0, randfloat_1.randfloat)(-2, -5) : (0, randfloat_1.randfloat)(2, 5)),
+    ]);
+    const half = period / 2;
+    splinePoints.push([half, yStart]);
+    const threeQuarter = (3 * period) / 4;
+    splinePoints.push([
+        threeQuarter,
+        yStart + (isFirstNegative ? (0, randfloat_1.randfloat)(2, 5) : (0, randfloat_1.randfloat)(-2, -5)),
+    ]);
+    splinePoints.push([period, yStart]);
+    const color = (0, colors_1.randomColor)();
+    const commands = [
+        `S =Spline(${splinePoints
+            .map((point) => `(${point[0]},${point[1]})`)
+            .join(",")})`,
+        "SetFixed(S, true)",
+        `SetColor(S, "${color}")`,
+    ];
+    for (let i = 1; i < 10; i++) {
+        commands.push(`S_{${i}} = Translate(S, (${i * period}, 0))`, `SetFixed(S_{${i}}, true)`, `SetColor(S_{${i}}, "${color}")`);
+    }
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        axisLabels: ["$\\tiny Temps (ms)$", "$\\tiny Tension (V)$"],
+        isGridSimple: true,
+    });
+    const question = {
+        answer: period + "",
+        instruction: `L'enregistrement d'un signal sonore est donnée ci-dessous. Déterminer la période de ce signal.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { period, splinePoints },
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [0, 20, -8, 8],
+    };
+    return question;
+};
+const getPropositions = (n, { answer, period }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-3, 6) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.findPeriodFromGraph = {
+    id: "findPeriodFromGraph",
+    label: "Lire la période d'un signal sonore",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Son"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFindPeriodFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+    hasGeogebra: true,
+};

package/lib/exercises/pc/sound/findSoundFrequencyFromPeriod.d.ts

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

package/lib/exercises/pc/sound/findSoundFrequencyFromPeriod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSoundFrequencyFromPeriod.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findSoundFrequencyFromPeriod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwCF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/pc/sound/findSoundFrequencyFromPeriod.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findSoundFrequencyFromPeriod = 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 round_1 = require("../../../math/utils/round");
+const getFindSoundFrequencyFromPeriodQuestion = () => {
+    const period = (0, round_1.round)((0, randfloat_1.randfloat)(1, 50), 1);
+    const periodInSeconds = period / 1000;
+    const answer = `${(0, round_1.round)(1 / periodInSeconds, 0)}`;
+    const question = {
+        answer,
+        instruction: `Un signal sonore a une période de $${period}\\ \\text{ms}$. Calculer la fréquence de ce signal en $\\text{Hz}$ (arrondir à l'unité).`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { period },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, period }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const answerFromPeriodInMs = `${(0, round_1.round)(1 / period, 0)}`;
+    const answerWithWrongConversion = `${(0, round_1.round)(1 / (period / 100), 0)}`;
+    const answerWithWrongConversion2 = `${(0, round_1.round)(1 / (period / 10000), 0)}`;
+    (0, exercise_1.tryToAddWrongProp)(propositions, answerFromPeriodInMs);
+    (0, exercise_1.tryToAddWrongProp)(propositions, answerWithWrongConversion);
+    (0, exercise_1.tryToAddWrongProp)(propositions, answerWithWrongConversion2);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, randint_1.randint)(0, 1000)}`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.findSoundFrequencyFromPeriod = {
+    id: "findSoundFrequencyFromPeriod",
+    label: "Calculer la fréquence d'un signal sonore en fonction de la période",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Son"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFindSoundFrequencyFromPeriodQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Physique",
+};

package/lib/exercises/pc/sound/findSoundPeriodFromFrequency.d.ts

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

package/lib/exercises/pc/sound/findSoundPeriodFromFrequency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSoundPeriodFromFrequency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/sound/findSoundPeriodFromFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoDF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}