math-exercises 3.0.76 → 3.0.78

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

@@ -0,0 +1,121 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
+const operations = [
+    { name: "+", func: (x, step) => x + step },
+    { name: "-", func: (x, step) => x - step },
+    { name: "*", func: (x, step) => x * step },
+    { name: "//", func: (x, step) => Math.floor(x / step) },
+];
+const getAnswer = ({ a, b, opName }) => {
+    const operation = operations.find((op) => op.name === opName);
+    const opresult = operation.func(a, b);
+    let result;
+    if (opresult < b) {
+        result = b;
+    }
+    else if (opresult === b) {
+        result = opresult + b;
+    }
+    else {
+        result = opresult + 1;
+    }
+    return result.frenchify();
+};
+const getInstruction = ({ a, b, opName }) => `
+Quel sera l'affichage du code suivant ?
+\`\`\`python
+a = ${a}
+b = ${b}
+a = a ${opName} b
+if a < b:
+    a = b
+elif a == b:
+    a = a + b
+else:
+    a = a + 1
+print(a)
+\`\`\`
+`;
+const getHint = ({ opName }) => `Calcule la valeur de $a$ avec $a = a ${opName} b$ puis applique la condition if-elif-else.`;
+const getCorrection = ({ a, b, opName }) => {
+    const operation = operations.find((op) => op.name === opName);
+    const opresult = operation.func(a, b);
+    let branch;
+    let finalValue;
+    if (opresult < b) {
+        branch = `La condition $a < b$ est vraie $(${opresult} < ${b})$, on exécute le bloc if donc : $a = ${b}$.`;
+        finalValue = b;
+    }
+    else if (opresult === b) {
+        branch = `La condition $a < b$ est fausse mais la condition $a == b$ est vraie $(${opresult} == ${b})$, on exécute le bloc elif donc : $a = ${opresult} + ${b} = ${opresult + b}$.`;
+        finalValue = opresult + b;
+    }
+    else {
+        branch = `Les deux conditions précédentes (If, Elif) sont fausses, on exécute le bloc else donc : $a = ${opresult} + 1 = ${opresult + 1}$.`;
+        finalValue = opresult + 1;
+    }
+    return `On calcule l'opération $a ${opName} b$ ce qui donne : $${a} ${opName} ${b} = ${opresult}$.
+
+${branch}
+
+Le résultat final affiché sera : $${finalValue}$.`;
+};
+const getConditionIfElifElseQuestion = () => {
+    const targets = ["lt", "eq", "gt"];
+    const target = random(targets);
+    let a, b, operation, opresult;
+    do {
+        a = randint(0, 50);
+        b = randint(0, 50);
+        operation = random(operations);
+        opresult = operation.func(a, b);
+    } while ((target === "lt" && !(opresult < b)) ||
+        (target === "eq" && !(opresult === b)) ||
+        (target === "gt" && !(opresult > b)));
+    return getQuestionFromIdentifiers({ a, b, opName: operation.name });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["a", "b", "equal"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, opName }) => {
+    const propositions = [];
+    const operation = operations.find((op) => op.name === opName);
+    const opresult = operation.func(a, b);
+    const equalResult = opresult + b;
+    const elseResult = opresult + 1;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, a.frenchify());
+    tryToAddWrongProp(propositions, b.frenchify());
+    tryToAddWrongProp(propositions, equalResult.frenchify());
+    tryToAddWrongProp(propositions, elseResult.frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(0, 10).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => ans === answer;
+export const conditionIfElifElse = {
+    id: "conditionIfElifElse",
+    label: "Condition if-elif-else",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConditionIfElifElseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getHint,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -11,4 +11,5 @@ export * from "./variableType.js";
 export * from "./whileLoopCount.js";
 export * from "./conditionIfElse.js";
 export * from "./variableAffectation.js";
+export * from "./conditionIfElifElse.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;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,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;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

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

@@ -11,3 +11,4 @@ export * from "./variableType.js";
 export * from "./whileLoopCount.js";
 export * from "./conditionIfElse.js";
 export * from "./variableAffectation.js";
+export * from "./conditionIfElifElse.js";

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

@@ -1 +1 @@
-{"version":3,"file":"pyNestedForLoopExercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyNestedForLoopExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAGX,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"pyNestedForLoopExercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyNestedForLoopExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAGX,CAAC;AAuGF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -19,18 +19,31 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const { n, p, op } = identifiers;
-    return `Qu'affichera le programme suivant ?
-  \`\`\`
-  s=0
-  n=${n}
-  p=${p}
-  for i in range(1,n+1):
-    for j in range(1,p+1):
-      s=s${op}1
-  print(s) 
-  \`\`\`
+    return `Qu'affichera le script en Python suivant ?
+\`\`\`
+s=0
+n=${n}
+p=${p}
+for i in range(1,n+1):
+  for j in range(1,p+1):
+    s=s${op}1
+print(s) 
+\`\`\`
   `;
 };
+const getHint = (identifiers) => {
+    return `La deuxième boucle for s'exécute entièrement à chaque éxécution de la première boucle.`;
+};
+const getCorrection = (identifiers) => {
+    const { n, p, op } = identifiers;
+    return `La première boucle for s'exécute $${n}$ fois (car \`range(1, ${n + 1})\` correspond aux nombres de $1$ à $${n}$). 
+  
+A chaque exécution de la première boucle, on exécute la deuxième boucle. Cette deuxième boucle s'exécute $${p}$ fois, à chaque exécution de la première boucle. 
+
+Au final, il y a donc $${n} \\times ${p} = ${n * p}$ exécutions de la deuxième boucle.
+
+A chaque exécution, on ${op === "+" ? "ajoute" : "soustrait"} $1$ à la variable $s$. Au total, on obtient donc $s = ${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -38,6 +51,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +92,5 @@ export const pyNestedForLoopExercise = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -3,7 +3,6 @@ type Identifiers = {
     a: number;
     b: number;
     op: string;
-    withInput: boolean;
 };
 export declare const pyWhileLoop1Exercise: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"pyWhileLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyWhileLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,OAAO,CAAC;CAGpB,CAAC;AAyGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"pyWhileLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyWhileLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;CAKZ,CAAC;AAwIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

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

@@ -2,20 +2,18 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { random } from "../../../utils/alea/random.js";
-const rebuildIdentifiers = (oldIds) => {
-    if (oldIds.op)
-        return oldIds;
-    return {
-        a: oldIds.exercise.a,
-        b: oldIds.exercise.b,
-        op: oldIds.exercise.op,
-        withInput: coinFlip(),
-    };
-};
+// const rebuildIdentifiers: RebuildIdentifiers<Identifiers> = (oldIds) => {
+//   if (oldIds.op) return oldIds;
+//   return {
+//     a: oldIds.exercise.a,
+//     b: oldIds.exercise.b,
+//     op: oldIds.exercise.op,
+//     withInput: coinFlip(),
+//   };
+// };
 const getAnswer = (identifiers) => {
-    const { a, b, withInput, op } = identifiers;
+    const { a, b, op } = identifiers;
     let n = 1;
     while (n <= a) {
         if (op === "+")
@@ -26,18 +24,8 @@ const getAnswer = (identifiers) => {
     return n.frenchify();
 };
 const getInstruction = (identifiers) => {
-    const { a, b, op, withInput } = identifiers;
-    if (!withInput)
-        return `Qu'affichera le programme suivant ?
-  \`\`\`
-  a=${a}
-  n=1
-  while n<=a:
-    n=${b}${op}n
-  print(n)
-  \`\`\`
-  `;
-    return `Qu'affichera le programme suivant, si l'utilisateur entre $${a}$ ?
+    const { a, b, op } = identifiers;
+    return `Qu'affichera le script Python suivant, si l'utilisateur entre $${a}$ ?
   \`\`\`
   a=input("Entrez un entier naturel non nul.")
   a=int(a)
@@ -48,6 +36,41 @@ const getInstruction = (identifiers) => {
   \`\`\`
   `;
 };
+const operations = [
+    { name: "+", func: (x, step) => x + step },
+    { name: "*", func: (x, step) => x * step },
+];
+const getHint = (identifiers) => {
+    const { a, b, op } = identifiers;
+    const operation = operations.find((o) => o.name === op);
+    return `La boucle s'exécute tant que la condition $n \\leq ${a}$ est vraie. À chaque itération, $n$ devient égal à $n ${operation.name} ${b}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, op } = identifiers;
+    const operation = operations.find((o) => o.name === op);
+    let n = 1;
+    let count = 0;
+    let allValues = [];
+    while (n <= a) {
+        allValues.push(n.frenchify());
+        n = operation.func(n, b);
+        count++;
+    }
+    allValues.push(n.frenchify());
+    return `Puisque l'utilisateur entre $${a}$, la variable $a$ prend la valeur $${a}$. 
+  
+On commence avec $n = 1$ et à chaque itération on effectue l'opération $n = n ${operation.name} ${b}$. La boucle while $n \\leq a$ s'exécute tant que $n$ est inférieur ou égal à $${a}$.
+
+$n$ prend donc les valeurs successives suivantes :
+
+$$
+${allValues.join("\\rightarrow ")}
+$$
+
+La boucle s'arrête alors car $${allValues[allValues.length - 1]} > ${a}$.
+
+Le programme affichera donc $${n.frenchify()}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -55,6 +78,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -72,18 +97,17 @@ const getPyWhileLoop1ExerciseQuestion = () => {
     const nbIter = randint(2, randCombination.maxIter + 1);
     const aA = op === "+" ? Math.ceil(b * nbIter) : Math.pow(b, nbIter);
     const a = randint(aA / b, aA);
-    const withInput = coinFlip();
-    const identifiers = { a, b, op, withInput };
+    const identifiers = { a, b, op };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer, a, b, withInput, op }) => {
+const getPropositions = (n, { answer, a, b, op }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const firstProposition = op === "*" ? +answer * b : +answer + b;
     tryToAddWrongProp(propositions, firstProposition + "");
     const secondProposition = op === "*" ? +answer / b : +answer - b;
     tryToAddWrongProp(propositions, secondProposition + "");
-    const correctAnswer = Number(getAnswer({ a, b, withInput, op }));
+    const correctAnswer = Number(getAnswer({ a, b, op }));
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, randint(correctAnswer - 11, correctAnswer + 11, [correctAnswer, 0]) + "");
     }
@@ -94,7 +118,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
 };
 export const pyWhileLoop1Exercise = {
     id: "pyWhileLoop1Exercise",
-    label: "Boucles while $1$",
+    label: "Boucle while en Python (avec entrée utilisateur)",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPyWhileLoop1ExerciseQuestion, nb),
     qcmTimer: 60,
@@ -103,6 +127,5 @@ export const pyWhileLoop1Exercise = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
-    rebuildIdentifiers,
-    // hasHintAndCorrection: true,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"pythonFunctionTrinom.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonFunctionTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}
+{"version":3,"file":"pythonFunctionTrinom.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonFunctionTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8FF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

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

@@ -4,12 +4,13 @@ import { Trinom, TrinomConstructor } from "../../../math/polynomials/trinom.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../tree/nodes/equations/equalNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { x, trinom } = identifiers;
     const tri = new Trinom(trinom[0], trinom[1], trinom[2]);
     const image = tri.calculate(x);
     const equation = tri.toPython();
-    return `Qu'affichera le programme suivant ?
+    return `Qu'affichera le script en Python suivant ?
 \`\`\`
 def f(x):
     y = ${equation}
@@ -19,6 +20,24 @@ print(y)
 \`\`\`
 `;
 };
+const getHint = (identifiers) => {
+    return `En Python, l'opération ** signifie "puissance". `;
+};
+const getCorrection = (identifiers) => {
+    const { image, trinom, x } = identifiers;
+    const tri = new Trinom(trinom[0], trinom[1], trinom[2]);
+    return `On appelle la fonction $f$ avec comme argument $x=${x}$.
+  
+Le calcul effectué par la fonction est donc : 
+
+${alignTex([
+        ["y", "=", tri.toTree().toDetailedEvaluation({ x: x.toTree() }).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+
+Le script affiche ensuite la valeur de $y$ : il affichera donc $${getAnswer(identifiers)}$.
+`;
+};
 const getAnswer = (identifiers) => {
     const { image } = identifiers;
     return image.frenchify();
@@ -37,6 +56,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["f", "x", "y", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -70,4 +91,5 @@ export const pythonFunctionTrinom = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -52,7 +52,7 @@ $$
 ${allValues.join("\\rightarrow ")}
 $$
 
-La boucle s'arrêtte alors car $${allValues[allValues.length - 1]} > ${a}$.
+La boucle s'arrête alors car $${allValues[allValues.length - 1]} > ${a}$.
   
 Le programme affichera donc $${n.frenchify()}$.`;
 };
@@ -105,7 +105,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 export const whileLoop = {
     id: "whileLoop",
-    label: "Boucle while $2$ (Python)",
+    label: "Boucle while en Python",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getWhileLoopQuestion, nb),
     qcmTimer: 60,

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

@@ -43,7 +43,7 @@ $$
 ${allValues.join("\\rightarrow ")}
 $$
 
-La boucle s'arrêtte alors car $${allValues[allValues.length - 1]} < ${threshold}$.
+La boucle s'arrête alors car $${allValues[allValues.length - 1]} < ${threshold}$.
   
   La boucle s'exécute donc $${count}$ fois.`;
 };

package/lib/exercises/math/sequences/explicitFormulaUsage.js

@@ -4,7 +4,7 @@ import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/po
 import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { rank, coeffs } = identifiers;
-    const u = new Polynomial(coeffs);
+    const u = new Polynomial(coeffs, "n");
     return `Soit $u$ la suite définie pour tout $n\\geq 0$ par 
   
 $$
@@ -15,7 +15,7 @@ Calculer $u_${rank}$.`;
 };
 const getAnswer = (identifiers) => {
     const { rank, coeffs } = identifiers;
-    const u = new Polynomial(coeffs);
+    const u = new Polynomial(coeffs, "n");
     const answer = u.calculate(rank) + "";
     return answer;
 };
@@ -37,7 +37,7 @@ const getExplicitFormulaUsageQuestion = () => {
 };
 const getPropositions = (n, { answer, rank, coeffs }) => {
     const propositions = [];
-    const u = new Polynomial(coeffs);
+    const u = new Polynomial(coeffs, "n");
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, u.calculate(rank - 1) + "");
     tryToAddWrongProp(propositions, u.calculate(rank + 1) + "");

package/lib/exercises/math/sequences/genericSequenceVariations.js

@@ -4,14 +4,14 @@ import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/po
 import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { coeffs } = identifiers;
-    const u = new Polynomial(coeffs);
+    const u = new Polynomial(coeffs, "n");
     return `Soit $u$ la suite définie par $u_n = ${u
         .toTree()
         .toTex()}$. Quel est le sens de variations de $u$ ?`;
 };
 const getAnswer = (identifiers) => {
     const { coeffs } = identifiers;
-    const u = new Polynomial(coeffs);
+    const u = new Polynomial(coeffs, "n");
     const [b, a] = u.coefficients.slice(1);
     const root = Math.ceil((-a - b) / (2 * a));
     const answer = root <= 0

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

@@ -1,3 +1,5 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
+export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

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

@@ -1,2 +1,4 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
+export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";

package/lib/exercises/math/sets/nameOfNumberSets.d.ts

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

package/lib/exercises/math/sets/nameOfNumberSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nameOfNumberSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/nameOfNumberSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,OAAO,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgJF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}

