math-exercises 3.0.172 → 3.0.174

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

@@ -0,0 +1,408 @@
+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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNodeFX = (nodeUNext) => {
+    return nodeUNext
+        .toMathString()
+        .replaceAll("u_{n}", "x")
+        .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 getStrPythonProgramComplete = (identifiers, opts) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        keyIncomplete: "",
+    };
+    return getStrPythonProgramIncomplete(identifiersTweaked, opts);
+};
+const getStrPythonProgramIncomplete = (identifiers, opts) => {
+    const { firstValue, keyIncomplete } = identifiers;
+    const { strFXReturn, strForLoop, strUEquals, strTermeUN } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers, opts)).map(([key, str]) => (key === keyIncomplete ? [key, "..."] : [key, str])));
+    return `def f(x):
+  ${strFXReturn}
+
+def terme_u(n):
+  u = ${firstValue}
+  ${strForLoop}
+    ${strUEquals}
+  return u
+
+print(${strTermeUN})
+`;
+};
+const getDictStrCompletion = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { rankAsked, coeffs } = identifiers;
+    const nodeUNext = createNodeUNext(coeffs);
+    return {
+        strFXReturn: `return ${createStrPythonForNodeFX(nodeUNext)}`,
+        strForLoop: `for i in range(${substract("n".toTree(), firstRank)
+            .simplify()
+            .toTex()}):`,
+        strUEquals: `u = f(u)`,
+        strTermeUN: `terme_u(${rankAsked})`,
+    };
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { firstValue, rankAsked, coeffs } = identifiers;
+    const nodeUNext = createNodeUNext(coeffs);
+    return `On considère la suite $(u_{n})$ définie par 
+  
+${alignTex([
+        [`u_{${firstRank}}`, "=", `${firstValue.frenchify()}`],
+        [`u_{n+1}`, "=", `${nodeUNext.toTex()}`],
+    ])}
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant pour calculer $u_{${rankAsked}}$ ?
+
+${codify(getStrPythonProgramIncomplete(identifiers, opts))}
+
+`;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { keyIncomplete } = identifiers;
+    const dictStrCompletion = getDictStrCompletion(identifiers, opts);
+    return codifyChunk(dictStrCompletion[keyIncomplete]);
+};
+const getHint = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strFXReturn":
+            return `La fonction $f$ implémente la formule de récurrence. Attention, l'argument de la fonction $f$ est nommé $x$ et pas $u$.`;
+        case "strForLoop":
+            return `Écris une boucle avec le bon nombre d'itérations`;
+        case "strUEquals":
+            return `Quel est la variable que retourne la fonction ${codifyChunk("terme_u")} ? 
+À chaque itération, on doit lui affecter une nouvelle valeur (celle que l'on crée en utilisant la formule de récurrence).`;
+        case "strTermeUN":
+            return `Utilise un appel de fonction avec le(s) bon(s) paramètre(s).`;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { rankAsked } = identifiers;
+    return `Voici le programme complet pour afficher $u_{${rankAsked}}$
+
+${codify(getStrPythonProgramComplete(identifiers, opts))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const _firstRank = opts.firstTermRankOne ? 1 : 0;
+    const firstRankWrong = opts.firstTermRankOne ? 0 : 1;
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { coeffs, rankAsked, keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strFXReturn":
+            {
+                const nodeUNext = createNodeUNext(coeffs);
+                //student: forgets to add return
+                {
+                    const strWrong = `${createStrPythonForNodeFX(nodeUNext)}`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //students: x -> u
+                {
+                    {
+                        const strWrong = `return ${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "u");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "u");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                }
+                //students: x -> u(n)
+                {
+                    {
+                        const strWrong = `return ${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "u(n)");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "u(n)");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                }
+                //students: x -> terme_u(x)
+                {
+                    {
+                        const strWrong = `return ${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "terme_u(x)");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `${createStrPythonForNodeFX(nodeUNext)}`.replaceAll("x", "terme_u(x)");
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                }
+            }
+            break;
+        case "strForLoop":
+            {
+                //student: firstRankWrong
+                {
+                    const strWrong = `for i in range(${substract("n".toTree(), firstRankWrong)
+                        .simplify()
+                        .toTex()}):`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                {
+                    const strWrong = `for i in range(${add("n".toTree(), 1)
+                        .simplify()
+                        .toTex()}):`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                {
+                    const strWrong = `for i in range(${Math.floor(rankAsked / 10)}):`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: forgets to add :
+                {
+                    {
+                        const strWrong = `for i in range(${substract("n".toTree(), firstRankWrong)
+                            .simplify()
+                            .toTex()})`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `for i in range(${add("n".toTree(), 1)
+                            .simplify()
+                            .toTex()})`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `for i in range(${Math.floor(rankAsked / 10)})`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                }
+            }
+            break;
+        case "strUEquals":
+            {
+                const nodeUNext = createNodeUNext(coeffs);
+                //student: something with i
+                {
+                    const strWrong = `u = f(i)`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: u is a list
+                {
+                    const strWrong = `u[i+1] = f(u[i])`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                // fait une tambouille avec i
+                {
+                    const strProgramChunk = codifyChunk(`u = ${createStrPythonForNodeFX(nodeUNext).replaceAll("x", "i")}`);
+                    tryToAddWrongProp(propositions, strProgramChunk, "raw");
+                }
+                // fait une tambouille avec n
+                {
+                    const strProgramChunk = codifyChunk(`u(n+1) = f(u(n))`);
+                    tryToAddWrongProp(propositions, strProgramChunk, "raw");
+                }
+                //terror: forgets to assign
+                {
+                    const strWrong = random([`f(u)`, `f(i)`, `f(u[i])`, `f(u(n))`]);
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+            }
+            break;
+        case "strTermeUN":
+            {
+                //student: rankAsked - 1
+                {
+                    const strWrong = `terme_u(${rankAsked - 1})`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: rankAsked + 1
+                {
+                    const strWrong = `terme_u(${rankAsked + 1})`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: u_n(rankAsked)
+                {
+                    const strWrong = `u_n(${rankAsked})`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    if (coinFlip()) {
+                        if (coinFlip()) {
+                            const strWrong = `u_n(${rankAsked - 1})`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                        else {
+                            const strWrong = `u_n(${rankAsked + 1})`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                    }
+                }
+                //student: u(rankAsked)
+                {
+                    const strWrong = `u(${rankAsked})`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    if (coinFlip()) {
+                        if (coinFlip()) {
+                            const strWrong = `u(${rankAsked - 1})`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                        else {
+                            const strWrong = `u(${rankAsked + 1})`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                    }
+                }
+                //student: u[rankAsked]
+                {
+                    const strWrong = `u[${rankAsked}]`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    if (coinFlip()) {
+                        if (coinFlip()) {
+                            const strWrong = `u[${rankAsked - 1}]`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                        else {
+                            const strWrong = `u[${rankAsked + 1}]`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                    }
+                }
+                //terror: ...(i)
+                {
+                    const strWrong = random([`terme_u(i)`, `u_n(i)`, `u(i)`, `u[i]`]);
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+            }
+            break;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = (_opts) => {
+    const firstValue = randint(-10, 10);
+    const rankAsked = randint(500, 1001);
+    const coeffs = [];
+    const rand = randint(0, 4);
+    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 keyIncomplete = random([
+        "strFXReturn",
+        "strForLoop",
+        "strUEquals",
+        "strTermeUN",
+    ]);
+    const identifiers = { firstValue, rankAsked, coeffs, keyIncomplete };
+    return identifiers;
+};
+const getPySequenceTermFromFunctionCallInstructionCompletionQuestion = (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 pySequenceTermFromFunctionCallInstructionCompletion = {
+    id: "pySequenceTermFromFunctionCallInstructionCompletion",
+    label: "Compléter un algorithme de calcul de terme à l'aide d'une boucle \"for\" (avec fonction)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceTermFromFunctionCallInstructionCompletionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsUsePythonDef } from "../../../../exercises/options/optionIsUsePythonDef.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    valueThreshold: number;
+    valueLimit: number;
+    nodeIdsDistanceMax: NodeIdentifiers;
+    keyIncomplete: string;
+};
+type Options = OptionFirstTermRankOne & OptionIsUsePythonDef & {
+    isUsePythonList: boolean;
+    typeSequence: string;
+};
+export declare const pySequenceThresholdInstructionCompletion: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pySequenceThresholdInstructionCompletion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pySequenceThresholdInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/pySequenceThresholdInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,oBAAoB,EACrB,MAAM,iDAAiD,CAAC;AAKzD,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,eAAe,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAykBF,KAAK,OAAO,GAAG,sBAAsB,GACnC,oBAAoB,GAAG;IACrB,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAoCJ,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,WAAW,EACX,OAAO,CAkBR,CAAC"}