math-exercises 3.0.76 → 3.0.78

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.d.ts

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

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramFourthAngle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/angles/parallelogramFourthAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/geometry/angles/parallelogramFourthAngle.js

@@ -0,0 +1,92 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { degreeParser } from "../../../../tree/parsers/degreeParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, singleAngle, doubleAngle }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${singleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${360 - singleAngle - doubleAngle}^{\\circ}`);
+    tryToAddWrongProp(propositions, `${Math.abs(180 - 2 * singleAngle - doubleAngle)}^{\\circ}`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { singleAngle, doubleAngle } = identifiers;
+    const fourthAngle = 360 - singleAngle - 2 * doubleAngle;
+    return `${fourthAngle}^{\\circ}`;
+};
+const getInstruction = (identifiers) => {
+    return `Un parallélogramme a deux angles de mesure $${identifiers.doubleAngle}^{\\circ}$ et un angle de mesure $${identifiers.singleAngle}^{\\circ}$. 
+
+Quelle est la mesure de son quatrième angle ?`;
+};
+const getHint = (identifiers) => {
+    return `La somme des angles d'un parallélogramme est égale à $360°$.`;
+};
+const getCorrection = (identifiers) => {
+    const { singleAngle, doubleAngle } = identifiers;
+    const sum = singleAngle + 2 * doubleAngle;
+    return `La somme des angles d'un parallélogramme est égale à $360°$. Ici, la somme des trois angles connus vaut : 
+  
+$$
+${singleAngle}^{\\circ} + 2\\times ${doubleAngle}^{\\circ} = ${sum}^{\\circ}
+$$
+
+Le quatrième angle vaut donc : 
+
+$$
+360^{\\circ} - ${sum}^{\\circ} = ${singleAngle} ^{\\circ}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return degreeParser(ans) === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParallelogramFourthAngleQuestion = (ops) => {
+    const doubleAngle = randint(10, 170);
+    const singleAngle = 180 - doubleAngle;
+    const identifiers = {
+        singleAngle,
+        doubleAngle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getKeys = (identifiers) => {
+    return ["degree"];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const parallelogramFourthAngle = {
+    id: "parallelogramFourthAngle",
+    label: "Déterminer le $4$ème angle d'un parallélogramme en connaissant les $3$ autres",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramFourthAngleQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/cartesian/placeAbscissOnLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAbscissOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAQ1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"placeAbscissOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAa1D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAgBpD,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnLine.js

@@ -9,8 +9,10 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
 const getInstruction = ({ abscissTex }) => {
     return `Placer le point d'abscisse $${abscissTex}$ sur la droite graduée ci-dessous :`;
 };
