math-exercises 3.0.171 → 3.0.173

package/lib/exercises/math/python/sequences/pySequenceFactorialInstructionFalseOneOut.js

@@ -0,0 +1,274 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getOptionIsUsePythonDefStuff, } from "../../../../exercises/options/optionIsUsePythonDef.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const _createStrPythonForNode = (nodeUNext) => {
+    return nodeUNext.toMathString().replaceAll("^", "**");
+};
+const uncypherRandModFour = (cyRandModFour) => {
+    return (cyRandModFour - 1) % 4;
+};
+const cypherRandModFour = (randModFour) => {
+    return randModFour + 1;
+};
+const _getStrPythonProgram = (opts) => {
+    const { isUsePythonDef } = opts;
+    if (isUsePythonDef) {
+        return `def factorielle(n):
+  v = 1
+  for i in range(1,n):
+    v = v * i
+  return v
+
+print(factorielle(n))
+`;
+    }
+    else {
+        return `v = 1
+for i in range(1,n):
+  v = v * i
+print(v)
+`;
+    }
+};
+const getStrPythonProgramValid = (identifiers, opts) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        cyRandModFour: undefined,
+    };
+    return getStrPythonProgramInvalid(identifiersTweaked, opts);
+};
+const getStrPythonProgramInvalid = (identifiers, opts) => {
+    const { isUsePythonDef } = opts;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const { strInitialization, strForLoop, strLoopBody, strPrint } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers, opts)).map(([key, miniDict], i) => i === randModFour ? [key, miniDict.invalid] : [key, miniDict.valid]));
+    if (isUsePythonDef) {
+        return `def factorielle(n):
+  ${strInitialization}
+  ${strForLoop}
+    ${strLoopBody}
+  return v
+
+${strPrint}
+`;
+    }
+    else {
+        return `${strInitialization}
+${strForLoop}
+  ${strLoopBody}
+${strPrint}
+`;
+    }
+};
+const getDictStrCompletion = (identifiers, opts) => {
+    const { isUsePythonDef } = opts;
+    const { nAsked, arrRandForStr } = identifiers;
+    const [randStrInitialization, randStrForLoop, randStrLoopBody, randStrPrint] = arrRandForStr;
+    function getStrFromArr(arrStr, rand) {
+        const i = rand % arrStr.length;
+        return arrStr[i];
+    }
+    if (isUsePythonDef) {
+        return {
+            strInitialization: {
+                valid: getStrFromArr(["v = 1"], randStrInitialization),
+                invalid: getStrFromArr([
+                    //inits with 0
+                    "v = 0",
+                    //wrong variable
+                    "x = 1",
+                    "n = 1",
+                ], randStrInitialization),
+            },
+            strForLoop: {
+                valid: getStrFromArr(["for i in range(1,n+1):"], randStrForLoop),
+                invalid: getStrFromArr([
+                    //starts at 0
+                    "for i in range(n+1):",
+                    "for i in range(n):",
+                    "for i in range(n-1):",
+                    //missing :
+                    "for i in range(1,n+1)",
+                    "for i in range(1,n)",
+                    "for i in range(1,n-1)",
+                ], randStrForLoop),
+            },
+            strLoopBody: {
+                valid: getStrFromArr(["v = v * i", "v = i * v"], randStrLoopBody),
+                invalid: getStrFromArr([
+                    //uses n
+                    "n = n * i",
+                    "n = i * n",
+                    "v = i * n",
+                    "v = n * i",
+                    //i -> (i+1)
+                    "v = v * (i+1)",
+                    "v = (i+1) * v",
+                ], randStrLoopBody),
+            },
+            strPrint: {
+                valid: getStrFromArr([`print(factorielle(${nAsked}))`], randStrPrint),
+                invalid: getStrFromArr([
+                    "print(factorielle(n))",
+                    "factorielle(n)",
+                    `print(factorielle(${nAsked - 1}))`,
+                    `factorielle(${nAsked - 1})`,
+                    `factorielle(${nAsked})`,
+                    "print(factorielle)",
+                    `print(factorielle[${nAsked}])`,
+                ], randStrPrint),
+            },
+        };
+    }
+    else {
+        return {
+            strInitialization: {
+                valid: getStrFromArr(["v = 1"], randStrInitialization),
+                invalid: getStrFromArr([
+                    //inits with 0
+                    "v = 0",
+                    //wrong variable
+                    "x = 1",
+                    "n = 1",
+                ], randStrInitialization),
+            },
+            strForLoop: {
+                valid: getStrFromArr([`for i in range(1,${nAsked + 1}):`], randStrForLoop),
+                invalid: getStrFromArr([
+                    //starts at 0
+                    `for i in range(${nAsked + 1}):`,
+                    `for i in range(${nAsked}):`,
+                    `for i in range(${nAsked - 1}):`,
+                    //missing :
+                    `for i in range(1,${nAsked + 1})`,
+                    `for i in range(1,${nAsked})`,
+                    `for i in range(1,${nAsked - 1})`,
+                ], randStrForLoop),
+            },
+            strLoopBody: {
+                valid: getStrFromArr(["v = v * i", "v = i * v"], randStrLoopBody),
+                invalid: getStrFromArr([
+                    //uses n
+                    "n = n * i",
+                    "n = i * n",
+                    "v = i * n",
+                    "v = n * i",
+                    //i -> (i+1)
+                    "v = v * (i+1)",
+                    "v = (i+1) * v",
+                ], randStrLoopBody),
+            },
+            strPrint: {
+                valid: getStrFromArr([`print(v)`], randStrPrint),
+                invalid: getStrFromArr([
+                    "v",
+                    "print(n)",
+                    `print(i)`,
+                    `print(v*${nAsked})`,
+                    `print(v[${nAsked}])`,
+                ], randStrPrint),
+            },
+        };
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { nAsked } = identifiers;
+    return `Quelqu'un a codé ce programme Python dans le but d'afficher la valeur de $${nAsked}!$ (pour $n \\geq 1$, $n!$ ("factorielle $n$") est le produit des entiers compris entre $1$ et $n$ inclus).
+
+${codify(getStrPythonProgramInvalid(identifiers, opts))}
+
+Quelle instruction est erronée dans ce programme ?
+
+`;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const arrEntry = Object.entries(getDictStrCompletion(identifiers, opts));
+    const [_, miniDict] = arrEntry[randModFour];
+    const strInstructionInvalid = miniDict.invalid;
+    return codifyChunk(strInstructionInvalid);
+};
+const getHint = () => {
+    return `Regarde s'il y a des erreurs de syntaxe et s'il n'y en a pas, essaye d'exécuter le programme pour détecter ce qui ne va pas.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return `Voici le programme corrigé : 
+  
+${codify(getStrPythonProgramValid(identifiers, opts))}
+
+`;
+};
+const getPropositions = (_n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const propositions = [];
+    Object.entries(getDictStrCompletion(identifiers, opts)).forEach(([_, miniDict], i) => {
+        if (i === randModFour) {
+            const strInstruction = miniDict.invalid;
+            addValidProp(propositions, codifyChunk(strInstruction), "raw");
+        }
+        else {
+            const strInstruction = miniDict.valid;
+            tryToAddWrongProp(propositions, codifyChunk(strInstruction), "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = (_opts) => {
+    const cyRandModFour = cypherRandModFour(randint(20, 100));
+    const nAsked = randint(9, 20);
+    const arrRandForStr = [...Array(4).keys()].map(() => randint(10, 50));
+    const identifiers = { cyRandModFour, nAsked, arrRandForStr };
+    return identifiers;
+};
+const getPySequenceFactorialInstructionFalseOneOutQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultIsUsePythonDef, generatorOptionIsUsePythonDef } = getOptionIsUsePythonDefStuff(false);
+const optsDefault = {
+    ...optsDefaultIsUsePythonDef,
+};
+const options = [generatorOptionIsUsePythonDef];
+export const pySequenceFactorialInstructionFalseOneOut = {
+    id: "pySequenceFactorialInstructionFalseOneOut",
+    label: "Déterminer l'instruction fausse dans un algorithme de calcul de factorielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceFactorialInstructionFalseOneOutQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/python/sequences/pySequenceFirstTermsListInstructionCompletion.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isUseFuncRecur: boolean;
+};
+type Options = OptionFirstTermRankOne;
+export declare const pySequenceFirstTermsListInstructionCompletion: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pySequenceFirstTermsListInstructionCompletion.d.ts.map

package/lib/exercises/math/python/sequences/pySequenceFirstTermsListInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pySequenceFirstTermsListInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/pySequenceFirstTermsListInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AA2E3D,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAyWF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAClE,WAAW,EACX,OAAO,CAmBR,CAAC"}

package/lib/exercises/math/python/sequences/pySequenceFirstTermsListInstructionCompletion.js

@@ -0,0 +1,368 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom } from "../../../../math/polynomials/trinom.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNodeUNext = (nodeUNext) => {
+    return nodeUNext
+        .toMathString()
+        .replaceAll("u_{n}", "u")
+        .replaceAll("^", "**");
+};
+const createNodeUNext = (coeffs) => {
+    const nodeUn = "u_{n}".toTree();
+    let nodeUNext;
+    const [c, b, a] = coeffs;
+    if (a !== undefined) {
+        //trinom recur
+        const trinom = new Trinom(a, b, c, { variable: nodeUn.toTex() });
+        nodeUNext = trinom.toTree();
+    }
+    else if (b !== undefined) {
+        if (c !== 0) {
+            //arithmetico-geometric (=== affine recur)
+            nodeUNext = add(multiply(b, nodeUn), c);
+        }
+        else {
+            //geometric
+            nodeUNext = multiply(b, nodeUn);
+        }
+    }
+    else {
+        //arithmetic
+        nodeUNext = add(nodeUn, c);
+    }
+    return nodeUNext;
+};
+const createNodeUExplicit = (firstValue, firstRank, coeffs) => {
+    const nodeFactor = firstRank === 0 ? "n".toTree() : substract("n".toTree(), firstRank);
+    const [c, b, a] = coeffs;
+    if (a !== undefined) {
+        return undefined;
+    }
+    else if (b !== undefined) {
+        if (c !== 0) {
+            return undefined;
+        }
+        else {
+            //geometric
+            return multiply(firstValue, power(b, nodeFactor));
+        }
+    }
+    else {
+        //arithmetic
+        return add(firstValue, multiply(c, nodeFactor));
+    }
+};
+const getStrPythonProgramIncomplete = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { firstValue, isUseFuncRecur, coeffs, lengthAsked } = identifiers;
+    if (isUseFuncRecur) {
+        const nodeUNext = createNodeUNext(coeffs);
+        return `def terme_suivant(u):
+  return ${createStrPythonForNodeUNext(nodeUNext)}
+
+def creer_liste(n):
+  u = [${firstValue}]
+  for i in range(n - 1):
+    ...
+
+print(creer_liste(${lengthAsked}))
+`;
+    }
+    else {
+        const nodeUExplicit = createNodeUExplicit(firstValue, firstRank, coeffs);
+        return `def terme_u(n):
+  return ${createStrPythonForNodeUNext(nodeUExplicit)}
+
+def creer_liste(n):
+  u = [${firstValue}]
+  for i in range(n - 1):
+    ...
+
+print(creer_liste(${lengthAsked}))
+`;
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { lengthAsked } = identifiers;
+    return `Le programme suivant sert à créer la liste des $${lengthAsked}$ premiers termes d'une suite $u_{n}$.
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant pour que le programme fonctionne correctement ?
+
+${codify(getStrPythonProgramIncomplete(identifiers, opts))}
+
+`;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { isUseFuncRecur } = identifiers;
+    if (isUseFuncRecur) {
+        return codifyChunk("u.append(terme_suivant(u[i]))");
+    }
+    else {
+        return codifyChunk(`u.append(terme_u(${firstRank + 1}+i))`);
+    }
+};
+const getHint = () => {
+    return `Trouve une instruction qui va : 
+- créer un nouveau terme (en appelant une fonction définie dans le programme)
+- mettre cette valeur en bout de liste
+`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { isUseFuncRecur } = identifiers;
+    if (isUseFuncRecur) {
+        return `La fonction mise à disposition s'appelle ${codifyChunk("terme_suivant")}.
+Elle calcule le terme qui suit le terme ${codifyChunk("u")} passé en argument.
+
+Dans la fonction ${codifyChunk("creer_liste")}, ${codifyChunk("u")} désigne la liste qui est créée progressivement.
+À la première itération (quand ${codifyChunk("i")} vaut $0$), on va utiliser ${codifyChunk("u[0]")}.
+À la deuxième itération (quand ${codifyChunk("i")} vaut $1$), on va utiliser ${codifyChunk("u[1]")}.
+Autrement dit, à l'itération ${codifyChunk("i")}, on va utiliser ${codifyChunk("u[i]")}.
+
+Le nouveau terme sera donc ${codifyChunk("terme_suivant(u[i])")}
+
+Il ne reste plus qu'à l'ajouter à la liste pour que tout s'enchaîne correctement.
+On veut donc écrire
+
+${codify("u.append(terme_suivant(u[i]))")}
+
+`;
+    }
+    else {
+        return `La fonction mise à disposition s'appelle ${codifyChunk("terme_u")}.
+Elle calcule le terme à l'indice ${codifyChunk("n")} passé en argument.
+
+Dans la fonction ${codifyChunk("creer_liste")}, ${codifyChunk("u")} désigne la liste qui est créée progressivement.
+${codifyChunk("u[0]")} est la valeur de $u_{${firstRank}}$.
+Pour créer ${codifyChunk("u[1]")} ($u_{${firstRank + 1}}$), on appelle donc ${codifyChunk(`terme_u(${firstRank + 1})`)}.
+Pour créer ${codifyChunk("u[1+i]")} ($u_{i}$), on appelle donc ${codifyChunk(`terme_u(${firstRank + 1}+i)`)}.
+
+Le nouveau terme sera donc ${codifyChunk(`terme_u(${firstRank + 1}+i)`)}
+
+Il ne reste plus qu'à l'ajouter à la liste pour que tout s'enchaîne correctement.
+On veut donc écrire
+
+${codify(`u.append(terme_u(${firstRank + 1}+i))`)}
+
+`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { isUseFuncRecur } = identifiers;
+    if (isUseFuncRecur) {
+        const _strValid = "u.append(terme_suivant(u[i]))";
+        //student: forgets to append
+        {
+            const strProgramChunk = codifyChunk(`terme_suivant(u[i])`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //student: u.append(...) -> u=...
+        {
+            const strProgramChunk = codifyChunk(`u=terme_suivant(u[i])`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //student: i -> i+1
+        {
+            {
+                const strProgramChunk = codifyChunk(`u.append(terme_suivant(u[i+1]))`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            //student: forgets to append
+            {
+                const strProgramChunk = codifyChunk(`terme_suivant(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            //student: u.append(...) -> u=...
+            {
+                const strProgramChunk = codifyChunk(`u=terme_suivant(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+        //student: magic thinking u[i+1] auto creates itself
+        {
+            {
+                const strProgramChunk = codifyChunk(`u=u[i+1]`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u.append(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u[i+1]`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+        //student: u[i].append(...)
+        {
+            {
+                const strProgramChunk = codifyChunk(`u[i].append(terme_suivant(u[i]))`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u[i].append(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+    }
+    else {
+        const _strValid = `u.append(terme_u(${firstRank + 1}+i))`;
+        //student: forgets to append
+        {
+            const strProgramChunk = codifyChunk(`terme_u(${firstRank + 1}+i)`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //student: u.append(...) -> u=...
+        {
+            const strProgramChunk = codifyChunk(`u=terme_u(${firstRank + 1}+i)`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //student: i -> i-1
+        {
+            {
+                const strProgramChunk = codifyChunk(`u.append(terme_u(${firstRank}+i))`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            //student: forgets to append
+            {
+                const strProgramChunk = codifyChunk(`terme_u(${firstRank}+i)`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            //student: u.append(...) -> u=...
+            {
+                const strProgramChunk = codifyChunk(`u=terme_u(${firstRank}+i)`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+        //student: magic thinking u[i+1] auto creates itself
+        {
+            {
+                const strProgramChunk = codifyChunk(`u=u[i+1]`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u.append(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u[i+1]`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+        //student: u[i].append(...)
+        {
+            {
+                const strProgramChunk = codifyChunk(`u[i].append(terme_u(${firstRank + 1}+i))`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+            {
+                const strProgramChunk = codifyChunk(`u[i].append(u[i+1])`);
+                tryToAddWrongProp(propositions, strProgramChunk, "raw");
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = (_opts) => {
+    const firstValue = randint(-10, 10);
+    const lengthAsked = randint(5, 8);
+    const isUseFuncRecur = coinFlip();
+    const coeffs = [];
+    const rand = isUseFuncRecur ? randint(0, 4) : randint(0, 2);
+    switch (rand) {
+        case 0:
+            {
+                //arithmetic
+                const c = randint(-10, 10, [0]);
+                coeffs.push(c);
+            }
+            break;
+        case 1:
+            {
+                //geometric
+                const c = 0;
+                const b = randfloat(-10, 10, 2, [0]);
+                coeffs.push(...[c, b]);
+            }
+            break;
+        case 2:
+            {
+                //arithmetico-geometric (=== affine recur)
+                const c = randint(-10, 10, [0]);
+                const b = randfloat(-10, 10, 2, [0]);
+                coeffs.push(...[c, b]);
+            }
+            break;
+        case 3:
+            {
+                //trinom recur
+                const c = randint(-10, 10, [0]);
+                const b = randfloat(-10, 10, 2, [0]);
+                const a = randint(-2, 3, [0]);
+                coeffs.push(...[c, b, a]);
+            }
+            break;
+    }
+    const identifiers = { firstValue, lengthAsked, coeffs, isUseFuncRecur };
+    return identifiers;
+};
+const getPySequenceFirstTermsListInstructionCompletionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const pySequenceFirstTermsListInstructionCompletion = {
+    id: "pySequenceFirstTermsListInstructionCompletion",
+    label: "Compléter un algorithme créant la liste des premiers termes d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceFirstTermsListInstructionCompletionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/python/sequences/pySequenceFirstTermsSumInstructionCompletion.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsUsePythonDef } from "../../../../exercises/options/optionIsUsePythonDef.js";
+type Identifiers = {
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isAnswerAlternative: boolean;
+};
+type Options = OptionFirstTermRankOne & OptionIsUsePythonDef;
+export declare const pySequenceFirstTermsSumInstructionCompletion: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pySequenceFirstTermsSumInstructionCompletion.d.ts.map

package/lib/exercises/math/python/sequences/pySequenceFirstTermsSumInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pySequenceFirstTermsSumInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/pySequenceFirstTermsSumInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,oBAAoB,EACrB,MAAM,iDAAiD,CAAC;AAkDzD,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AA4OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,oBAAoB,CAAC;AAe7D,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAmBR,CAAC"}