math-exercises 3.0.98 → 3.0.100

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoFF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"mentalAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalAddAndSub.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA+FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalAddAndSub.js

@@ -24,6 +24,16 @@ const getStartStatement = (identifiers) => {
 const getAnswer = (identifiers) => {
     return getStatementNode(identifiers).simplify().toTex();
 };
+// const getHint: GetHint<Identifiers> = (identifiers)=>{
+//   return `Ajoute les nombres dans l'ordre.`
+// }
+// const getCorrection: GetCorrection<Identifiers> = (identifiers)=>{
+//   const {numbers} = identifiers
+//   return `On ajoute les nombres dans l'ordre :
+// ${alignTex([
+//   [getStartStatement(identifiers), "=", add(numbers[])],
+// ])}`
+// }
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),

package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.js

@@ -50,7 +50,7 @@ $$`;
 };
 const getHint = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
-    return `Commence par développer ${type === 0 ? "le produit" : "les produits"} en utilisant la distributivité. Ensuite, résout l'équation en regroupant les termes en $x$ d'un côté de l'équation.`;
+    return `Commence par développer ${type === 0 ? "le produit" : "les produits"} en utilisant la distributivité. Ensuite, résous l'équation en regroupant les termes en $x$ d'un côté de l'équation.`;
 };
 const getCorrection = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;

package/lib/exercises/math/functions/affines/affineExpressionFromTwoImages.js

