math-exercises 3.0.75 → 3.0.76

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

@@ -0,0 +1,119 @@
+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 { 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 = (identifiers) => {
+    const { a, b, opName, condition } = identifiers;
+    const operation = operations.find((op) => op.name === opName);
+    const opresult = operation.func(a, b);
+    const answer = (condition === "a <= b" ? opresult <= b : opresult >= b)
+        ? b
+        : opresult + 1;
+    return answer.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, opName, condition } = identifiers;
+    return `Quel sera l'affichage du script en Python suivant ?
+\`\`\`python
+a = ${a}
+b = ${b}
+a = a ${opName} b
+if ${condition} :
+    a = b
+else :
+    a = a + 1
+print(a)
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    const { opName, condition } = identifiers;
+    return `Calcule la valeur de $a$ après l'exécution de l'instruction $a = a ${opName} b$. 
+  
+Ensuite, vérifie si la condition $${condition}$ est vraie ou fausse.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, opName, condition } = identifiers;
+    const operation = operations.find((op) => op.name === opName);
+    const opresult = operation.func(a, b);
+    const finalValue = (condition === "a <= b" ? opresult <= b : opresult >= b)
+        ? b
+        : opresult + 1;
+    const branch = condition === "a <= b" ? opresult <= b : opresult >= b;
+    const branchText = branch
+        ? `La condition $${condition}$ est donc vraie. On exécute alors le bloc \`if\` donc : $a = ${b}$.`
+        : `La condition $${condition}$ est donc fausse. On exécute alors le bloc \`else\` donc : 
+    
+$$
+a = ${opresult} + 1 = ${opresult + 1}
+$$`;
+    return `On calcule l'opération $a ${opName} b$ : 
+  
+$$
+${a} ${opName} ${b} = ${opresult}
+$$
+
+
+${branchText}
+
+Le résultat final affiché sera  : $${finalValue}$.`;
+};
+const getConditionIfElseQuestion = () => {
+    const a = randint(0, 10, [0, 1]);
+    const b = randint(0, 10, [0, 1]);
+    const operation = random(operations);
+    const condition = coinFlip() ? "a <= b" : "b <= a";
+    const identifiers = { a, b, opName: operation.name, condition };
+    return getQuestionFromIdentifiers(identifiers);
+};
+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 elseResult = opresult + 1;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, a.frenchify());
+    tryToAddWrongProp(propositions, b.frenchify());
+    tryToAddWrongProp(propositions, opresult.frenchify());
+    tryToAddWrongProp(propositions, elseResult.frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(0, 10).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const conditionIfElse = {
+    id: "conditionIfElse",
+    label: "Condition if-else",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConditionIfElseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getHint,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"forLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/forLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwGF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAWzC,CAAC"}
+{"version":3,"file":"forLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/forLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsIF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAYzC,CAAC"}

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

@@ -29,6 +29,31 @@ const getAnswer = (identifiers) => {
     const answer = value.toString();
     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). `;
+};
+const getCorrection = (identifiers) => {
+    const { initialValue, step, iterations, opIndex } = identifiers;
+    const op = operations[opIndex];
+    let allValues = [];
+    let n = initialValue;
+    for (let i = 0; i < iterations; i++) {
+        allValues.push(n.frenchify());
+        n = op.func(n, step);
+    }
+    allValues.push(n.frenchify());
+    return `La boucle \`for\` s'éxécute $${iterations}$ fois, car $i$ prend les valeurs de $0$ à $${iterations - 1}$.
+  
+À chaque itération, $x$ prend la valeur $x ${op.name} ${step}$. 
+
+$x$ prend donc les valeurs successives suivantes : 
+
+$$
+${allValues.join("\\rightarrow ")}
+$$
+
+Le programme affichera donc $${n.frenchify()}$.`;
+};
 const getForLoopQuestion = () => {
     const initialValue = randint(-10, 10, [0, 1]);
     const opIndex = randint(0, operations.length);
@@ -44,6 +69,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["a", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -96,4 +123,5 @@ export const forLoop = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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,EAYT,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;AAqFF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAW7C,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;AAoHF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}

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

@@ -30,11 +30,35 @@ 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.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, id1, id2 } = identifiers;
+    const op1 = operations[id1];
+    const op2 = operations[id2];
+    const interB = op1.func(a, b);
+    return `On détaille ligne par ligne le script : 
+
+\`\`\`
+a = ${a}
+b = ${b}
+b = a ${op1.name} b # Ici b prend la valeur ${a} ${op1.name} ${b} = ${interB}
+a = a ${op2.name} b # Ici, la valeur de b est ${interB}, donc a prend la valeur ${a} ${op2.name} ${interB} = ${op2.func(a, interB)}
+print(a) 
+\`\`\`
+L'affichage à la fin du script est donc $${op2.func(a, interB)}$.
+`;
+};
 const getInOutCalculQuestion = () => {
-    const a = randint(-10, 10);
-    const b = randint(-10, 10);
-    const id1 = randint(0, operations.length);
-    const id2 = randint(0, operations.length);
+    let a = randint(-10, 10);
+    let b = randint(-10, 10, [0]);
+    let id1 = randint(0, operations.length);
+    let id2 = randint(0, operations.length);
+    while (id2 === 3 && operations[id1].func(a, b) === 0) {
+        id2 = randint(0, operations.length);
+    }
     const identifiers = { a, b, id1, id2 };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -45,6 +69,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["a", "b", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -78,4 +104,5 @@ export const inOutCalcul = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -9,4 +9,6 @@ export * from "./pyNestedForLoopExercise.js";
 export * from "./pyIfElseCondition.js";
 export * from "./variableType.js";
 export * from "./whileLoopCount.js";
+export * from "./conditionIfElse.js";
+export * from "./variableAffectation.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"}
+{"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"}

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

@@ -9,3 +9,5 @@ export * from "./pyNestedForLoopExercise.js";
 export * from "./pyIfElseCondition.js";
 export * from "./variableType.js";
 export * from "./whileLoopCount.js";
+export * from "./conditionIfElse.js";
+export * from "./variableAffectation.js";

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

@@ -1 +1 @@
-{"version":3,"file":"pyForLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyForLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA0GF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAWxD,CAAC"}
+{"version":3,"file":"pyForLoop1Exercise.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pyForLoop1Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAuIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAYxD,CAAC"}

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

@@ -38,6 +38,32 @@ const getForLoopQuestion = () => {
     const identifiers = { initialValue, step, iterations, opIndex };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { initialValue, step, iterations, opIndex } = identifiers;
+    return `La valeur entrée par l'utilisateur va être affectée à la variable $y$. La boucle \`for\` s'exécute pour $i$ allant de $1$ à $${iterations}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { initialValue, step, iterations, opIndex } = identifiers;
+    const op = operations[opIndex];
+    let allValues = [];
+    let n = initialValue;
+    for (let i = 0; i < iterations; i++) {
+        allValues.push(n.frenchify());
+        n = op.func(n, step);
+    }
+    allValues.push(n.frenchify());
+    return `Puisque l'utilisateur entre la valeur $${step}$, y vaut $${step}$. La boucle \`for\` s'éxécute $${iterations}$ fois, car $i$ prend les valeurs de $1$ à $${iterations}$.
+  
+À chaque itération, $x$ prend la valeur $x ${op.name} ${step}$. 
+
+$x$ prend donc les valeurs successives suivantes : 
+
+$$
+${allValues.join("\\rightarrow ")}
+$$
+
+Le programme affichera donc $${n.frenchify()}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -45,6 +71,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["a", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -97,4 +125,5 @@ export const pythonForLoop1Exercise = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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,CAatD,CAAC"}
+{"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"}

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

@@ -104,4 +104,5 @@ export const pyWhileLoop1Exercise = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    // hasHintAndCorrection: true,
 };

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

@@ -61,7 +61,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 export const pythonFunctionTrinom = {
     id: "pythonFunctionTrinom",
-    label: "Valeur de retour d'une fonction",
+    label: "Valeur de retour d'une fonction en Python",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPythonFunctionTrinomQuestion, nb),
     qcmTimer: 60,

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { Affine } from "../../../math/polynomials/affine.js";
+type Identifiers = {
+    variableName: string;
+    initialVariable: number;
+    affines: Affine[];
+};
+export declare const variableAffectation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=variableAffectation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"variableAffectation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/variableAffectation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,MAAM,EAAqB,MAAM,kCAAkC,CAAC;AAQ7E,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwJF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

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

@@ -0,0 +1,144 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../math/polynomials/affine.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, initialVariable, affines }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${initialVariable}`);
+    let variable = initialVariable;
+    for (const affine of affines) {
+        variable = affine.calculate(variable);
+        tryToAddWrongProp(propositions, `${variable}`);
+        tryToAddWrongProp(propositions, `${add(variable, 1).simplify().toTex()}`);
+        tryToAddWrongProp(propositions, `${add(variable, -1).simplify().toTex()}`);
+        tryToAddWrongProp(propositions, `${multiply(variable, -1).simplify().toTex()}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { initialVariable, affines } = identifiers;
+    let variable = initialVariable;
+    for (const affine of affines) {
+        variable = affine.calculate(variable);
+    }
+    return `${variable}`;
+};
+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 ?
+
+\`\`\`
+${variableName} = ${initialVariable};
+${variableName} = ${affinePythonStrings};
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    const { variableName } = identifiers;
+    return `Pour chaque ligne, calcule la nouvelle valeur de \`${variableName}\`.`;
+};
+const getCorrection = (identifiers) => {
+    const { variableName, initialVariable, affines } = identifiers;
+    let variable = initialVariable;
+    let evVariable;
+    return `Pour chaque ligne, on calcule la valeur de l'expression à droite, 
+  et on affecte cette valeur dans la variable \`${variableName}\`. On a donc :
+  
+\`\`\`
+${variableName} = ${initialVariable}; # Ici ${variableName} = ${variable}
+${affines
+        .map((a) => {
+        evVariable = a
+            .toTree()
+            .toDetailedEvaluation({ [variableName]: variable.toTree() });
+        variable = a.calculate(variable);
+        return (`${variableName} = ` +
+            a.toPython() +
+            `; # Ici ${variableName} = ${evVariable
+                .toTex()
+                .replace("\\times", "*")
+                .replaceAll("\\left", "")
+                .replaceAll("\\right", "")} = ${variable}\n`);
+    })
+        .join("")}
+\`\`\`
+
+À la fin du script, \`${variableName}\` vaut donc $${variable}$. 
+  `;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getVariableAffectationQuestion = (ops) => {
+    const variableNames = [
+        "v",
+        "var",
+        "x",
+        "y",
+        "z",
+        "t",
+        "toto",
+        "tata",
+        "foo",
+        "bar",
+    ];
+    const variableName = random(variableNames);
+    const initialVariable = randint(-3, 3);
+    const numberOfLinesToGenerate = randint(1, 4);
+    let affines = [];
+    for (let i = 0; i < numberOfLinesToGenerate; i++) {
+        const type = randint(1, 4);
+        if (type === 1) {
+            affines.push(new Affine(1, randint(-4, 5, [0]), variableName));
+        }
+        else if (type === 2) {
+            affines.push(new Affine(randint(-4, 5, [0]), 0, variableName));
+        }
+        else {
+            affines.push(AffineConstructor.random({ min: -4, max: 4 }, { min: -5, max: 5 }, variableName));
+        }
+    }
+    const identifiers = { variableName, initialVariable, affines };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const variableAffectation = {
+    id: "variableAffectation",
+    label: "Affectation de variable et calculs simples",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVariableAffectationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,7 +2,6 @@ import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     initialValue: number;
     step: number;
-    iterations: number;
     opIndex: number;
     a: number;
     x: number;

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

@@ -1 +1 @@
-{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6FF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAW3C,CAAC"}
+{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}

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

@@ -10,14 +10,14 @@ const operationsreversed = [
     { name: "/", func: (x, step) => Math.floor(x / step) },
 ];
 const getAnswer = (identifiers) => {
-    const { a, initialValue, iterations, opIndex, step, x } = identifiers;
+    const { a, initialValue, opIndex, step, x } = identifiers;
     const answer = x.toString();
     return answer;
 };
 const getInstruction = (identifiers) => {
-    const { a, initialValue, iterations, opIndex, step, x } = identifiers;
+    const { a, initialValue, opIndex, step, x } = identifiers;
     const op = operations[opIndex];
-    return `Qu'affichera le programme suivant \`var\` ?
+    return `Qu'affichera le programme suivant ?
 \`\`\`
 a = ${a}
 n = ${initialValue}
@@ -27,6 +27,35 @@ print(n)
 \`\`\`
 `;
 };
+const getHint = (identifiers) => {
+    const { a, initialValue, opIndex, step, x } = identifiers;
+    const op = operations[opIndex];
+    return `La boucle s'exécute tant que la condition $n \\leq ${a}$ est vraie. À chaque itération, $n$ devient égal à $n ${op.name} ${step}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, initialValue, opIndex, step } = identifiers;
+    const op = operations[opIndex];
+    let n = initialValue;
+    let count = 0;
+    let allValues = [];
+    while (n <= a) {
+        allValues.push(n.frenchify());
+        n = op.func(n, step);
+        count++;
+    }
+    allValues.push(n.frenchify());
+    return `On commence avec $n = ${initialValue}$ et à chaque itération on effectue l'opération $n = n ${op.name} ${step}$. 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êtte alors car $${allValues[allValues.length - 1]} > ${a}$.
+  
+Le programme affichera donc $${n.frenchify()}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -34,6 +63,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["a", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -42,13 +73,12 @@ const getWhileLoopQuestion = () => {
     const opIndex = randint(0, operations.length);
     const op = operations[opIndex];
     const step = randint(1, 10, [0, 1]);
-    const iterations = randint(1, 6, [1]);
     let x = initialValue;
     const a = randint(10, 30);
     while (x <= a) {
         x = op.func(x, step);
     }
-    const identifiers = { initialValue, step, iterations, opIndex, a, x };
+    const identifiers = { initialValue, step, opIndex, a, x };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, step, opIndex, x }) => {
@@ -75,7 +105,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 export const whileLoop = {
     id: "whileLoop",
-    label: "Boucle while $2$",
+    label: "Boucle while $2$ (Python)",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getWhileLoopQuestion, nb),
     qcmTimer: 60,
@@ -84,4 +114,5 @@ export const whileLoop = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -23,7 +23,7 @@ const getAnswer = ({ inputValue, threshold }) => {
     return count.frenchify();
 };
 const getHint = ({ inputValue, threshold }) => {
-    return `La boucle s'exécute tant que la condition $x > ${threshold}$ est vraie. À chaque tour, $x$ est divisé par $2$. Compte combien de fois on peut diviser $${inputValue}$ par $2$ avant d'obtenir un résultat inférieur ou égal à $${threshold}$.`;
+    return `La boucle s'exécute tant que la condition $x > ${threshold}$ est vraie. À chaque itération, $x$ est divisé par $2$. Compte combien de fois on peut diviser $${inputValue}$ par $2$ avant d'obtenir un résultat inférieur ou égal à $${threshold}$.`;
 };
 const getCorrection = ({ inputValue, threshold, }) => {
     let x = inputValue;
@@ -78,7 +78,7 @@ const getPropositions = (n, { answer, inputValue, threshold }) => {
 const isAnswerValid = (ans, { answer }) => ans === answer;
 export const pyWhileLoopCount = {
     id: "whileLoopCount",
-    label: "Nombre d’itérations d’une boucle while",
+    label: "Nombre d'itérations d'une boucle while (Python)",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPyWhileLoopCountQuestion, nb),
     qcmTimer: 60,

package/lib/index.d.ts

@@ -74,6 +74,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -279,6 +282,9 @@ declare const mathExercises: (Exercise<{
     sign: number;
 }, {}> | Exercise<{
     n: number;
+}, {}> | Exercise<{
+    a: number;
+    isOpposite: boolean;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -2132,7 +2138,6 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     initialValue: number;
     step: number;
-    iterations: number;
     opIndex: number;
     a: number;
     x: number;
@@ -2158,6 +2163,15 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     inputValue: number;
     threshold: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    opName: string;
+    condition: string;
+}, {}> | Exercise<{
+    variableName: string;
+    initialVariable: number;
+    affines: import("./math/polynomials/affine.js").Affine[];
 }, {}> | Exercise<{
     p: number;
     n: number;