math-exercises 3.0.109 → 3.0.110

package/lib/exercises/math/calcul/addAndSubWithoutRelatives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addAndSubWithoutRelatives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/addAndSubWithoutRelatives.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AAEH,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA+EzC,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"addAndSubWithoutRelatives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/addAndSubWithoutRelatives.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAG3B;;GAEG;AAEH,KAAK,WAAW,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAmFzC,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/calcul/addAndSubWithoutRelatives.js

@@ -8,7 +8,11 @@ import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const getInstruction = (identifiers) => {
     const { numbers } = identifiers;
-    return `Calculer : $${getStartStatement(identifiers)}$`;
+    return `Calculer : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
 };
 const getAnswer = (identifiers) => {
     const { numbers } = identifiers;

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.js

@@ -119,7 +119,7 @@ L'abscisse du point d'inflexion est donc $${inflexionPoint.toTex()}$.`;
 };
 export const inflexionPointQuadrinomials = {
     id: "inflexionPointQuadrinomials",
-    label: "Calcul du point d'inflexion",
+    label: "Calculer l'abscisse du point d'inflexion",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getInflexionPointQuadrinomialsQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/limits/sequencePolynomLimit.js

@@ -4,7 +4,7 @@ import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/po
 import { randint } from "../../../math/utils/random/randint.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
-    const poly = new Polynomial(identifiers.coeffs);
+    const poly = new Polynomial(identifiers.coeffs, "n");
     return `Déterminer la limite de la suite $u$ définie par : 
   
 $$
@@ -13,7 +13,7 @@ $$`;
 };
 const getAnswer = (identifiers) => {
     const to = "+\\infty";
-    const poly = new Polynomial(identifiers.coeffs);
+    const poly = new Polynomial(identifiers.coeffs, "n");
     const answer = poly.getLimit(to);
     return answer;
 };

package/lib/exercises/math/limits/sequencePolynomNoFILimit.js

@@ -4,7 +4,7 @@ import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/po
 import { randint } from "../../../math/utils/random/randint.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
-    const poly = new Polynomial(identifiers.coeffs);
+    const poly = new Polynomial(identifiers.coeffs, "n");
     return `Déterminer la limite de la suite $u$ définie par :
   
 $$
@@ -13,7 +13,7 @@ $$`;
 };
 const getAnswer = (identifiers) => {
     const to = "+\\infty";
-    const poly = new Polynomial(identifiers.coeffs);
+    const poly = new Polynomial(identifiers.coeffs, "n");
     const answer = poly.getLimit(to);
     return answer;
 };

package/lib/exercises/math/limits/sequencePolynomProductLimit.js

