math-exercises 3.0.75 → 3.0.77

package/lib/exercises/math/functions/cube/compareCubeValues.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `>`);
+    tryToAddWrongProp(propositions, `<`);
+    tryToAddWrongProp(propositions, `=`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    if (a > b) {
+        return `>`;
+    }
+    else if (a < b) {
+        return `<`;
+    }
+    else {
+        return `=`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Compléter par le bon symbole : 
+  
+$$
+${power(a, 3).toTex()}\\ \\ldots \\ ${power(b, 3).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `La fonction cube conserve l'ordre : pour tous $a$ et $b$ réels,
+  
+- $a^3 > b^3$ si et seulement si $a > b$ ;
+
+- $a^3 < b^3$ si et seulement si $a < b$ ;
+
+- $a^3 = b^3$ si et seulement si $a = b$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a < b ? "<" : a > b ? ">" : "=";
+    return `La fonction cube conserve l'ordre. 
+  
+Puisque $${a.frenchify()} ${signe} ${b.frenchify()}$, alors $${power(a, 3).toTex()} ${getAnswer(identifiers)} ${power(b, 3).toTex()}$.`;
+};
+const getCompareCubeValuesQuestion = (ops) => {
+    const randomNumberOrDecimal = (min, max, excl) => {
+        const isDecimal = coinFlip();
+        return isDecimal ? randfloat(min, max, 2, excl) : randint(min, max, excl);
+    };
+    let a = null;
+    let b = null;
+    const bound = 10;
+    switch (randint(0, 3)) {
+        case 0:
+            a = randomNumberOrDecimal(0, bound);
+            b = randomNumberOrDecimal(0, bound, [a]);
+            break;
+        case 1:
+            a = randomNumberOrDecimal(-bound, 0);
+            b = randomNumberOrDecimal(-bound, 0, [a]);
+            break;
+        case 2:
+        default:
+            if (coinFlip()) {
+                a = randomNumberOrDecimal(-bound, 0);
+                b = randomNumberOrDecimal(0, bound);
+            }
+            else {
+                a = randomNumberOrDecimal(0, bound);
+                b = randomNumberOrDecimal(-bound, 0);
+            }
+            break;
+    }
+    const identifiers = {
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareCubeValues = {
+    id: "compareCubeValues",
+    label: "Comparer des nombres élevés au cube",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareCubeValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/cube/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
+export * from "./compareCubeValues.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/cube/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/cube/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/functions/cube/index.js

@@ -1,2 +1,3 @@
 export * from "./cubicEquation.js";
 export * from "./imageOfCubeFunction.js";
+export * from "./compareCubeValues.js";

package/lib/exercises/math/functions/index.d.ts

@@ -12,4 +12,5 @@ export * from "./integral/index.js";
 export * from "./exponentials/index.js";
 export * from "./sign/index.js";
 export * from "./variations/index.js";
+export * from "./sqrt/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

package/lib/exercises/math/functions/index.js

@@ -12,3 +12,4 @@ export * from "./integral/index.js";
 export * from "./exponentials/index.js";
 export * from "./sign/index.js";
 export * from "./variations/index.js";
+export * from "./sqrt/index.js";

package/lib/exercises/math/functions/parity/parityFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parityFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"parityFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/functions/parity/parityFromGraph.js

@@ -79,6 +79,19 @@ const getParityFromGraphQuestion = () => {
     const identifiers = { type, fctCmd: fct };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `Une fonction $f$ est paire si sa courbe représentative est symétrique par rapport à l'axe des ordonnées. 
+  
+Une fonction $f$ est impaire si sa courbe représentative est symétrique par rapport à l'origine du repère.`;
+};
+const getCorrection = (identifiers) => {
+    const type = identifiers.type;
+    if (type === "even")
+        return `La courbe représentative de $f$ est symétrique par rapport à l'axe des ordonnées : la fonction $f$ est donc paire.`;
+    if (type === "uneven")
+        return `La courbe représentative de $f$ est symétrique par rapport à l'origine du repère : la fonction $f$ est donc impaire.`;
+    return `La courbe représentative de $f$ n'est ni symétrique par rapport à l'axe des ordonnées, ni symétrique par rapport à l'origine du repère : la fonction $f$ n'est donc ni paire, ni impaire.`;
+};
 const getInstruction = (identifiers) => {
     return `La fonction $f$ représentée ci-dessous est-elle paire, impaire, ou ni paire ni impaire ?`;
 };
@@ -113,6 +126,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -136,5 +151,6 @@ export const parityFromGraph = {
     answerType: "QCU",
     hasGeogebra: true,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

package/lib/exercises/math/functions/sqrt/compareSqrtValues.d.ts

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

package/lib/exercises/math/functions/sqrt/compareSqrtValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareSqrtValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/compareSqrtValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2EF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

package/lib/exercises/math/functions/sqrt/compareSqrtValues.js

@@ -0,0 +1,83 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `>`);
+    tryToAddWrongProp(propositions, `<`);
+    tryToAddWrongProp(propositions, `=`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a > b ? ">" : a < b ? "<" : "=";
+    return `${signe}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Compléter par le bon symbole : 
+  
+$$
+${sqrt(a).toTex()} \\ \\ldots \\ ${sqrt(b).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    return `La racine carré conserve l'ordre : pour tous $a$ et $b$ positifs,
+  
+- $a > b \\iff ${sqrt("a").toTex()} > ${sqrt("b").toTex()}$
+- $a < b \\iff ${sqrt("a").toTex()} < ${sqrt("b").toTex()}$
+- $a = b \\iff ${sqrt("a").toTex()} = ${sqrt("b").toTex()}$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const signe = a > b ? ">" : a < b ? "<" : "=";
+    return `La racine carrée conserve l'ordre. 
+  
+Puisque $${a.frenchify()} ${signe} ${b.frenchify()}$, alors $${sqrt(a).toTex()} ${signe} ${sqrt(b).toTex()}$.`;
+};
+const getCompareSqrtValuesQuestion = (ops) => {
+    const randomNumberOrDecimal = (min, max, excl) => {
+        const isDecimal = coinFlip();
+        return isDecimal ? randfloat(min, max, 2, excl) : randint(min, max, excl);
+    };
+    const bound = 10;
+    const a = randomNumberOrDecimal(0, bound);
+    const b = randomNumberOrDecimal(0, bound, [a]);
+    const identifiers = {
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const compareSqrtValues = {
+    id: "compareSqrtValues",
+    label: "Comparer des racines carrés",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareSqrtValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/sqrt/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./compareSqrtValues.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/sqrt/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sqrt/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/functions/sqrt/index.js

@@ -0,0 +1 @@
+export * from "./compareSqrtValues.js";

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"}