@@ -115,7 +115,7 @@ const isAnswerValid = (ans, { answer, xA, xB, yA, yB }) => {
 export const affineExpressionFromTwoImages = {
     id: "affineExpressionFromTwoImages",
     connector: "=",
-    label: "Expression algébrique d'une fonction affine via deux images",
+    label: "Déterminer l'expression algébrique d'une fonction affine via deux images",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getAffineExpressionFromTwoImagesQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/functions/sign/readSignTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"readSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/readSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}
+{"version":3,"file":"readSignTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/sign/readSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

package/lib/exercises/math/functions/variations/compareImagesInVarTable.js

@@ -51,7 +51,7 @@ const getInstruction = (identifiers) => {
     return `On donne le tableau de variations d'une fonction $f$ définie sur $\\mathbb{R}$ :
   
   
-<svg id='varTable'>${JSON.stringify(table)}</svg>
+<svg id="varTable">${JSON.stringify(table)}</svg>
 
 Compléter par le bon symbole : 
 

package/lib/exercises/math/functions/variations/varTableExtremaReading.js

@@ -64,7 +64,7 @@ const getInstruction = (identifiers) => {
     const table = getTable(identifiers);
     let instruction = `On considère la fonction $f$ dont le tableau de variations est donné ci-dessous : 
   
-  <svg id='varTable'>${JSON.stringify(table)}</svg>
+  <svg id="varTable">${JSON.stringify(table)}</svg>
   
   ${identifiers.isAskingX
         ? `Sur l'intervalle $${interval.toTex()}$, en quelle valeur le ${type} de la fonction $f$ est-il atteint ?`

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts

@@ -3,6 +3,7 @@ import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     vars: string[];
     xs: NodeIdentifiers[];
+    initTable: string[][];
 };
 export declare const varTableFromSentences: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/variations/varTableFromSentences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varTableFromSentences.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromSentences.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,EAAE,EAAE,eAAe,EAAE,CAAC;CACvB,CAAC;AAyKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}
+{"version":3,"file":"varTableFromSentences.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableFromSentences.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAwLF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/functions/variations/varTableFromSentences.js

@@ -134,9 +134,21 @@ const getVarTableFromSentencesQuestion = (ops) => {
     const identifiers = {
         xs: xs.map((e) => e.toTree().toIdentifiers()),
         vars,
+        initTable: getInitTable(),
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getInitTable = () => {
+    const stringed = ["", "\\ ", "", "\\ ", "", "\\ ", ""];
+    const emptyLine = ["\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "];
+    const inputLine = ["", "", "", "", "", "", ""];
+    return [
+        ["$x$", ...stringed],
+        ["$\\ $", ...emptyLine],
+        ["$f(x)$", ...inputLine],
+        ["$\\ $", ...emptyLine],
+    ];
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     return {
         answerTable: getAnswerTable(identifiers),
@@ -146,6 +158,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
     };
 };
 export const varTableFromSentences = {
@@ -165,3 +178,5 @@ export const varTableFromSentences = {
     hasHintAndCorrection: true,
     answerType: "varTable",
 };
+// caca
+// /pas d'init table ?

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts

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

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateAreaFromCodedShape.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/calculateAreaFromCodedShape.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8KF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.js

@@ -0,0 +1,156 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+const getPropositions = (n, { answer, height, shape, width }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, (height * width).frenchify());
+    tryToAddWrongProp(propositions, ((height * width) / 2).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, ((3 / 4) * height * width + randint(-3, 3, [0])).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return multiply(0.75, identifiers.height * identifiers.width)
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    return `On considère la figure ci-dessous.
+    
+Quelle est l'aire de la surface colorée ?`;
+};
+const getHint = (identifiers) => {
+    return `L'aire de la surface colorée est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.`;
+};
+const getCorrection = (identifiers) => {
+    //rectangle - triangle
+    //moitié rectangle + triangle
+    //moitié reactangle + moitié moitié reactalge
+    const { height, shape, width } = identifiers;
+    return `Pour calculer l'aire de la surface colorée, on remarque qu'elle est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.
+  
+L'aire du rectangle $ABCD$ est égale à :
+
+$$
+${multiply(height, width).toTex({ forceNoSimplification: true })}=${(height * width).frenchify()}
+$$
+
+On calcule ensuite l'aire du triangle $CED$. Puisqu'il est rectangle en $D$, son aire vaut : 
+
+$$
+${frac(multiply("CD", "DE"), 2).toTex({ forceTimesSign: true })}
+$$
+
+Or $CD = ${height.frenchify()}$ et $DE = ${(width / 2).frenchify()}$. L'aire de $CED$ vaut donc : 
+
+$$
+${frac(multiply(height, width / 2), 2).toTex()}=${((height * width) /
+        4).frenchify()}
+$$
+
+L'aire de la surface colorée vaut donc : 
+
+$$
+${substract(height * width, (height * width) / 4).toTex()} = ${getAnswer(identifiers)}
+$$
+
+
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { height, shape, width } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `B = (0,0)`,
+            `C = (${width},0)`,
+            `D = (${width},${height})`,
+            `A = (0,${height})`,
+            `E = (${width / 2},${height})`,
+            ...["A", "B", "C", "D", "E"].flatMap((e) => [
+                `SetVisibleInView(${e},1, false)`,
+                `SetFixed(${e}, true)`,
+            ]),
+            `Segment(E, C)`,
+            `Segment(D, C)`,
+            `se1 = Segment(A, E)`,
+            `se2 = Segment(E,D)`,
+            `SetDecoration(se1, 2)`,
+            `SetDecoration(se2, 2)`,
+            `a = Angle(C,B,A)`,
+            `ShowLabel(a, false)`,
+            `b = Angle(B,A,D)`,
+            `ShowLabel(b, false)`,
+            `c = Angle(A,D,C)`,
+            `ShowLabel(c, false)`,
+            `P = Polygon(B,A,E,C)`,
+            `SetFixed(P, true)`,
+            `Text("$\\scriptsize B$", (0, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize C$", (${width}, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize D$", (${width}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize E$", (${width / 2}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize A$", (0, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${height}$", (-0.4, ${height / 2}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${width}$", (${width / 2}, -0.1*${height}), true, true, 0, 0)`,
+        ],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1, width + 1, -1.5, height + 1.5],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getCalculateAreaFromCodedShapeQuestion = (opts) => {
+    const width = randint(3, 11);
+    const height = randint(1, width);
+    const identifiers = {
+        shape: 1,
+        height,
+        width,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const calculateAreaFromCodedShape = {
+    id: "calculateAreaFromCodedShape",
+    label: "Calculer l'aire d'une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateAreaFromCodedShapeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/areas/index.d.ts

@@ -7,4 +7,5 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/areas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/geometry/areas/index.js

@@ -7,3 +7,4 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";

package/lib/exercises/math/geometry/euclidian/index.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC"}

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

@@ -1 +1,2 @@
 export * from "./pythagoreOrThales.js";
+export * from "./orthogonalProjectFromPicture.js";

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonalProjectFromPicture.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkMF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

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

@@ -0,0 +1,197 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPoints = () => {
+    const points = [
+        new Point("A", 0, 0),
+        new Point("B", 4, 0),
+        new Point("C", 4, 4),
+        new Point("D", 0, 4),
+        new Point("E", 0, 2),
+        new Point("F", 4, 2),
+        new Point("G", 2, 4),
+        new Point("H", 2, 0),
+        new Point("I", 1, 3),
+        new Point("J", 3, 1),
+        new Point("K", 1, 1),
+        new Point("L", 3, 3),
+        new Point("P", 2, 2),
+    ];
+    return points;
+};
+const getNames = () => {
+    const names = [
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "J",
+        "K",
+        "L",
+        "P",
+    ];
+    return names;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const names = getNames();
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(names));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const projs = [
+        { line: "AB", A: ["A", "E", "D"], H: ["G", "P", "H"], B: ["C", "F", "B"] },
+        { line: "EF", E: ["A", "E", "D"], P: ["G", "P", "H"], F: ["C", "F", "B"] },
+        { line: "DC", D: ["A", "E", "D"], G: ["G", "P", "H"], C: ["C", "F", "B"] },
+        { line: "DA", A: ["A", "H", "B"], E: ["E", "P", "F"], D: ["D", "G", "C"] },
+        { line: "GH", H: ["A", "H", "B"], P: ["E", "P", "F"], G: ["D", "G", "C"] },
+        { line: "CB", B: ["A", "H", "B"], F: ["E", "P", "F"], C: ["D", "G", "C"] },
+        {
+            line: "DB",
+            D: ["D"],
+            I: ["E", "I", "G"],
+            P: ["A", "K", "P", "L", "C"],
+            J: ["H", "J", "F"],
+            B: ["B"],
+        },
+        {
+            line: "AC",
+            C: ["C"],
+            K: ["E", "K", "H"],
+            P: ["D", "I", "P", "J", "B"],
+            L: ["G", "L", "F"],
+            A: ["A"],
+        },
+        {
+            line: "EH",
+            E: ["E", "I", "G"],
+            H: ["H", "J", "F"],
+            K: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "GF",
+            G: ["E", "I", "G"],
+            F: ["H", "J", "F"],
+            L: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "EG",
+            E: ["E", "K", "H"],
+            G: ["G", "L", "F"],
+            I: ["D", "I", "P", "J", "B"],
+        },
+        {
+            line: "HF",
+            H: ["E", "K", "H"],
+            F: ["G", "L", "F"],
+            J: ["D", "I", "P", "J", "B"],
+        },
+    ];
+    const dataSet = projs.find((e) => e.line === identifiers.line);
+    for (const [key, value] of Object.entries(dataSet)) {
+        if (key === "line")
+            continue;
+        if (value.includes(identifiers.point)) {
+            return key;
+        }
+    }
+    return "";
+};
+const getInstruction = (identifiers) => {
+    const { line, point } = identifiers;
+    return `On considère le carré $ABCD$ ci-dessous :
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/pointsOnSquare.png)
+
+Quel est le projeté orthogonal de $${point}$ sur la droite $\\left(${line}\\right)$ ?
+`;
+};
+const getHint = (identifiers) => {
+    return `- Si $A$ est un point sur une droite $d$, alors le projeté orthogonal de $A$ sur $d$ est $A$.
+  
+- Si $A$ n'appartient pas à la droite $d$, alors le projeté orthogonal de $A$ sur $d$ est le point $H$ sur $d$ tel que la droite $(AH)$ est perpendiculaire à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { line, point } = identifiers;
+    //si point sur droite
+    //sinon
+    const points = getPoints();
+    const pointAnswer = getAnswer(identifiers);
+    const pointObj = points.find((e) => e.name === point);
+    const linePoints = points.filter((e) => line.includes(e.name));
+    const isOnLine = pointObj.isAligned(linePoints[0], linePoints[1]);
+    if (isOnLine) {
+        return `Puisque $${point}$ appartient à la droite $\\left(${line}\\right)$, le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est $${point}$.`;
+    }
+    else {
+        return `Les droites $\\left(${line}\\right)$ et $\\left(${point}${pointAnswer}\\right)$ sont perpendiculaires. De plus, le point $${pointAnswer}$ appartient à la droite $${line}$. Le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est donc $${pointAnswer}$.`;
+    }
+};
+const getKeys = (identifiers) => {
+    const names = getNames();
+    return names;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getOrthogonalProjectFromPictureQuestion = (ops) => {
+    const data = [
+        { lines: ["AB", "EF", "DC"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DA", "GH", "CB"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DB", "AC"], excludes: [] },
+        { lines: ["EH", "GF"], excludes: ["B", "D"] },
+        { lines: ["EG", "HF"], excludes: ["A", "C"] },
+    ];
+    const names = getNames();
+    const dataSet = random(data);
+    const line = random(dataSet.lines);
+    const point = random(names, dataSet.excludes);
+    const identifiers = {
+        line,
+        point,
+    };
+    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 orthogonalProjectFromPicture = {
+    id: "orthogonalProjectFromPicture",
+    label: "Identifier le projeté orthogonal d'un point sur une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getOrthogonalProjectFromPictureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA0IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBpE,CAAC"}
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA8IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -23,8 +23,12 @@ const getEndPoint = (identifiers) => {
     const end = vector.getEndPoint(startPoint, identifiers.startPoint + "'");
     return end;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
 const getGGBAnswer = (identifiers) => {
     return getEndPoint(identifiers).toGGBCommand();
 };
@@ -108,11 +112,12 @@ export const pointImageFromTranslation = {
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
     options,
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/pythagore/calculateDiagonalFromSides.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    shape: "square" | "rectangle";
+    side: number;
+    side2?: number;
+};
+export declare const calculateDiagonalFromSides: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateDiagonalFromSides.d.ts.map

package/lib/exercises/math/geometry/pythagore/calculateDiagonalFromSides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDiagonalFromSides.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/calculateDiagonalFromSides.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqJF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}