math-exercises 3.0.184 → 3.0.186

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

@@ -0,0 +1,232 @@
+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 { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+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") {
+        return `'${elem}'`;
+    }
+    else {
+        return `${elem}`;
+    }
+};
+const getStrPythonProgramIncomplete = (identifiers) => {
+    const { nameList, indexAsked } = identifiers;
+    return `...
+print(${nameList}[${indexAsked}])
+`;
+};
+const getInstruction = (identifiers) => {
+    const { listInitial, indexAsked } = identifiers;
+    return `Par quelle(s) instruction(s) peut-on remplacer les pointillés pour que le programme Python ci-dessous affiche ${codifyChunk(`${listInitial[indexAsked]}`)} ? 
+
+${codify(getStrPythonProgramIncomplete(identifiers))}
+
+`;
+};
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { nameList, listInitial } = identifiers;
+//   return `${nameList} = ${strPythonForList(listInitial)}`;
+// };
+const createRandomListValid = (identifiers) => {
+    const { listInitial, indexAsked } = identifiers;
+    const elem = listInitial[indexAsked];
+    function createRandomElem() {
+        return randint(-30, 31);
+    }
+    const listLength = randint(indexAsked + 1, listInitial.length);
+    return [...Array(listLength).keys()].map((i) => i === indexAsked ? elem : createRandomElem());
+};
+const createRandomListInvalid = (identifiers) => {
+    const { listInitial, indexAsked } = identifiers;
+    const elem = listInitial[indexAsked];
+    function createRandomElem(excludes) {
+        return randint(-30, 31, excludes);
+    }
+    const indexAskedWrong = random([
+        ...(indexAsked - 1 >= 0 ? [indexAsked - 1] : []),
+        ...(indexAsked + 1 < listInitial.length ? [indexAsked + 1] : []),
+    ]);
+    const listLength = randint(indexAsked + 1, listInitial.length);
+    return [...Array(listLength).keys()].map((i) => i === indexAskedWrong
+        ? elem
+        : i === indexAsked
+            ? createRandomElem([elem])
+            : createRandomElem([]));
+};
+const createRandomValidAnswer = (identifiers) => {
+    const { nameList } = identifiers;
+    const listValid = createRandomListValid(identifiers);
+    return codifyChunk(`${nameList} = ${strPythonForList(listValid)}`);
+};
+const getHint = (identifiers) => {
+    const { nameList } = identifiers;
+    return `Il faut créer une liste, qui sera assignée à la variable $${nameList}$.
+
+Pour créer une liste, il faut mettre entre crochets, les éléments séparés par des virgules.
+
+Il faut aussi que l'élément récupéré corresponde bien à l'indice utilisé.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, listInitial, indexAsked } = identifiers;
+    return `Dans le programme proposé, la dernière ligne est
+
+${codify(`print(${nameList}[${indexAsked}])`)}
+
+Il est donc nécessaire que l'élément à l'indice $${indexAsked}$ soit ${codifyChunk(strPythonForListElem(listInitial[indexAsked]))}.
+
+Il est également nécessaire que le nom de la liste soit $${nameList}$.
+
+Pour créer une liste, il faut mettre entre crochets, les éléments séparés par des virgules.
+
+Les propositions correctes sont toutes celles qui utilisent le nom correct, des crochets et des virgules, et qui ont ${codifyChunk(strPythonForListElem(listInitial[indexAsked]))} à l'indice $${indexAsked}$ :
+
+${codify(`${nameList} = [${[
+        ...listInitial
+            .slice(0, indexAsked + 1)
+            .map((elem, i) => (i === indexAsked ? strPythonForListElem(elem) : "_")),
+        "...",
+    ].join(", ")}]`)}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nameList } = identifiers;
+    const arrStrForTerror = [];
+    //valid
+    const propositionsValid = [];
+    const nbValid = probaLawFlip([
+        [1, 0.45],
+        [2, 0.3],
+        [3, 0.2],
+        [4, 0.05],
+    ]);
+    {
+        propWhile(propositionsValid, nbValid, () => {
+            const strAnswer = createRandomValidAnswer(identifiers);
+            const isAlreadyAdded = propositionsValid
+                .map((proposition) => proposition.statement)
+                .includes(strAnswer);
+            if (!isAlreadyAdded) {
+                addValidProp(propositionsValid, strAnswer, "raw");
+                arrStrForTerror.push(strAnswer);
+            }
+        });
+    }
+    const maxNbMandatory = n - nbValid;
+    const nbMandatory = randint(Math.min(maxNbMandatory, 1), Math.min(maxNbMandatory, 3));
+    //very wrong
+    const propositionsMandatory = [];
+    {
+        //student: no []
+        {
+            const listValid = createRandomListValid(identifiers);
+            const strWrong = codifyChunk(`${nameList} = ${strPythonForList(listValid)
+                .replace("[", "")
+                .replace("]", "")}`);
+            tryToAddWrongProp(propositionsMandatory, strWrong, "raw");
+        }
+        //student: ; instead of ,
+        {
+            const listValid = createRandomListValid(identifiers);
+            const strWrong = codifyChunk(`${nameList} = ${strPythonForList(listValid).replaceAll(",", ";")}`);
+            tryToAddWrongProp(propositionsMandatory, strWrong, "raw");
+            arrStrForTerror.push(strWrong);
+        }
+        //student: no [] + ; instead of ,
+        {
+            const listValid = createRandomListValid(identifiers);
+            const strWrong = codifyChunk(`${nameList} = ${strPythonForList(listValid)
+                .replace("[", "")
+                .replace("]", "")
+                .replaceAll(",", ";")}`);
+            tryToAddWrongProp(propositionsMandatory, strWrong, "raw");
+        }
+    }
+    //filler/terror
+    const propositionsFiller = [];
+    {
+        //student: elem is not at indexAsked
+        {
+            [...Array(3).keys()].forEach(() => {
+                const listInvalid = createRandomListInvalid(identifiers);
+                const strWrong = codifyChunk(`${nameList} = ${strPythonForList(listInvalid)}`);
+                tryToAddWrongProp(propositionsFiller, strWrong, "raw");
+                arrStrForTerror.push(strWrong);
+            });
+        }
+        //terror: wrong list name
+        {
+            const poolNameListWrong = [
+                ...["l", "lst", "liste"].filter((name) => name !== nameList),
+                "list",
+            ];
+            const nameListWrong = random(poolNameListWrong);
+            const arrStrPicked = randomMany(arrStrForTerror, 2);
+            arrStrPicked.forEach((strPicked) => {
+                const strWrong = strPicked.replace(nameList, nameListWrong);
+                tryToAddWrongProp(propositionsFiller, strWrong, "raw");
+            });
+        }
+    }
+    return shuffleProps([
+        ...shuffleProps(propositionsValid, nbValid),
+        ...shuffleProps(propositionsMandatory, nbMandatory),
+        ...shuffleProps(propositionsFiller, n - nbValid - nbMandatory),
+    ], n);
+};
+const createRandomIdentifiers = () => {
+    const poolNameList = ["l", "lst", "liste"];
+    const nameList = random(poolNameList);
+    const listInitial = (() => {
+        const length = randint(4, 7);
+        const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+        const listNumber = randomMany(poolNumber, length);
+        return listNumber;
+    })();
+    const indexAsked = randint(1, listInitial.length - 1);
+    const identifiers = { nameList, listInitial, indexAsked };
+    return identifiers;
+};
+const getPyListCreateListInstructionCompletionQuestion = () => {
+    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 pyListCreateListInstructionCompletion = {
+    id: "pyListCreateListInstructionCompletion",
+    label: "Créer une liste en Python (compléter le programme)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListCreateListInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pyListElemAtIndex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListElemAtIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AA6BrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkUF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

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

@@ -0,0 +1,292 @@
+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 { random, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+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") {
+        return `'${elem}'`;
+    }
+    else {
+        return `${elem}`;
+    }
+};
+const getStrPythonProgram = (identifiers) => {
+    const { nameList, listInitial, indexAsked } = identifiers;
+    return `${nameList} = ${strPythonForList(listInitial)}
+print(${nameList}[${indexAsked}])
+`;
+};
+const getFunctionForPythonProgram = (identifiers) => {
+    const { nameList, listInitial, indexAsked } = identifiers;
+    return (..._otherArgs) => {
+        const outDict = {};
+        //init
+        const list = listInitial;
+        outDict[0] = {
+            [nameList]: list,
+        };
+        //main
+        {
+            if (indexAsked >= 0) {
+                if (indexAsked < list.length) {
+                    outDict[1] = {
+                        [nameList]: list,
+                        elem: list[indexAsked],
+                    };
+                }
+                else {
+                    outDict[1] = {
+                        [nameList]: list,
+                        err: "IndexError: list index out of range",
+                    };
+                }
+            }
+            else {
+                if (indexAsked < -list.length) {
+                    outDict[1] = {
+                        [nameList]: list,
+                        err: "IndexError: list index out of range",
+                    };
+                }
+                else {
+                    outDict[1] = {
+                        [nameList]: list,
+                        elem: list[list.length + indexAsked],
+                    };
+                }
+            }
+        }
+        //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 stepDictEnd = getFunctionForPythonProgram(identifiers)()[-1];
+    return `${stepDictEnd.elem ?? stepDictEnd.err}`;
+};
+const getHint = () => {
+    return `Nommons $n$ la longueur de la liste (autrement dit son nombre d'emplacements).
+
+- Le premier élément est à l'indice $0$.
+- Le dernier élément est à l'indice $n-1$.
+
+On peut aussi récupérer les éléments en partant de la fin :
+
+- Le dernier élément est à l'indice $-1$.
+- Le premier élément est à l'indice $-n$.
+
+Attention à ne pas demander un indice trop grand ou trop petit : cela provoquerait une erreur.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, listInitial, indexAsked } = identifiers;
+    return `Dans le programme proposé, la dernière ligne est
+
+${codify(`print(${nameList}[${indexAsked}])`)}
+
+On veut donc afficher l'élément de $${nameList}$ à l'indice $${indexAsked}$.
+
+La taille de la liste est $${listInitial.length}$.
+
+${(() => {
+        if (indexAsked >= 0) {
+            return mdTable([
+                ["\\text{Indice}", ...listInitial.map((_, i) => `${i}`)],
+                [
+                    "\\text{Valeur}",
+                    ...listInitial.map((v) => `\\text{${strPythonForListElem(v)}}`),
+                ],
+            ], true);
+        }
+        else {
+            return mdTable([
+                [
+                    "\\text{Indice}",
+                    ...listInitial.map((_, i) => `${-listInitial.length + i}`),
+                ],
+                [
+                    "\\text{Valeur}",
+                    ...listInitial.map((v) => `\\text{${strPythonForListElem(v)}}`),
+                ],
+            ], true);
+        }
+    })()}
+
+${(() => {
+        if (indexAsked >= 0) {
+            if (indexAsked < listInitial.length) {
+                return `L'indice demandé est compris entre $0$ et $${listInitial.length - 1}$ inclus.
+      
+Le programme affichera :
+
+${codify(getAnswer(identifiers))}
+
+`;
+            }
+            else {
+                return `L'indice demandé est strictement supérieur à $${listInitial.length - 1}$.
+
+On a dépassé l'indice maximum permis.
+
+Le programme affichera :
+
+${codify(getAnswer(identifiers))}
+
+`;
+            }
+        }
+        else {
+            if (indexAsked < -listInitial.length) {
+                return `L'indice demandé est strictement inférieur à $${-listInitial.length}$.
+
+On a dépassé l'indice mininum permis.
+
+Le programme affichera :
+
+${codify(getAnswer(identifiers))}
+
+`;
+            }
+            else {
+                return `L'indice demandé est compris entre $-1$ et $${-listInitial.length}$ inclus.
+
+On récupère l'élément en partant de la fin.
+
+Le programme affichera :
+
+${codify(getAnswer(identifiers))}
+
+`;
+            }
+        }
+    })()}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, codifyChunk(answer), "raw");
+    const { indexAsked } = identifiers;
+    //indexAsked-1
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            indexAsked: indexAsked - 1,
+        });
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //indexAsked+1
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            indexAsked: indexAsked + 1,
+        });
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //-indexAsked
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            indexAsked: -indexAsked,
+        });
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //error
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            indexAsked: 404,
+        });
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //filler
+    {
+        const { listInitial } = identifiers;
+        propWhile(propositions, n, () => {
+            const identifiersWrong = Object.assign({}, identifiers, {
+                indexAsked: randint(0, listInitial.length),
+            });
+            tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const poolNameList = ["l", "lst", "liste"];
+    const nameList = random(poolNameList);
+    const listInitial = (() => {
+        const length = randint(4, 9);
+        const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+        const listNumber = randomMany(poolNumber, length);
+        const poolLetter = "abcdefghijklmnopqrstuvwxyz".split("");
+        const listLetters = randomMany(poolLetter, length);
+        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(2, 5)).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 indexAsked = randint(-8, 9);
+    const identifiers = { nameList, listInitial, indexAsked };
+    return identifiers;
+};
+const getPyListElemAtIndexQuestion = () => {
+    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 pyListElemAtIndex = {
+    id: "pyListElemAtIndex",
+    label: "Lire un élément dans une liste en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListElemAtIndexQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,29 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Append<T> = {
+    nameList: string;
+    value: T;
+};
+type Remove<T> = {
+    nameList: string;
+    value: T;
+};
+type Inject<T> = {
+    nameList: string;
+    index: number;
+    value: T;
+};
+type Instruction<T> = ({
+    type: "append";
+} & Append<T>) | ({
+    type: "remove";
+} & Remove<T>) | ({
+    type: "inject";
+} & Inject<T>);
+type Identifiers = {
+    nameList: string;
+    listInitial: unknown[];
+    arrInstruction: Instruction<unknown>[];
+};
+export declare const pyListMutationMix: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyListMutationMix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pyListMutationMix.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListMutationMix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AAsbF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}