math-exercises 3.0.72 → 3.0.73

package/lib/exercises/math/functions/square/getImageOfSquareRootFunction.js

@@ -0,0 +1,128 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { isPowerNode, square } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const randomNumber = randint(0, 100);
+        const randomNumberNode = randomNumber.toTree();
+        const randomNumberSquare = square(randomNumberNode);
+        const randomFraction = RationalConstructor.randomIrreductible().toTree();
+        const choices = [randomNumberNode, randomNumberSquare, randomFraction];
+        const randomChoice = random(choices);
+        tryToAddWrongProp(propositions, randomChoice.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    const sqrtNode = sqrt(reifyAlgebraic(a));
+    const x = sqrtNode.simplify().toTex();
+    return x;
+};
+const getInstruction = (identifiers) => {
+    const { a } = identifiers;
+    return `Déterminer l'image de $${reifyAlgebraic(a).toTex()}$ par la fonction racine carrée.`;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `Quel est le nombre qui, multiplié par lui-même, donne $${reifyAlgebraic(a).toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { a } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const tex = aNode.toTex();
+    const answer = getAnswer(identifiers);
+    switch (true) {
+        case isNumberNode(aNode):
+            return `On remarque que $${tex} = ${answer}^2$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        case isPowerNode(aNode):
+            return `On sait que $\\sqrt{x^2} = |x|$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        case isFractionNode(aNode):
+            return `On sait que $\\sqrt{\\frac{a}{b}} = \\frac{\\sqrt{a}}{\\sqrt{b}}$. 
+      
+Ici on a donc $\\sqrt{${tex}} = ${answer}$.`;
+        default:
+            throw new Error(`getCorrection: nœud inattendu rencontré (${aNode.constructor.name})`);
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        if (!isNumberNode(ansNode) && !isFractionNode(ansNode))
+            return false;
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetImageOfSquareRootFunctionQuestion = (ops) => {
+    const xTreeValue = randint(1, 11) ** 2;
+    const xTree = xTreeValue.toTree();
+    const randomIntTree = randint(1, 100).toTree();
+    let denom = randint(2, 10);
+    let numer = randint(1, 10);
+    while (gcd(numer, denom) !== 1) {
+        denom = randint(2, 10);
+        numer = randint(1, 10);
+    }
+    const fractionTree = frac(numer ** 2, denom ** 2);
+    const candidates = [randomIntTree, fractionTree];
+    const chosenInputTree = candidates[randint(0, candidates.length)];
+    const squaredTree = square(chosenInputTree);
+    const choices = [
+        xTree.toIdentifiers(),
+        squaredTree.toIdentifiers(),
+        fractionTree.toIdentifiers(),
+    ];
+    const a = random(choices);
+    return getQuestionFromIdentifiers({ a });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const getImageOfSquareRootFunction = {
+    id: "getImageOfSquareRootFunction",
+    label: "Calculer une image par la fonction racine carrée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetImageOfSquareRootFunctionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

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

@@ -1 +1,2 @@
 export * from "./squareImageInterval.js";
+export * from "./getImageOfSquareRootFunction.js";

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;AAoNF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAsBnD,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;AAqPF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAuBnD,CAAC"}

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

@@ -55,8 +55,37 @@ const getInstruction = (identifiers) => {
 
 Pour ${instruction}, il faut utiliser... `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return `Voici les énoncés des théorèmes de Pythagore et de Thalès, et leurs réciproques :
+// - **Théorème de Pythagore** : Dans un triangle rectangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés.
+// - **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.
+// - **Théorème de Thalès** : Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si les droites $(DE)$ et $(BC)$ sont parallèles, alors :
+// $$
+// \\frac{AD}{AB}=\\frac{AE}{AC}=\\frac{DE}{BC}
+// $$
+// - **Réciproque du théorème de Thalès** :  Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si $\\frac{AD}{AB}=\\frac{AE}{AC}$, alors les droites $(AB)$ et $(AC)$ sont parallèles.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
+//   const points = pointsIdentifiers.map((p) =>
+//     PointConstructor.fromIdentifiers(p),
+//   );
+//   if (isSegmentHeight) {
+//     if(isAskingLength){
+//       // ("Pythagore");
+//       return ``
+//     } else {
+//       // ("Recip pythagore");
+//     }
+//   } else {
+//     if (isAskingLength) {
+//       // ("Thales");
+//     } else {
+//       // ("Recip thales");
+//     }
+//   }
+//   return ``;
+// };
 const getGGBOptions = (identifiers) => {
     const { isAskingLength, lengths, pointsIdentifiers, isSegmentHeight } = identifiers;
     const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
@@ -198,6 +227,7 @@ export const pythagoreOrThales = {
         shouldSpreadPropositions: true,
     },
     getQuestionFromIdentifiers,
+    // hasHintAndCorrection: true,
 };
 const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
     const [A, B, C] = triangle.points;

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

@@ -3,6 +3,7 @@ export * from "./calculLitteral/index.js";
 export * from "./combinatory/index.js";
 export * from "./complex/index.js";
 export * from "./conversion/index.js";
+export * from "./curve/index.js";
 export * from "./derivation/index.js";
 export * from "./equaDiff/index.js";
 export * from "./functions/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/index.js

@@ -3,6 +3,7 @@ export * from "./calculLitteral/index.js";
 export * from "./combinatory/index.js";
 export * from "./complex/index.js";
 export * from "./conversion/index.js";
+export * from "./curve/index.js";
 export * from "./derivation/index.js";
 export * from "./equaDiff/index.js";
 export * from "./functions/index.js";

package/lib/exercises/math/powers/decimalToScientific.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAyBA,OAAO,EACL,QAAQ,EAgBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}
+{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAyBA,OAAO,EACL,QAAQ,EAgBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}

package/lib/exercises/math/powers/decimalToScientific.js

@@ -104,7 +104,6 @@ const isAnswerValid = (ans, { decimal }) => {
                 return false;
             if (parsed.rightChild.leftChild.value !== 10)
                 return false;
-            console.log(parsed.simplify({ calculatePowers: true }).toTex(), decimal.frenchify());
             return (parsed.simplify({ calculatePowers: true }).toTex() ===
                 decimal.frenchify());
         }

package/lib/exercises/math/powers/powersMixOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA2KF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA0KF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/powers/powersMixOperations.js

@@ -27,7 +27,6 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    const statement = getStatementNode(identifiers);
     const { a, b, k, l, m, n } = identifiers;
     if (a !== b) {
         const pow = k + l * m;

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

@@ -1 +1 @@
-{"version":3,"file":"ballsBasicProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/ballsBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAoGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}
+{"version":3,"file":"ballsBasicProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/ballsBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAoGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -83,10 +83,8 @@ const isAnswerValid = (ans, { colorAskedIndex, repartitions, answer }) => {
 export const ballsBasicProbas = {
     id: "ballsBasicProbas",
     connector: "=",
-    label: "Calcul de probabilité simple avec des boules colorés",
-    levels: ["5ème", "4ème", "3ème", "2ndPro", "2nde", "CAP"],
+    label: "Calcul de probabilité simple avec des boules colorées",
     isSingleStep: true,
-    sections: ["Probabilités"],
     generator: (nb) => getDistinctQuestions(getBallsBasicProbasQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

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

@@ -6,4 +6,6 @@ export * from "./whileLoop.js";
 export * from "./pythonFunctionTrinom.js";
 export * from "./conditionIf.js";
 export * from "./pyNestedForLoopExercise.js";
+export * from "./pyIfElseCondition.js";
+export * from "./variableType.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kBAAkB,CAAC;AACjC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}

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

@@ -6,3 +6,5 @@ export * from "./whileLoop.js";
 export * from "./pythonFunctionTrinom.js";
 export * from "./conditionIf.js";
 export * from "./pyNestedForLoopExercise.js";
+export * from "./pyIfElseCondition.js";
+export * from "./variableType.js";

package/lib/exercises/math/python/pyIfElseCondition.d.ts

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

package/lib/exercises/math/python/pyIfElseCondition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyIfElseCondition.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyIfElseCondition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2IF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/python/pyIfElseCondition.js

@@ -0,0 +1,133 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+const getInstruction = ({ isCondition, inputValue, }) => {
+    if (isCondition) {
+        return `On définit la fonction en Python suivante :
+
+\`\`\`python
+def condition(x):
+  if x > 10:
+    return x + 3
+  else:
+    return 2 * x
+\`\`\`
+
+Que renvoie la commande condition($${inputValue}$) ?`;
+    }
+    else {
+        return `On définit la fonction en Python suivante :
+
+\`\`\`python
+def alter(a):
+  if a < 2:
+    return 2 * a
+  elif a >= 2 and a < 5:
+    return a ** 2
+  else:
+    return a + 5
+\`\`\`
+
+Que renvoie la commande alter($${inputValue}$) ?`;
+    }
+};
+const getAnswer = ({ isCondition, inputValue }) => {
+    let result;
+    if (isCondition) {
+        result = inputValue > 10 ? inputValue + 3 : 2 * inputValue;
+    }
+    else {
+        if (inputValue < 2)
+            result = 2 * inputValue;
+        else if (inputValue < 5)
+            result = inputValue ** 2;
+        else
+            result = inputValue + 5;
+    }
+    return result.frenchify();
+};
+const getHint = ({ isCondition }) => {
+    return isCondition
+        ? "Si $x > 10$, la fonction retourne $x + 3$ ; sinon elle retourne $2 \\times x$."
+        : "Regarde les trois cas : $a < 2$, $2 \\leq a < 5$, puis $a \\geq 5$. Chaque cas retourne une expression différente.";
+};
+const getCorrection = ({ isCondition, inputValue, }) => {
+    let exp = `On appelle la fonction avec $${inputValue}$.\n`;
+    if (isCondition) {
+        if (inputValue > 10) {
+            exp += `Comme $${inputValue} > 10$, on renvoie $${inputValue} + 3 = ${inputValue + 3}$.`;
+        }
+        else {
+            exp += `Comme $${inputValue} \\leq 10$, on renvoie $2 \\times ${inputValue} = ${2 * inputValue}$.`;
+        }
+    }
+    else {
+        if (inputValue < 2) {
+            exp += `Comme $${inputValue} < 2$, on renvoie $2 \\times ${inputValue} = ${2 * inputValue}$.`;
+        }
+        else if (inputValue < 5) {
+            exp += `Comme $2 \\leq ${inputValue} < 5$, on renvoie $${inputValue}^2 = ${inputValue ** 2}$.`;
+        }
+        else {
+            exp += `Comme $${inputValue} \\geq 5$, on renvoie $${inputValue} + 5 = ${inputValue + 5}$.`;
+        }
+    }
+    return exp;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPyIfElseConditionQuestion = () => {
+    const isCondition = coinFlip();
+    const inputValue = randint(0, 15);
+    return getQuestionFromIdentifiers({ isCondition, inputValue });
+};
+const getPropositions = (n, { answer, isCondition, inputValue }) => {
+    const propositions = [];
+    const correct = parseInt(answer);
+    addValidProp(propositions, correct.frenchify());
+    if (isCondition) {
+        tryToAddWrongProp(propositions, (inputValue + 3).frenchify());
+        tryToAddWrongProp(propositions, (2 * inputValue).frenchify());
+    }
+    else {
+        tryToAddWrongProp(propositions, (inputValue + 5).frenchify());
+        tryToAddWrongProp(propositions, (2 * inputValue).frenchify());
+        tryToAddWrongProp(propositions, (inputValue ** 2).frenchify());
+    }
+    tryToAddWrongProp(propositions, (correct + 1).frenchify());
+    tryToAddWrongProp(propositions, (correct - 1).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(0, 25).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const pyIfElseCondition = {
+    id: "pyIfElseCondition",
+    label: "Conditions simples et doubles en Python",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getPyIfElseConditionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getInstruction,
+    getHint,
+    getCorrection,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/python/variableType.d.ts

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

package/lib/exercises/math/python/variableType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableType.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/variableType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}

package/lib/exercises/math/python/variableType.js

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Nombre entier", "raw");
+    tryToAddWrongProp(propositions, "Nombre flottant", "raw");
+    tryToAddWrongProp(propositions, "Chaine de caractères", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { v, vType } = identifiers;
+    if (vType === "int") {
+        return "Nombre entier";
+    }
+    else if (vType === "float") {
+        return "Nombre flottant";
+    }
+    else if (vType === "str") {
+        return "Chaine de caractères";
+    }
+    else {
+        throw new Error(`Unknown type: ${vType}`);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { v, vType } = identifiers;
+    return `On exécute le script en Python ci-dessous :\n
+  \`\`\`python
+  v = ${vType === "str" ? `"${v}"` : v}
+  \`\`\`
+  \n
+  Quel est le type de la variable var ? 
+  `;
+};
+const getHint = (identifiers) => {
+    return "En Python, le type d'une variable peut être : un nombre entier, un nombre flottant (c'est à dire avec une virgule), ou une chaîne de caractère (c'est à dire un texte).";
+};
+const getCorrection = (identifiers) => {
+    const { v, vType } = identifiers;
+    let explanationType = "";
+    if (vType === "int") {
+        explanationType = "Nombre entier";
+    }
+    else if (vType === "float") {
+        explanationType = "Nombre flottant";
+    }
+    else if (vType === "str") {
+        explanationType = "Chaine de caractères";
+    }
+    return `En Python, le type d'une variable peut être : un nombre entier, un nombre flottant (c'est à dire avec une virgule), ou une chaîne de caractère (c'est à dire un texte).
+  
+Ici, la variable \`v\` est de type ${explanationType.toLocaleLowerCase()}.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getVariableTypeQuestion = (ops) => {
+    const vTypes = ["int", "float", "str"];
+    const vType = vTypes[randint(0, vTypes.length)];
+    let v;
+    if (vType === "int") {
+        v = randint(0, 100);
+    }
+    else if (vType === "float") {
+        v = randint(0, 100) + Math.random().toFixed(2);
+    }
+    else {
+        const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        const length = randint(3, 8);
+        let result = "";
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(randint(0, chars.length));
+        }
+        v = result;
+    }
+    const identifiers = { v, vType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const variableType = {
+    id: "variableType",
+    label: "Déterminer le type d’une variable en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVariableTypeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/python/whileLoop.js

@@ -17,7 +17,7 @@ const getAnswer = (identifiers) => {
 const getInstruction = (identifiers) => {
     const { a, initialValue, iterations, opIndex, step, x } = identifiers;
     const op = operations[opIndex];
-    return `Qu'affichera le programme suivant ?
+    return `Qu'affichera le programme suivant \`var\` ?
 \`\`\`
 a = ${a}
 n = ${initialValue}

package/lib/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}
+{"version":3,"file":"arithmeticExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.js

@@ -71,6 +71,7 @@ const getPropositions = (n, { answer, firstValue, askedRank, reason }) => {
 const isAnswerValid = (ans, { answer, askedRank }) => {
     return [
         answer,
+        `u${askedRank}=${answer}`,
         `u_${askedRank}=${answer}`,
         `u_{${askedRank}}=${answer}`,
     ].includes(ans);

package/lib/exercises/math/sequences/arithmetic/arithmeticFindReason.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindReason.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -63,7 +64,7 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
 export const arithmeticFindReason = {
     id: "arithmeticFindReason",

package/lib/exercises/math/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AA6GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAwIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}