@@ -7,8 +7,8 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { polyNumCoeffs, polyDenumCoeffs } = identifiers;
-    const polyNum = new Polynomial(polyNumCoeffs);
-    const polyDenum = new Polynomial(polyDenumCoeffs);
+    const polyNum = new Polynomial(polyNumCoeffs, "n");
+    const polyDenum = new Polynomial(polyDenumCoeffs, "n");
     return `Déterminer la limite de la suite $u$ définie par : 
 
 $$
@@ -17,8 +17,8 @@ $$`;
 };
 const getAnswer = (identifiers) => {
     const { polyNumCoeffs, polyDenumCoeffs } = identifiers;
-    const polyNum = new Polynomial(polyNumCoeffs);
-    const polyDenum = new Polynomial(polyDenumCoeffs);
+    const polyNum = new Polynomial(polyNumCoeffs, "n");
+    const polyDenum = new Polynomial(polyDenumCoeffs, "n");
     const numLeadingCoeff = polyNum.coefficients[polyNum.degree];
     const denumLeadingCoeff = polyDenum.coefficients[polyDenum.degree];
     const product = new Monom(polyNum.degree + polyDenum.degree, numLeadingCoeff * denumLeadingCoeff, "n");

package/lib/exercises/math/limits/sequenceRationalFracLimit.js

@@ -8,8 +8,8 @@ import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { numCoeffs, denumCoeffs } = identifiers;
-    const polyNum = new Polynomial(numCoeffs);
-    const polyDenum = new Polynomial(denumCoeffs);
+    const polyNum = new Polynomial(numCoeffs, "n");
+    const polyDenum = new Polynomial(denumCoeffs, "n");
     return `Déterminer la limite de la suite $u$ définie par : 
   
 $$
@@ -18,8 +18,8 @@ $$`;
 };
 const getAnswer = (identifiers) => {
     const { numCoeffs, denumCoeffs } = identifiers;
-    const polyNum = new Polynomial(numCoeffs);
-    const polyDenum = new Polynomial(denumCoeffs);
+    const polyNum = new Polynomial(numCoeffs, "n");
+    const polyDenum = new Polynomial(denumCoeffs, "n");
     let answer = "";
     const to = "+\\infty";
     const numLeadingCoeff = polyNum.coefficients[polyNum.degree];

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

@@ -3,6 +3,7 @@ type Identifiers = {
     a: number;
     b: number;
     opName: string;
+    ineqs: string[];
 };
 export declare const conditionIfElifElse: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"conditionIfElifElse.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/conditionIfElifElse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+HF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"conditionIfElifElse.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/conditionIfElifElse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAmJF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

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

@@ -2,36 +2,39 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.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 getAnswer = ({ a, b, opName, ineqs }) => {
     const operation = operations.find((op) => op.name === opName);
     const opresult = operation.func(a, b);
-    let result;
+    const results = [b, opresult + b, opresult + 1];
+    const unshuffledIneqs = ["<", "==", ">"];
+    const shuffledResults = unshuffledIneqs.map((e) => results[ineqs.indexOf(e)]);
     if (opresult < b) {
-        result = b;
+        return shuffledResults[0].frenchify();
     }
     else if (opresult === b) {
-        result = opresult + b;
+        return shuffledResults[1].frenchify();
     }
     else {
-        result = opresult + 1;
+        return shuffledResults[2].frenchify();
     }
-    return result.frenchify();
 };
-const getInstruction = ({ a, b, opName }) => `
-Quel sera l'affichage du code suivant ?
+const getInstruction = ({ a, b, opName, ineqs, }) => `
+Quel sera l'affichage du script en Python suivant ?
+
 \`\`\`python
 a = ${a}
 b = ${b}
 a = a ${opName} b
-if a < b:
+if a ${ineqs[0]} b:
     a = b
-elif a == b:
+elif a ${ineqs[1]} b:
     a = a + b
 else:
     a = a + 1
@@ -39,17 +42,21 @@ 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 getCorrection = ({ a, b, opName, ineqs }) => {
     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}$.`;
+    if ((ineqs[0] === "<" && opresult < b) ||
+        (ineqs[0] === ">" && opresult > b) ||
+        (ineqs[0] === "==" && opresult === b)) {
+        branch = `La condition $a ${ineqs[0]} b$ est vraie $(${opresult} ${ineqs[0]} ${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}$.`;
+    else if ((ineqs[1] === "<" && opresult < b) ||
+        (ineqs[1] === ">" && opresult > b) ||
+        (ineqs[1] === "==" && opresult === b)) {
+        branch = `La condition $a ${ineqs[0]} b$ est fausse mais la condition $a ${ineqs[1]} b$ est vraie $(${opresult} ${ineqs[1]} ${b})$, on exécute le bloc elif donc : $a = ${opresult} + ${b} = ${opresult + b}$.`;
         finalValue = opresult + b;
     }
     else {
@@ -74,7 +81,8 @@ const getConditionIfElifElseQuestion = () => {
     } while ((target === "lt" && !(opresult < b)) ||
         (target === "eq" && !(opresult === b)) ||
         (target === "gt" && !(opresult > b)));
-    return getQuestionFromIdentifiers({ a, b, opName: operation.name });
+    const ineqs = shuffle(["<", "==", ">"]);
+    return getQuestionFromIdentifiers({ a, b, opName: operation.name, ineqs });
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {

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

@@ -30,7 +30,7 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getHint = (identifiers) => {
-    return `L'instruction \`for i in range(a,b)\` est une boucle dans laquelle $i$ prend d'abord la valeur $a$, puis augmente de $1$ jusqu'à atteindre $b$ (exclus). `;
+    return `L'instruction \`for i in range(a,b)\` est une boucle dans laquelle $i$ prend d'abord la valeur $a$, puis augmente de $1$ jusqu'à atteindre $b$ (exclu). `;
 };
 const getCorrection = (identifiers) => {
     const { initialValue, step, iterations, opIndex } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"inOutCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/inOutCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAoHF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"inOutCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/inOutCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAsHF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}

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

@@ -32,7 +32,11 @@ print(a)
 };
 const getHint = (identifiers) => {
     const { a, b, id1, id2 } = identifiers;
-    return `Suis le script ligne par ligne, en remplaçant les variables par les valeurs qu'elles ont prises aux lignes précédentes.`;
+    let divisionHint = `En Python, l'opération \`//\` est une division entière : \`a // b\` donne le quotient de la division euclidienne de \`a\` par \`b\`. Par exemple, \`20//3 = 6\`, car le quotient de la division euclidienne de $20$ par $3$ est $6$.`;
+    let corr = `Suis le script ligne par ligne, en remplaçant les variables par les valeurs qu'elles ont prises aux lignes précédentes.`;
+    if (id1 === 3 || id2 === 3)
+        return corr + "\n" + divisionHint;
+    return corr;
 };
 const getCorrection = (identifiers) => {
     const { a, b, id1, id2 } = identifiers;

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

@@ -25,7 +25,7 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const { a, b, op } = identifiers;
-    return `Qu'affichera le script Python suivant, si l'utilisateur entre $${a}$ ?
+    return `Qu'affichera le script en Python suivant si l'utilisateur entre $${a}$ ?
   \`\`\`
   a=input("Entrez un entier naturel non nul.")
   a=int(a)

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

@@ -1 +1 @@
-{"version":3,"file":"pythonForLoopInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonForLoopInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAkBpE,CAAC"}
+{"version":3,"file":"pythonForLoopInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonForLoopInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoIF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAkBpE,CAAC"}

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

@@ -7,32 +7,32 @@ const getPropositions = (n, { answer, coeff, iterations, operation }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, `\`${operation}${coeff}\``, "raw");
-    tryToAddWrongProp(propositions, `\`x${operation}${iterations}\``, "raw");
+    tryToAddWrongProp(propositions, `\`a${operation}${iterations}\``, "raw");
     tryToAddWrongProp(propositions, `\`${coeff}\``, "raw");
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    return `a${identifiers.operation}${identifiers.coeff}`;
+    return `\`a${identifiers.operation}${identifiers.coeff}\``;
 };
 const getInstruction = (identifiers) => {
     let word = "";
     const { coeff, iterations, operation } = identifiers;
     switch (operation) {
         case "+":
-            word = "l'additionner";
+            word = `lui ajouter $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "-":
-            word = "le soustraire";
+            word = `lui soustraire $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "*":
-            word = "le multiplier";
+            word = `le multiplier à $${iterations}$ reprises par $${coeff}$`;
             break;
         case "/":
         default:
-            word = "le diviser";
+            word = `le diviser à $${iterations}$ reprises par $${coeff}$`;
             break;
     }
-    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word} à $${iterations}$ reprises par $${coeff}$, puis de renvoyer le résultat du calcul.
+    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word}, puis de renvoyer le résultat du calcul.
   
 Par quoi faut-il remplacer les trois points ?
 
@@ -63,14 +63,23 @@ x = x${fakeOperation}${fakeCoeff}
 };
 const getCorrection = (identifiers) => {
     const { coeff, iterations, operation } = identifiers;
-    const word = operation === "/"
-        ? "diviser"
-        : operation === "+"
-            ? "additionner"
-            : operation === "-"
-                ? "soustraire"
-                : "multiplier";
-    return `On veut ${word} \`a\` par $${coeff}$ à chaque exécution de la boucle \`for\`. En python, cela se traduit par : 
+    let word = "";
+    switch (operation) {
+        case "+":
+            word = `ajouter $${coeff}$ à \`a\``;
+            break;
+        case "-":
+            word = `soustraire $${coeff}$ à \`a\``;
+            break;
+        case "*":
+            word = `multiplier \`a\` par $${coeff}$`;
+            break;
+        case "/":
+        default:
+            word = `diviser \`a\` par $${coeff}$`;
+            break;
+    }
+    return `On veut ${word} à chaque exécution de la boucle \`for\`. En python, cela se traduit par : 
   
 \`\`\`
 a=a${operation}${coeff}

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

@@ -1 +1 @@
-{"version":3,"file":"pythonRangeCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonRangeCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}
+{"version":3,"file":"pythonRangeCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonRangeCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

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

@@ -6,6 +6,8 @@ import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, Number(answer) + 1 + "");
+    tryToAddWrongProp(propositions, Number(answer) - 1 + "");
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, randint(1, 20).frenchify());
     }
@@ -19,20 +21,20 @@ const getInstruction = (identifiers) => {
     const { coeff, iterations, operation } = identifiers;
     switch (operation) {
         case "+":
-            word = "l'additionner";
+            word = `lui ajouter $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "-":
-            word = "le soustraire";
+            word = `lui soustraire $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "*":
-            word = "le multiplier";
+            word = `le multiplier à $${iterations}$ reprises par $${coeff}$`;
             break;
         case "/":
         default:
-            word = "le diviser";
+            word = `le diviser à $${iterations}$ reprises par $${coeff}$`;
             break;
     }
-    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word} à $${iterations}$ reprises par $${coeff}$, puis de renvoyer le résultat du calcul.
+    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word}, puis de renvoyer le résultat du calcul.
   
 Par quoi faut-il remplacer les trois points ?
 

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

@@ -32,8 +32,8 @@ const getInstruction = (identifiers) => {
     const { variableName, initialVariable, affines } = identifiers;
     const affinePythonStrings = affines
         .map((a) => a.toPython())
-        .join(`;\n${variableName} = `);
-    return `On exécute le script Python ci-dessous. Quelle est la valeur de \`${variableName}\` à la fin du script ?
+        .join(`\n${variableName} = `);
+    return `On exécute le script en Python ci-dessous. Quelle est la valeur de \`${variableName}\` à la fin du script ?
 
 \`\`\`
 ${variableName} = ${initialVariable}
@@ -53,7 +53,7 @@ const getCorrection = (identifiers) => {
   et on affecte cette valeur dans la variable \`${variableName}\`. On a donc :
   
 \`\`\`
-${variableName} = ${initialVariable}; # Ici ${variableName} = ${variable}
+${variableName} = ${initialVariable} # Ici ${variableName} = ${variable}
 ${affines
         .map((a) => {
         evVariable = a
@@ -62,8 +62,8 @@ ${affines
         variable = a.calculate(variable);
         return (`${variableName} = ` +
             a.toPython() +
-            `; # Ici ${variableName} = ${evVariable
-                .toTex()
+            ` # Ici ${variableName} = ${evVariable
+                .toTex({ forceNoSimplification: true })
                 .replace("\\times", "*")
                 .replaceAll("\\left", "")
                 .replaceAll("\\right", "")} = ${variable}\n`);