@@ -108,6 +110,28 @@ const getPlaceAbscissOnLineQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { absciss, axisUnit, oneUnitTex, abscissType, abscissTex, coeff } = identifiers;
+    return `Il faut compter le nombre de graduations entre les points $O$ et $A$. Puis on utilise le fait qu'une graduation vaut $${oneUnitTex}$. 
+  
+D'autre part, si $A$ est placé à gauche de $O$, alors son abscisse est négative.`;
+};
+const getCorrection = (identifiers) => {
+    const { absciss, axisUnit, oneUnitTex, abscissType, abscissTex, coeff } = identifiers;
+    const absCoeff = Math.abs(coeff);
+    const oneUnitNode = parseAlgebraic(oneUnitTex);
+    return `Il y a $${absCoeff}$ ${pluralize("graduation", absCoeff)} entre $O$ et $A$. Puisqu'une graduation vaut $${oneUnitTex}$, cela représente un écart de  :
+  
+$$
+${multiply(absCoeff, oneUnitNode).toTex({
+        forceNoSimplification: true,
+    })} = ${multiply(absCoeff, oneUnitNode).simplify().toTex()}
+$$ 
+  
+${coeff < 0
+        ? `Puisque $A$ est placé à gauche du point $O$, son abscisse est négative. L'abscisse du point $A$ est donc $${abscissTex}$.`
+        : `L'abscisse du point $A$ est donc $${abscissTex}$.`}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
@@ -133,4 +157,5 @@ export const placeAbscissOnLine = {
     getStudentGGBOptions,
     answerType: "GGB",
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AAqPF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAuBnD,CAAC"}
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA4RF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAuBnD,CAAC"}

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -30,9 +30,26 @@ const getAnswer = (identifiers) => {
             : "La réciproque du théorème de Thalès";
 };
 const getInstruction = (identifiers) => {
-    const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const { isAskingLength, pointsIdentifiers, lengths, isSegmentHeight } = identifiers;
     const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
     let instruction = ``;
+    let segments;
+    if (isSegmentHeight) {
+        const withoutA = points.slice(1);
+        segments = withoutA.map((p, i) => new Segment(p, withoutA[(i + 1) % 3], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[3], points[0], {
+            lengthNode: new NumberNode(lengths[3]),
+        }));
+        segments.push(new Segment(points[0], points[1]));
+    }
+    else {
+        segments = points.map((p, i) => new Segment(p, points[(i + 1) % points.length], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[1], points[3]));
+    }
     if (isSegmentHeight) {
         if (isAskingLength) {
             instruction = `calculer la longueur $${points[0].name}${points[1].name}$`;
@@ -53,6 +70,11 @@ const getInstruction = (identifiers) => {
         ? `, où les droites $\\left(${points[1].name}${points[3].name}\\right)$ et $\\left(${points[0].name}${points[4].name}\\right)$ sont parallèles.`
         : "."}
 
+On connaît les longueurs suivantes : $${segments
+        .slice(0, segments.length - 1)
+        .map((e) => e.toLengthTex())
+        .join("\\ ; \\ ")}$.
+
 Pour ${instruction}, il faut utiliser... `;
 };
 const getHint = (identifiers) => {
@@ -69,22 +91,32 @@ $$
 };
 const getCorrection = (identifiers) => {
     const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
-    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
     if (isSegmentHeight) {
         if (isAskingLength) {
-            // ("Pythagore");
-            return ``;
+            return `Il faut utiliser le théorème de Pythagore : das un triangle rectangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés.
+  
+On applique ce théorème dans le triangle $ABD$ rectangle en $D$. En effet, d'après le théorème de Pythagore, on a $AB^2 = AD^2 + DB^2$. Puisqu'on connaît les longueurs $AD$ et $DB$, on peut en déduire la longueur $AB$.`;
         }
         else {
-            // ("Recip pythagore");
+            return `Il faut utiliser la réciproque du théorème de Pythagore : si dans un triangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
+  
+On applique cette réciproque dans le triangle $BCD$. En effet, on connaît les longueurs des trois côtés. Il suffit donc de montrer que $BC^2 = BD^2 + CD^2$.`;
         }
     }
     else {
         if (isAskingLength) {
-            // ("Thales");
+            return `Il faut utiliser le théorème de Thalès : dans le triangle $ABC$, si les droites $(DE)$ et $(BC)$ sont parallèles, alors :
+
+$$
+\\frac{AD}{AB}=\\frac{AE}{AC}=\\frac{DE}{BC}
+$$
+  
+On peut donc calculer $DE$ en remplaçant les longueurs par les valeurs données dans l'énoncé.`;
         }
         else {
-            // ("Recip thales");
+            return `Il faut utiliser la réciproque du théorème de Thalès : dans le triangle $ABC$, si $\\frac{DB}{AB}=\\frac{EB}{CB}$, alors les droites $(DE)$ et $(AC)$ sont parallèles.
+  
+Il suffit donc de prouver que $\\frac{DB}{AB} = \\frac{EB}{CB}$, en remplaçant les longueurs par les valeurs données dans l'énoncé.`;
         }
     }
     return ``;
@@ -112,9 +144,11 @@ const getGGBOptions = (identifiers) => {
     const commands = [
         ...points.flatMap((p) => p.toGGBCommand()),
         ...segments.flatMap((s, i) => s.toGGBCommands(false, { color: "grey", thickness: 3 })),
-        ...segments
-            .slice(0, segments.length - 1)
-            .flatMap((s, i) => s.getFitCaptionCommands({ size: "scriptsize", color: "red" })),
+        // ...segments
+        //   .slice(0, segments.length - 1)
+        //   .flatMap((s, i) =>
+        //     s.getFitCaptionCommands({ size: "scriptsize", color: "red" }),
+        //   ),
         ...(isAskingLength && isSegmentHeight
             ? new Angle([points[1], points[3], points[0]]).toCommands()
             : []),
@@ -203,8 +237,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "raw",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -230,7 +264,7 @@ export const pythagoreOrThales = {
         shouldSpreadPropositions: true,
     },
     getQuestionFromIdentifiers,
-    // hasHintAndCorrection: true,
+    hasHintAndCorrection: true,
 };
 const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
     const [A, B, C] = triangle.points;

package/lib/exercises/math/geometry/lines/linesRelativePositions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linesRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/linesRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAE/D,WAAW,EAAE,MAAM,CAAC;CAKrB,CAAC;AAkJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAoBxD,CAAC"}
+{"version":3,"file":"linesRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/linesRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAE/D,WAAW,EAAE,MAAM,CAAC;CAKrB,CAAC;AAyKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAqBxD,CAAC"}

package/lib/exercises/math/geometry/lines/linesRelativePositions.js

@@ -25,6 +25,31 @@ const getAnswer = (identifiers) => {
             return "sécantes mais non perpendiculaires";
     }
 };
+const getHint = (identifiers) => {
+    return `Deux droites sont : 
+  
+- perpendiculaires si leur intersection forme un angle droit ;
+- sécantes mais non perpendiculaires si elles s'intersectent mais sans angle droit ;
+- parallèles si elles n'ont pas de point d'intersection.`;
+};
+const getCorrection = (identifiers) => {
+    const { coupleAsked, lines } = identifiers;
+    const askedLines = coupleAsked === 0
+        ? [lines[0], lines[4]]
+        : coupleAsked === 3
+            ? [lines[2], lines[4]]
+            : [lines[coupleAsked], lines[coupleAsked + 1]];
+    const answer = getAnswer(identifiers);
+    if (answer === "parallèles")
+        return `Les droites $${askedLines[0].label}$ et $${askedLines[1].label}$ ne semblent pas avoir de point d'intersection : elles semblent donc parallèles.`;
+    if (answer === "perpendiculaires") {
+        `Les droites $${askedLines[0].label}$ et $${askedLines[1].label}$ ont un point d'intersection : elles sont donc sécantes. De plus, leur intersection semble former un angle droit : elles semblent donc perpendiculaires.`;
+    }
+    if (askedLines[1].label === "d_4") {
+        `Les droites $${askedLines[0].label}$ et $${askedLines[1].label}$ ont un point d'intersection : elles sont donc sécantes. De plus, elles ne semble pas perpendiculaires, car leur intersection ne semble pas former un angle droit.`;
+    }
+    return `Les droites $${askedLines[0].label}$ et $${askedLines[1].label}$ sont sécantes. En effet, même si on ne voit pas leur point d'intersection sur le graphique, on voit qu'elles ne sont pas parallèles, et qu'en poursuivant le tracé, elles finiront par s'intersecter.`;
+};
 const getInstruction = (identifiers) => {
     const { coupleAsked, lines } = identifiers;
     const askedLines = coupleAsked === 0
@@ -34,10 +59,8 @@ const getInstruction = (identifiers) => {
             : [lines[coupleAsked], lines[coupleAsked + 1]];
     return `On donne la figure ci-dessous. 
   
-$${askedLines[0].label}$ et $${askedLines[1].label}$ semblent...`;
+Les droites $${askedLines[0].label}$ et $${askedLines[1].label}$ semblent...`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
 const getGGBOptions = (identifiers) => {
     const lines = identifiers.lines.map((d, i) => new Line(new Point(`A_${d.label}`, d.pointA[0], d.pointA[1]), new Point(`B_${d.label}`, d.pointB[0], d.pointB[1]), d.label));
     const ggb = new GeogebraConstructor({
@@ -114,8 +137,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "raw",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -139,4 +162,5 @@ export const linesRelativePositions = {
     maxAllowedQuestions: 4,
     answerType: "QCU",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/calculateMeanFromFrequencies.d.ts

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

package/lib/exercises/math/probaStat/calculateMeanFromFrequencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateMeanFromFrequencies.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/calculateMeanFromFrequencies.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

package/lib/exercises/math/probaStat/calculateMeanFromFrequencies.js

@@ -0,0 +1,108 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+import { round } from "../../../math/utils/round.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const offset = randfloat(0.1, 1, 2);
+        tryToAddWrongProp(propositions, round(answer.unfrenchify() + offset, 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const sum = xValues.reduce((sum, v, i) => sum + v * yValues[i], 0);
+    const mean = round(sum, 2);
+    return mean.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    return `Un film a été noté par les spectateurs : 
+
+  
+${mdTable([
+        ["Note", ...xValues.map((v) => dollarize(v))],
+        ["Fréquence", ...yValues.map((v) => dollarize(`${round(v * 100, 2)} \\%`))],
+    ])}
+
+Quelle est la note moyenne du film ?`;
+};
+const getHint = (identifiers) => {
+    return `Pour calculer la moyenne, multiplie chaque valeur $x_i$ par sa fréquence correspondante $f_i$, puis additionne ces produits.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const products = xValues.map((v, i) => round(v * yValues[i], 2));
+    const total = getAnswer(identifiers);
+    return `On calcule les produits des notes par leur fréquence : \n\n
+  
+${xValues
+        .map((v, i) => `$$
+${v} \\times ${yValues[i].frenchify()} = ${products[i].frenchify()}
+$$`)
+        .join("\n\n")}
+  
+En additionnant ces produits, on obtient la moyenne $\\overline{x}$ :
+
+$$
+\\overline x = ${total}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateMeanFromFrequenciesQuestion = (ops) => {
+    const xValues = [0, 1, 2, 3, 4];
+    const raw = xValues.map(() => Math.random());
+    const total = raw.reduce((sum, v) => sum + v, 0);
+    const yValues = raw.map((v) => round(v / total, 2));
+    const sumRounded = yValues.reduce((sum, v) => sum + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    yValues[yValues.length - 1] = round(yValues[yValues.length - 1] + diff, 2);
+    const identifiers = { xValues, yValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const calculateMeanFromFrequencies = {
+    id: "calculateMeanFromFrequencies",
+    label: "Calculer une moyenne à partir de fréquences",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateMeanFromFrequenciesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/checkEquiprobability.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    total: number;
+    distribution: number[];
+    observe: boolean;
+};
+export declare const checkEquiprobability: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=checkEquiprobability.d.ts.map

package/lib/exercises/math/probaStat/checkEquiprobability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkEquiprobability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/checkEquiprobability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAsIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/probaStat/checkEquiprobability.js

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const wrong = answer === "Oui" ? "Non" : "Oui";
+    tryToAddWrongProp(propositions, wrong, "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { observe, distribution } = identifiers;
+    if (observe) {
+        return "Oui";
+    }
+    else {
+        return distribution.every((v) => v === distribution[0]) ? "Oui" : "Non";
+    }
+};
+const getInstruction = ({ total, distribution, observe, }) => {
+    const colors = ["rouges", "vertes", "bleues", "jaunes"];
+    const colorLines = distribution
+        .map((count, i) => `$${count}$ cartes sont ${colors[i]}`)
+        .join(", ");
+    return `Un jeu est constitué de $${total}$ cartes numérotées de $1$ à $${total}$.
+
+${colorLines}.
+
+On tire une carte au hasard.
+
+On observe ${observe ? "le numéro" : "la couleur"} de la carte tirée.  
+
+Les issues sont-elles équiprobables ?`;
+};
+const getHint = ({ observe }) => {
+    if (observe) {
+        return `Pense à combien de cartes portent chaque numéro.  
+Y a-t-il autant de cartes pour chaque numéro possible ?`;
+    }
+    else {
+        return `Regarde le nombre de cartes de chaque couleur.  
+A-t-on autant de chances d'obtenir toutes les couleurs ?`;
+    }
+};
+const getCorrection = ({ total, distribution, observe, }) => {
+    const colors = ["rouge", "vert", "bleu", "jaune"];
+    const probs = distribution
+        .map((count, i) => `$$
+P(\\text{${colors[i]}}) = ${frac(count, total).toTex()}
+$$`)
+        .join("\n \n");
+    const explanation = observe
+        ? `Chaque carte a un numéro distinct entre $1$ et $${total}$, donc chaque numéro a une probabilité d'être tiré égale à $${frac(1, total).toTex()}$.  
+Toutes les issues sont donc équiprobables.`
+        : `Les probabilités associées à chaque couleur sont : \n\n ${probs} \n\n
+${distribution.every((v) => v === distribution[0])
+            ? "Puisqu'il y autant de cartes de chaque couleur, les issues sont équiprobables."
+            : "Les couleurs n'ont pas toutes le même nombre de cartes, donc les issues ne sont pas équiprobables."}`;
+    return `${explanation}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCheckEquiprobabilityQuestion = (ops) => {
+    let total;
+    let distribution;
+    const isEquiprobable = coinFlip();
+    const observe = coinFlip();
+    if (isEquiprobable) {
+        total = 4 * randint(10, 30);
+        const value = total / 4;
+        distribution = [value, value, value, value];
+    }
+    else {
+        total = randint(30, 61);
+        const a = randint(2, total - 6);
+        const b = randint(2, total - a - 4);
+        const c = randint(2, total - a - b - 2);
+        const d = total - a - b - c;
+        distribution = [a, b, c, d];
+    }
+    const identifiers = {
+        total,
+        distribution,
+        observe,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const checkEquiprobability = {
+    id: "checkEquiprobability",
+    label: "Reconnaître une situation équiprobable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckEquiprobabilityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/getComplementaryProbability.d.ts

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

package/lib/exercises/math/probaStat/getComplementaryProbability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getComplementaryProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getComplementaryProbability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiFF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}