math-exercises 3.0.184 → 3.0.186

package/lib/exercises/math/python/list/pyListSetElemAtIndex.js

@@ -0,0 +1,331 @@
+import { addValidProp, propWhile, 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, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrPythonInstruction = (instruction) => {
+    const { nameList, value } = instruction;
+    switch (instruction.type) {
+        case "append":
+            return `${nameList}.append(${strPythonForListElem(value)})`;
+        case "remove":
+            return `${nameList}.remove(${strPythonForListElem(value)})`;
+        case "inject": {
+            const { index } = instruction;
+            return `${nameList}[${index}] = ${strPythonForListElem(value)}`;
+        }
+    }
+};
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const strPythonForList = (list) => {
+    return `[${list.map((elem) => strPythonForListElem(elem)).join(", ")}]`;
+};
+const strPythonForListElem = (elem) => {
+    if (typeof elem === "string") {
+        if (elem === "None") {
+            return `${elem}`;
+        }
+        else {
+            return `'${elem}'`;
+        }
+    }
+    else {
+        return `${elem}`;
+    }
+};
+const getStrPythonProgram = (identifiers) => {
+    const { nameList, listInitial, arrInstruction } = identifiers;
+    return `${nameList} = ${strPythonForList(listInitial)}
+${arrInstruction.map(getStrPythonInstruction).join(`
+  
+`)}
+print(${nameList})
+`;
+};
+const getFunctionPythonInstruction = (instruction) => {
+    return (l) => {
+        const { nameList, value } = instruction;
+        switch (instruction.type) {
+            case "append":
+                {
+                    const lWork = [...l];
+                    lWork.push(value);
+                    return lWork;
+                }
+                break;
+            case "remove":
+                {
+                    const lWork = [...l];
+                    const indexFound = lWork.findIndex((v) => v === value);
+                    if (indexFound === -1) {
+                        throw new Error(`ValueError: ${nameList}.remove(x): x not in list`);
+                    }
+                    lWork.splice(indexFound, 1);
+                    return lWork;
+                }
+                break;
+            case "inject":
+                {
+                    const { index } = instruction;
+                    if (index < -l.length || l.length <= index) {
+                        throw new Error(`IndexError: list assignment index out of range`);
+                    }
+                    else {
+                        const lWork = [...l];
+                        const indexPositive = index >= 0 ? index : l.length + index;
+                        lWork[indexPositive] = value;
+                        return lWork;
+                    }
+                }
+                break;
+        }
+    };
+};
+const getFunctionForPythonProgram = (identifiers) => {
+    const { nameList, listInitial, arrInstruction } = identifiers;
+    return (..._otherArgs) => {
+        const outDict = {};
+        //init
+        let list = listInitial;
+        outDict[0] = {
+            [nameList]: list,
+        };
+        //main
+        {
+            arrInstruction.forEach((instruction, i) => {
+                let err;
+                try {
+                    list = getFunctionPythonInstruction(instruction)(list);
+                }
+                catch (e) {
+                    err = e;
+                }
+                outDict[i + 1] = {
+                    [nameList]: list,
+                    err,
+                };
+            });
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getInstruction = (identifiers) => {
+    return `Qu'affichera le script en Python suivant ?
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nameList } = identifiers;
+    const stepDictEnd = getFunctionForPythonProgram(identifiers)()[-1];
+    if (stepDictEnd.err) {
+        return `${stepDictEnd.err.message}`;
+    }
+    else {
+        return strPythonForList(stepDictEnd[nameList]);
+    }
+};
+const getHint = (identifiers) => {
+    const { nameList, arrInstruction } = identifiers;
+    const [instructionInject] = arrInstruction;
+    const { index } = instructionInject;
+    return `Pour affecter la valeur $\\text{'toto'}$ à la variable $nom$, on écrit ${codifyChunk("nom = 'toto'")}.
+  
+Ici, on veut affecter une valeur à la variable $${nameList}[${index}]$ (si tant est que cet emplacement mémoire existe).`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, arrInstruction } = identifiers;
+    const dictSteps = getFunctionForPythonProgram(identifiers)();
+    const maxLength = Math.max(...Object.entries(dictSteps).map(([_, { [nameList]: l }]) => l.length));
+    const err = dictSteps[-1].err;
+    if (err === undefined) {
+        return `Voici l'évolution de la liste $${nameList}$ au fil des instructions.  
+    
+  ${mdTable([
+            (() => {
+                const l = dictSteps[0][nameList];
+                return [
+                    "\\text{Initialement}",
+                    ...[...Array(maxLength).keys()].map((i) => l.length > i ? `\\text{${l[i]}}` : "\\text{}"),
+                ];
+            })(),
+            ...arrInstruction.map((instruction, i) => {
+                const l = dictSteps[i + 1][nameList];
+                return [
+                    `\\text{Après ${getStrPythonInstruction(instruction)}}`,
+                    ...[...Array(maxLength).keys()].map((i) => l.length > i ? `\\text{${l[i]}}` : "\\text{}"),
+                ];
+            }),
+        ], true)}
+
+Le programme affichera donc :
+
+${codify(getAnswer(identifiers))}
+
+`;
+    }
+    else {
+        const [instructionInject] = arrInstruction;
+        const { index } = instructionInject;
+        return `Quand l'instruction ${codifyChunk(getStrPythonInstruction(instructionInject))} va être exécutée,
+
+étant donné qu'aucun élément de $${nameList}$ n'existe à l'indice $${index}$
+, l'exécution ne va pas pouvoir s'effectuer correctement.
+
+Un message d'erreur va donc s'afficher.`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, codifyChunk(answer), "raw");
+    const { arrInstruction } = identifiers;
+    const [instructionInject] = arrInstruction;
+    const { index, value } = instructionInject;
+    function createAnswerWrong(funcIndexWrong, funcValueWrong = (v) => v) {
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                if (instruction.type === "inject") {
+                    return {
+                        ...instruction,
+                        index: funcIndexWrong(instruction.index),
+                        value: funcValueWrong(instruction.value),
+                    };
+                }
+                else {
+                    return instruction;
+                }
+            }),
+        };
+        return getAnswer(identifiersWrong);
+    }
+    //indexAsked-1
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index - 1)), "raw");
+    }
+    //indexAsked+1
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index + 1)), "raw");
+    }
+    //student: lst[index]=value -> lst[value]=index
+    if (typeof value === "number") {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong(() => value, () => index)), "raw");
+    }
+    //-indexAsked
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => -index)), "raw");
+    }
+    //append
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                return {
+                    ...instruction,
+                    type: "append",
+                    value: instruction.value,
+                };
+            }),
+        };
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const poolNameList = ["l", "lst", "liste"];
+    const nameList = random(poolNameList);
+    function createRandomListInitial(minLength, maxLength) {
+        const length = randint(minLength, maxLength + 1);
+        const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+        const subPoolNumber = randomMany(poolNumber, Math.max(Math.floor(length * 1.5), length + 2));
+        const listNumber = [...Array(length).keys()].map(() => random(subPoolNumber));
+        const poolLetter = "abcdefghijklmnopqrstuvwxyz".split("");
+        const subPoolLetters = randomMany(poolLetter, Math.max(Math.floor(length * 1.5), length + 2));
+        const listLetters = [...Array(length).keys()].map(() => random(subPoolLetters));
+        const rand = randint(0, 4);
+        switch (rand) {
+            case 0:
+                return listNumber;
+            case 1:
+                return listLetters;
+            case 2: {
+                return [...Array(length).keys()].map(() => {
+                    const word = [...Array(randint(1, 4)).keys()]
+                        .map(() => random(poolLetter))
+                        .join("");
+                    return word;
+                });
+            }
+            case 3:
+                return zip(listNumber, listLetters).map(([n, letter]) => random([n, letter]));
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    }
+    const [valueEx, ...listInitial] = createRandomListInitial(3, 7);
+    const arrInstruction = [
+        (() => {
+            const index = coinFlip()
+                ? randint(0, listInitial.length)
+                : randint(-listInitial.length, 0);
+            const instruction = {
+                type: "inject",
+                nameList,
+                value: valueEx,
+                index,
+            };
+            return instruction;
+        })(),
+    ];
+    const identifiers = { nameList, listInitial, arrInstruction };
+    return identifiers;
+};
+const getPyListSetElemAtIndexQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+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;
+};
+export const pyListSetElemAtIndex = {
+    id: "pyListSetElemAtIndex",
+    label: "Affecter une valeur à un élément dans une liste en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListSetElemAtIndexQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/python/list/pyListSetElemAtIndexInstructionCompletion.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    nameList: string;
+    listInitial: unknown[];
+    listTarget: unknown[];
+};
+export declare const pyListSetElemAtIndexInstructionCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyListSetElemAtIndexInstructionCompletion.d.ts.map

package/lib/exercises/math/python/list/pyListSetElemAtIndexInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyListSetElemAtIndexInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListSetElemAtIndexInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AA6DrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAkYF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAmBzE,CAAC"}

package/lib/exercises/math/python/list/pyListSetElemAtIndexInstructionCompletion.js

@@ -0,0 +1,346 @@
+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 { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrPythonInstruction = (instruction) => {
+    const { nameList, value } = instruction;
+    switch (instruction.type) {
+        case "inject": {
+            const { index } = instruction;
+            return `${nameList}[${index}] = ${strPythonForListElem(value)}`;
+        }
+    }
+};
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const strPythonForList = (list) => {
+    return `[${list.map((elem) => strPythonForListElem(elem)).join(", ")}]`;
+};
+const strPythonForListElem = (elem) => {
+    if (typeof elem === "string") {
+        if (elem === "None") {
+            return `${elem}`;
+        }
+        else {
+            return `'${elem}'`;
+        }
+    }
+    else {
+        return `${elem}`;
+    }
+};
+const getStrPythonProgram = (identifiers) => {
+    const { nameList, listInitial } = identifiers;
+    return `${nameList} = ${strPythonForList(listInitial)}
+...
+print(${nameList})
+`;
+};
+const getInstruction = (identifiers) => {
+    const { listTarget } = identifiers;
+    return `Par quelle(s) instruction(s) peut-on remplacer les pointillés pour que le programme Python ci-dessous affiche ${codifyChunk(strPythonForList(listTarget))} ? 
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getHint = () => {
+    return `Détermine à quel indice dans la liste doit s'opérer la mutation. 
+  
+L'instruction valide doit affecter la bonne valeur au bon indice.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, listInitial, listTarget } = identifiers;
+    const [_valueInitial, valueTarget, indexTarget] = zip(listInitial, listTarget)
+        .map(([v1, v2], i) => [v1, v2, i])
+        .find(([v1, v2]) => v1 !== v2);
+    const instructionInjectAtPositiveIndex = {
+        nameList,
+        type: "inject",
+        value: valueTarget,
+        index: indexTarget,
+    };
+    const instructionInjectAtNegativeIndex = {
+        nameList,
+        type: "inject",
+        value: valueTarget,
+        index: indexTarget - listInitial.length,
+    };
+    return `Voici un tableau récapitulatif :
+  
+${mdTable([
+        ["\\text{Indices}", ...listInitial.map((_, i) => `${i}`)],
+        [
+            "\\text{Avant la mutation}",
+            ...listInitial.map((v) => `\\text{${strPythonForListElem(v)}}`),
+        ],
+        [
+            "\\text{Après la mutation}",
+            ...listTarget.map((v) => `\\text{${strPythonForListElem(v)}}`),
+        ],
+    ], true)}
+
+L'indice où l'on veut affecter la nouvelle valeur (${codifyChunk(strPythonForListElem(valueTarget))}) pour la liste nommée $${nameList}$ est donc $${indexTarget}$.
+
+Les instructions qui conviennent sont :
+
+${codify(getStrPythonInstruction(instructionInjectAtPositiveIndex))}
+
+et 
+
+${codify(getStrPythonInstruction(instructionInjectAtNegativeIndex))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { nameList, listInitial, listTarget } = identifiers;
+    const [valueInitial, valueTarget, indexTarget] = zip(listInitial, listTarget)
+        .map(([v1, v2], i) => [v1, v2, i])
+        .find(([v1, v2]) => v1 !== v2);
+    const instructionInjectAtPositiveIndex = {
+        nameList,
+        type: "inject",
+        value: valueTarget,
+        index: indexTarget,
+    };
+    const instructionInjectAtNegativeIndex = {
+        nameList,
+        type: "inject",
+        value: valueTarget,
+        index: indexTarget - listInitial.length,
+    };
+    //
+    //valid
+    //
+    {
+        const arrInstructionValid = probaLawFlip([
+            [
+                [instructionInjectAtPositiveIndex, instructionInjectAtNegativeIndex],
+                0.5,
+            ],
+            [[instructionInjectAtPositiveIndex], 0.4],
+            [[instructionInjectAtNegativeIndex], 0.1],
+        ]);
+        arrInstructionValid.forEach((instructionValid) => {
+            addValidProp(propositions, codifyChunk(getStrPythonInstruction(instructionValid)), "raw");
+        });
+    }
+    //
+    //invalid
+    //
+    //indexAsked-1
+    {
+        const arrInstructionWrong = [
+            instructionInjectAtPositiveIndex,
+            instructionInjectAtNegativeIndex,
+        ].map((instruction) => {
+            return { ...instruction, index: instruction.index - 1 };
+        });
+        arrInstructionWrong.forEach((instructionWrong) => {
+            tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+        });
+    }
+    //indexAsked+1
+    {
+        const arrInstructionWrong = [
+            instructionInjectAtPositiveIndex,
+            instructionInjectAtNegativeIndex,
+        ].map((instruction) => {
+            return { ...instruction, index: instruction.index + 1 };
+        });
+        arrInstructionWrong.forEach((instructionWrong) => {
+            tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+        });
+    }
+    //student: write initial value
+    {
+        const arrInstructionWrong = [
+            instructionInjectAtPositiveIndex,
+            instructionInjectAtNegativeIndex,
+        ].map((instruction) => {
+            return { ...instruction, value: valueInitial };
+        });
+        arrInstructionWrong.forEach((instructionWrong) => {
+            tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+        });
+    }
+    //easy terror: wrong list name
+    if (coinFlip()) {
+        const poolNameList = ["l", "lst", "liste"];
+        const nameListWrong = random(poolNameList.filter((name) => name !== nameList));
+        //indexAsked
+        {
+            const arrInstructionWrong = [
+                instructionInjectAtPositiveIndex,
+                instructionInjectAtNegativeIndex,
+            ].map((instruction) => {
+                return {
+                    ...instruction,
+                    nameList: nameListWrong,
+                };
+            });
+            arrInstructionWrong.forEach((instructionWrong) => {
+                tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+            });
+        }
+        //indexAsked-1
+        {
+            const arrInstructionWrong = [
+                instructionInjectAtPositiveIndex,
+                instructionInjectAtNegativeIndex,
+            ].map((instruction) => {
+                return {
+                    ...instruction,
+                    index: instruction.index - 1,
+                    nameList: nameListWrong,
+                };
+            });
+            arrInstructionWrong.forEach((instructionWrong) => {
+                tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+            });
+        }
+        //indexAsked+1
+        {
+            const arrInstructionWrong = [
+                instructionInjectAtPositiveIndex,
+                instructionInjectAtNegativeIndex,
+            ].map((instruction) => {
+                return {
+                    ...instruction,
+                    index: instruction.index + 1,
+                    nameList: nameListWrong,
+                };
+            });
+            arrInstructionWrong.forEach((instructionWrong) => {
+                tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+            });
+        }
+        //student: write initial value
+        {
+            const arrInstructionWrong = [
+                instructionInjectAtPositiveIndex,
+                instructionInjectAtNegativeIndex,
+            ].map((instruction) => {
+                return { ...instruction, value: valueInitial, nameList: nameListWrong };
+            });
+            arrInstructionWrong.forEach((instructionWrong) => {
+                tryToAddWrongProp(propositions, codifyChunk(getStrPythonInstruction(instructionWrong)), "raw");
+            });
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const poolNameList = ["l", "lst", "liste"];
+    const nameList = random(poolNameList);
+    function createRandomListInitialNumber(listTarget, index, poolNumber) {
+        const listWork = [...listTarget];
+        const valueTarget = listTarget[index];
+        const valueInitial = random(poolNumber.filter((v) => v != valueTarget));
+        listWork[index] = valueInitial;
+        return listWork;
+    }
+    function createRandomArrList(minLength, maxLength) {
+        const rand = randint(0, 4);
+        const length = randint(minLength, maxLength + 1);
+        const index = randint(0, length);
+        switch (rand) {
+            case 0: {
+                const poolLetter = "abcdefghijklmnopqrstuvwxyz".split("");
+                const poolWords = [
+                    ...["oui", "non"],
+                    ...["vrai", "faux", "math", "live", "test", "cool", "bien"],
+                    ...["raoul", "final", "grand", "train", "suite"],
+                ];
+                const wordTarget = random(poolWords.filter((word) => word.length === length));
+                const listTarget = wordTarget.split("");
+                const listInitial = (() => {
+                    const listWork = [...listTarget];
+                    const letterTarget = listTarget[index];
+                    const letterInitial = random(poolLetter.filter((letter) => letter != letterTarget));
+                    listWork[index] = letterInitial;
+                    return listWork;
+                })();
+                return [listInitial, listTarget];
+            }
+            case 1: {
+                //constant list
+                const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+                const listTarget = (() => {
+                    const value = random(poolNumber);
+                    return [...Array(length).keys()].map(() => value);
+                })();
+                const listInitial = createRandomListInitialNumber(listTarget, index, poolNumber);
+                return [listInitial, listTarget];
+            }
+            case 2: {
+                //arithmetic list
+                const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+                const listTarget = (() => {
+                    const value = random(poolNumber);
+                    const reason = randint(1, 10);
+                    return [...Array(length).keys()].map((i) => value + i * reason);
+                })();
+                const listInitial = createRandomListInitialNumber(listTarget, index, poolNumber);
+                return [listInitial, listTarget];
+            }
+            case 3: {
+                //geometric list
+                const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+                const listTarget = (() => {
+                    const value = random(poolNumber);
+                    const reason = randint(2, 5);
+                    return [...Array(length).keys()].map((i) => value * Math.pow(reason, i));
+                })();
+                const listInitial = createRandomListInitialNumber(listTarget, index, poolNumber);
+                return [listInitial, listTarget];
+            }
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    }
+    const [listInitial, listTarget] = createRandomArrList(3, 5);
+    const identifiers = { nameList, listInitial, listTarget };
+    return identifiers;
+};
+const getPyListSetElemAtIndexInstructionCompletionQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const pyListSetElemAtIndexInstructionCompletion = {
+    id: "pyListSetElemAtIndexInstructionCompletion",
+    label: "Affecter une valeur à un élément dans une liste en Python (compléter le programme)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListSetElemAtIndexInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};