@@ -105,10 +105,10 @@ const getVariableAffectationQuestion = (ops) => {
             affines.push(new Affine(1, randint(-4, 5, [0]), variableName));
         }
         else if (type === 2) {
-            affines.push(new Affine(randint(-4, 5, [0]), 0, variableName));
+            affines.push(new Affine(randint(-4, 5, [0, 1]), 0, variableName));
         }
         else {
-            affines.push(AffineConstructor.random({ min: -4, max: 4 }, { min: -5, max: 5 }, variableName));
+            affines.push(AffineConstructor.random({ min: -4, max: 4, excludes: [0, 1] }, { min: -5, max: 5, excludes: [0] }, variableName));
         }
     }
     const identifiers = { variableName, initialVariable, affines };

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

@@ -1 +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"}
+{"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;AAwGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}

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

@@ -7,7 +7,7 @@ const getPropositions = (n, { answer }) => {
     addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, "Nombre entier", "raw");
     tryToAddWrongProp(propositions, "Nombre flottant", "raw");
-    tryToAddWrongProp(propositions, "Chaine de caractères", "raw");
+    tryToAddWrongProp(propositions, "Chaîne de caractères", "raw");
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
@@ -19,7 +19,7 @@ const getAnswer = (identifiers) => {
         return "Nombre flottant";
     }
     else if (vType === "str") {
-        return "Chaine de caractères";
+        return "Chaîne de caractères";
     }
     else {
         throw new Error(`Unknown type: ${vType}`);
@@ -28,15 +28,16 @@ const getAnswer = (identifiers) => {
 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 ? 
+
+\`\`\`python
+v = ${vType === "str" ? `"${v}"` : v}
+\`\`\`
+
+Quel est le type de la variable \`v\` ? 
   `;
 };
 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).";
+    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;
@@ -48,9 +49,9 @@ const getCorrection = (identifiers) => {
         explanationType = "Nombre flottant";
     }
     else if (vType === "str") {
-        explanationType = "Chaine de caractères";
+        explanationType = "Chaîne 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).
+    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()}.`;
 };

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

@@ -2,7 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = ({ inputValue, threshold, }) => {
-    return `On définit la fonction en Python boucle.
+    return `On définit la fonction en Python suivante :
 
 \`\`\`python
 def boucle(x):

package/lib/index.d.ts

@@ -2550,6 +2550,7 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     opName: string;
+    ineqs: string[];
 }, {}> | Exercise<{
     coeff: number;
     iterations: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,UAAU,YAAW,CAAC;AAEnC;;;;GAIG"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,UAAU,YAAW,CAAC;AAEnC;;;;GAIG"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.109",
+  "version": "3.0.110",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [