math-exercises 3.0.184 → 3.0.186

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

@@ -0,0 +1,280 @@
+import { addValidProp, 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 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") {
+        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.indexOf(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) => {
+                list = getFunctionPythonInstruction(instruction)(list);
+                outDict[i + 1] = {
+                    [nameList]: list,
+                };
+            });
+        }
+        //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];
+    return strPythonForList(stepDictEnd[nameList]);
+};
+const getHint = () => {
+    return `En anglais, append signifie ajouter à la fin.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, arrInstruction } = identifiers;
+    const dictSteps = getFunctionForPythonProgram(identifiers)();
+    const maxLength = Math.max(...Object.entries(dictSteps).map(([_, { [nameList]: l }]) => l.length));
+    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))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, codifyChunk(answer), "raw");
+    const { nameList } = identifiers;
+    const stepDictEnd = getFunctionForPythonProgram(identifiers)()[-1];
+    const lFinal = stepDictEnd[nameList];
+    //student: add at start instead of append
+    {
+        const lWrong = [lFinal[lFinal.length - 1], ...lFinal.slice(0, -1)];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: add at start + append
+    {
+        const lWrong = [lFinal[lFinal.length - 1], ...lFinal];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: l.append(v) -> l = [v]
+    {
+        const value = lFinal[lFinal.length - 1];
+        const lWrong = [value];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: concat to last value instead of append to list
+    {
+        const lWrong = [
+            ...lFinal.slice(0, -2),
+            `${lFinal[lFinal.length - 2]}${lFinal[lFinal.length - 1]}`,
+        ];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //student: splits value and appends each char
+    {
+        const value = lFinal[lFinal.length - 1];
+        const lWrong = [
+            ...lFinal.slice(0, -1),
+            ...`${value}`.split("").map((c) => {
+                const n = Number(c);
+                if (n) {
+                    return n;
+                }
+                else {
+                    return c;
+                }
+            }),
+        ];
+        tryToAddWrongProp(propositions, codifyChunk(strPythonForList(lWrong)), "raw");
+    }
+    //terror: display tweaked good answer: remove first value
+    {
+        const lWrong = lFinal.slice(1);
+        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 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 listInitial = createRandomListInitial(2, 5);
+    const arrInstruction = createRandomListInitial(1, 1).map((v) => {
+        const instruction = {
+            type: "append",
+            nameList,
+            value: v,
+        };
+        return instruction;
+    });
+    const identifiers = { nameList, listInitial, arrInstruction };
+    return identifiers;
+};
+const getPyListAppendQuestion = () => {
+    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 pyListAppend = {
+    id: "pyListAppend",
+    label: "Ajouter un élément dans une liste en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListAppendQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    length: number;
+    nodeIdsElemAtIndexI: NodeIdentifiers;
+    rand: number;
+    randFOfI: number;
+};
+export declare const pyListCreateListByComprehension: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyListCreateListByComprehension.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pyListCreateListByComprehension.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListCreateListByComprehension.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwD7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,eAAe,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiPF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAgBjE,CAAC"}

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

@@ -0,0 +1,231 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const strPythonFromMathString = (strMathString) => {
+    return strMathString;
+};
+const createListByComprehension = (nodeElemAtIndexI, length) => {
+    return [...Array(length).keys()].map((i) => {
+        return nodeElemAtIndexI.evaluate({ i });
+    });
+};
+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 strPythonForListByComprehension = (nodeElemAtIndexI, length) => {
+    const strPythonElemAtIndexI = strPythonFromMathString(nodeElemAtIndexI.toMathString());
+    return `[${strPythonElemAtIndexI} for i in range(${length})]`;
+};
+const getStrPythonProgram = (identifiers) => {
+    const { length, nodeIdsElemAtIndexI } = identifiers;
+    const nodeElemAtIndexI = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexI);
+    return `l = ${strPythonForListByComprehension(nodeElemAtIndexI, length)}
+print(l)
+`;
+};
+const getInstruction = (identifiers) => {
+    return `Qu'affichera le script en Python suivant ?
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { length, nodeIdsElemAtIndexI } = identifiers;
+    const nodeElemAtIndexI = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexI);
+    return strPythonForList(createListByComprehension(nodeElemAtIndexI, length));
+};
+const getHint = (identifiers) => {
+    const { length, nodeIdsElemAtIndexI } = identifiers;
+    const nodeElemAtIndexI = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexI);
+    return `La ligne de code 
+  
+${codify(`l = ${strPythonForListByComprehension(nodeElemAtIndexI, length)}`)}
+
+peut se traduire mathématiquement par :
+
+Pour $i$ entier entre $0$ et $${length - 1}$ exclu :
+
+$$
+l_{i} = ${nodeElemAtIndexI.toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { length, nodeIdsElemAtIndexI } = identifiers;
+    const nodeElemAtIndexI = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexI);
+    const strPythonFormulaElemAtIndexI = nodeElemAtIndexI.toMathString();
+    const arrI = [...Array(length).keys()];
+    const arrList = createListByComprehension(nodeElemAtIndexI, length);
+    return `Dans le programme proposé, la liste $l$ est construite par compréhension.
+
+Chaque terme est construit en appliquant la formule ${codifyChunk(strPythonFormulaElemAtIndexI)} pour chaque valeur de $i$.
+
+${mdTable([
+        [nodeElemAtIndexI.toTex(), "i"],
+        ...zip(arrList, arrI).map(([v, i]) => [`${v}`, `${i}`]),
+    ], true)}
+
+Le programme va donc afficher :
+
+${codify(strPythonForList(arrList))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, codifyChunk(answer), "raw");
+    const { length, nodeIdsElemAtIndexI } = identifiers;
+    const nodeElemAtIndexI = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexI);
+    const arrArrList = [];
+    const arrListWrong = createListByComprehension(nodeElemAtIndexI, length);
+    arrArrList.push(arrListWrong);
+    //too few / too many
+    {
+        const lengthWrong = length + (probaFlip(0.7) ? -1 : +1);
+        const arrListWrong = createListByComprehension(nodeElemAtIndexI, lengthWrong);
+        const strWrong = strPythonForList(arrListWrong);
+        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+        arrArrList.push(arrListWrong);
+    }
+    //starts at i=1
+    {
+        const arrListWrong = createListByComprehension(nodeBySubstitutingVar(nodeElemAtIndexI, add("i".toTree(), 1), "i".toTree()), length);
+        const strWrong = strPythonForList(arrListWrong);
+        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+        arrArrList.push(arrListWrong);
+    }
+    //filler
+    {
+        [...Array(2).keys()].forEach(() => {
+            const identifiersWrong = createRandomIdentifiers();
+            const { nodeIdsElemAtIndexI: nodeIdsElemAtIndexIWrong } = identifiersWrong;
+            const nodeElemAtIndexIWrong = NodeConstructor.fromIdentifiers(nodeIdsElemAtIndexIWrong);
+            const lengthWrong = length + randint(-1, 2);
+            const arrListWrong = createListByComprehension(nodeElemAtIndexIWrong, lengthWrong);
+            const strWrong = strPythonForList(arrListWrong);
+            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+            arrArrList.push(arrListWrong);
+        });
+    }
+    //terror: reversed
+    if (coinFlip() || propositions.length < n) {
+        const arrListWrong = random(arrArrList).toReversed();
+        const strWrong = strPythonForList(arrListWrong);
+        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const randFOfI = randint(0, 1);
+    const nodeI = "i".toTree();
+    const nodeFOfI = randFOfI === 0 ? nodeI : add(nodeI, 1);
+    const rand = randint(0, 5);
+    const nodeElemAtIndexI = (() => {
+        switch (rand) {
+            case 0:
+                {
+                    //constant
+                    const c = randint(2, 10);
+                    return c.toTree();
+                }
+                break;
+            case 1:
+                {
+                    //b + f(i)
+                    const b = randint(2, 10);
+                    return add(b.toTree(), nodeFOfI);
+                }
+                break;
+            case 2:
+                {
+                    //a * f(i)
+                    const a = randint(2, 10);
+                    return multiply(a.toTree(), nodeFOfI);
+                }
+                break;
+            case 3:
+                {
+                    //a * f(i) + b
+                    const a = randint(2, 10);
+                    const b = randint(2, 10, [a]);
+                    return add(multiply(a.toTree(), nodeFOfI), b.toTree());
+                }
+                break;
+            case 4:
+                {
+                    //k ** f(i)
+                    const k = random([-2, -1, 2, 3]);
+                    return power(k.toTree(), nodeFOfI);
+                }
+                break;
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const length = randint(4, 8);
+    const identifiers = {
+        length,
+        nodeIdsElemAtIndexI: nodeElemAtIndexI.toIdentifiers(),
+        rand,
+        randFOfI,
+    };
+    return identifiers;
+};
+const getPyListCreateListByComprehensionQuestion = () => {
+    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 pyListCreateListByComprehension = {
+    id: "pyListCreateListByComprehension",
+    label: "Créer une liste par compréhension en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListCreateListByComprehensionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pyListCreateListInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListCreateListInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AA4BrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2QF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAiBvE,CAAC"}