package/lib/exercises/math/sets/nameOfNumberSets.js

@@ -0,0 +1,125 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, isQuestionAboutNotation }) => {
+    const propositions = [];
+    if (isQuestionAboutNotation) {
+        addValidProp(propositions, answer);
+        tryToAddWrongProp(propositions, "\\mathbb{R}");
+        tryToAddWrongProp(propositions, "\\mathbb{Q}");
+        tryToAddWrongProp(propositions, "\\mathbb{N}");
+        tryToAddWrongProp(propositions, "\\mathbb{Z}");
+        tryToAddWrongProp(propositions, "\\mathbb{D}");
+    }
+    else {
+        addValidProp(propositions, answer, "raw");
+        tryToAddWrongProp(propositions, "nombres réels", "raw");
+        tryToAddWrongProp(propositions, "nombres rationnels", "raw");
+        tryToAddWrongProp(propositions, "nombres entiers naturels", "raw");
+        tryToAddWrongProp(propositions, "nombres entiers relatifs", "raw");
+        tryToAddWrongProp(propositions, "nombres décimaux", "raw");
+    }
+    return shuffleProps(propositions, n);
+};
+const getHint = (identifiers) => {
+    return `On a les inclusions suivantes : 
+
+$$
+\\mathbb{N}\\subset \\mathbb{Z}\\subset \\mathbb{D}\\subset \\mathbb{Q}\\subset \\mathbb{R}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { caseNumber, isQuestionAboutNotation } = identifiers;
+    if (isQuestionAboutNotation)
+        return `L'ensemble des ${caseNumberToSetName(!isQuestionAboutNotation, caseNumber)} se note : $${caseNumberToSetName(isQuestionAboutNotation, caseNumber)}$.`;
+    return `$${caseNumberToSetName(!isQuestionAboutNotation, caseNumber)}$ est l'ensemble des ${caseNumberToSetName(isQuestionAboutNotation, caseNumber)}.`;
+};
+const caseNumberToSetName = (isQuestionAboutNotation, caseNumber) => {
+    if (isQuestionAboutNotation) {
+        switch (caseNumber) {
+            case 0:
+                return "\\mathbb{R}";
+            case 1:
+                return "\\mathbb{Q}";
+            case 2:
+                return "\\mathbb{N}";
+            case 3:
+                return "\\mathbb{Z}";
+            case 4:
+            default:
+                return "\\mathbb{D}";
+        }
+    }
+    else {
+        switch (caseNumber) {
+            case 0:
+                return "nombres réels";
+            case 1:
+                return "nombres rationnels";
+            case 2:
+                return "nombres entiers naturels";
+            case 3:
+                return "nombres entiers relatifs";
+            case 4:
+            default:
+                return "nombres décimaux";
+        }
+    }
+};
+const getAnswer = ({ isQuestionAboutNotation, caseNumber, }) => {
+    return caseNumberToSetName(isQuestionAboutNotation, caseNumber);
+};
+const getInstruction = ({ isQuestionAboutNotation, caseNumber, }) => {
+    if (isQuestionAboutNotation) {
+        return `Comment se note l'ensemble des ${caseNumberToSetName(!isQuestionAboutNotation, caseNumber)} ?`;
+    }
+    else {
+        return `$${caseNumberToSetName(!isQuestionAboutNotation, caseNumber)}$ est l'ensemble des ...`;
+    }
+};
+const getKeys = (identifiers) => {
+    return ["naturals", "integers", "rationals", "decimals", "reals"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getNameOfNumberSetsQuestion = (ops) => {
+    const caseNumber = randint(0, 5);
+    const isQuestionAboutNotation = coinFlip();
+    const identifiers = { caseNumber, isQuestionAboutNotation };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: identifiers.isQuestionAboutNotation ? "tex" : "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const nameOfNumberSets = {
+    id: "nameOfNumberSets",
+    label: "Nommer les ensembles des nombres",
+    answerType: "QCU",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getNameOfNumberSetsQuestion(opts), 5),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts

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

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsetsOfKnownSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/subsetsOfKnownSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAiGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}