math-exercises 3.0.184 → 3.0.186

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

@@ -0,0 +1,375 @@
+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 { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.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)})`;
+            }
+            break;
+        case "remove":
+            {
+                return `${nameList}.remove(${strPythonForListElem(value)})`;
+            }
+            break;
+        case "injection":
+            {
+                const { index } = instruction;
+                return `${nameList}[${index}] = ${strPythonForListElem(value)}`;
+            }
+            break;
+    }
+};
+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 "injection":
+                {
+                    const { index } = instruction;
+                    const lWork = [...l];
+                    lWork[index] = 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 = () => {
+    return `En anglais, remove signifie retirer.
+  
+L'instruction retire le premier élément de la liste qui a la valeur donnée en argument.
+Si aucun élément dans la liste n'a la valeur donnée, un message d'erreur s'affiche.`;
+};
+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 instructionRemove = arrInstruction[0];
+        const valueRemoved = instructionRemove.value;
+        return `Quand l'instruction ${codifyChunk(getStrPythonInstruction(instructionRemove))} va être exécutée,
+
+étant donné qu'il n'y a aucun élément de $${nameList}$ qui a la valeur ${codifyChunk(strPythonForListElem(valueRemoved))}, 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 { nameList, listInitial, arrInstruction } = identifiers;
+    const stepDictEnd = getFunctionForPythonProgram(identifiers)()[-1];
+    const lFinal = stepDictEnd[nameList];
+    const [instructionRemove] = arrInstruction;
+    const valueRemoved = instructionRemove.value;
+    //student: remove n elements with n=value
+    if (typeof valueRemoved === "number") {
+        //at end
+        {
+            const lWrong = lFinal.slice(0, -valueRemoved);
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+        }
+        //at start
+        {
+            const lWrong = lFinal.slice(valueRemoved);
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+        }
+    }
+    //student: remove ALL elements that equal value
+    {
+        const lWrong = lFinal.filter((v) => v !== valueRemoved);
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: replace value with null
+    {
+        //replace
+        {
+            const indexFound = listInitial.findIndex((v) => v === valueRemoved);
+            const lWrong = [...listInitial];
+            lWrong[indexFound] = "None";
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+        }
+        //replaceAll
+        {
+            const lWrong = listInitial.map((v) => (v === valueRemoved ? "None" : v));
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+        }
+    }
+    //student: remove, but from right to left
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            listInitial: listInitial.toReversed(),
+        });
+        const stepDictEnd = getFunctionForPythonProgram(identifiersWrong)()[-1];
+        const lWrong = stepDictEnd[nameList].toReversed();
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //error message
+    {
+        const valueAlien = "---";
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                return { ...instruction, value: valueAlien };
+            }),
+        };
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //student: remove other value
+    {
+        const valueOther = random(listInitial.filter((v) => v !== valueRemoved));
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                return { ...instruction, value: valueOther };
+            }),
+        };
+        const stepDictEnd = getFunctionForPythonProgram(identifiersWrong)()[-1];
+        const lWrong = stepDictEnd[nameList];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: append value
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                console.log("instruction", instruction);
+                return {
+                    ...instruction,
+                    type: "append",
+                    value: instruction.value,
+                };
+            }),
+        };
+        const stepDictEnd = getFunctionForPythonProgram(identifiersWrong)()[-1];
+        const lWrong = stepDictEnd[nameList];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //terror: display tweaked good answer: remove first value
+    if (coinFlip()) {
+        const lWrong = lFinal.slice(1);
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        {
+            const lWrong = shuffle(lFinal);
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+        }
+        {
+            const lWrong = shuffle(listInitial);
+            tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "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 value = probaFlip(0.8) ? random(listInitial) : valueEx;
+            const instruction = {
+                type: "remove",
+                nameList,
+                value,
+            };
+            return instruction;
+        })(),
+    ];
+    const identifiers = { nameList, listInitial, arrInstruction };
+    return identifiers;
+};
+const getPyListRemoveQuestion = () => {
+    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 pyListRemove = {
+    id: "pyListRemove",
+    label: "Retirer un élément dans une liste en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListRemoveQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/python/list/pyListSetElemAtIndex.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 pyListSetElemAtIndex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyListSetElemAtIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pyListSetElemAtIndex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListSetElemAtIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AA0IrC,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;AAqSF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}