math-exercises 3.0.171 → 3.0.173

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

@@ -0,0 +1,298 @@
+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 { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNodeUNext = (nodeUNext) => {
+    return nodeUNext
+        .toMathString()
+        .replaceAll("u_{n}", "u")
+        .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 createNodeUExplicit = (firstValue, firstRank, coeffs) => {
+    const nodeFactor = firstRank === 0 ? "n".toTree() : substract("n".toTree(), firstRank);
+    const [c, b, a] = coeffs;
+    if (a !== undefined) {
+        return undefined;
+    }
+    else if (b !== undefined) {
+        if (c !== 0) {
+            return undefined;
+        }
+        else {
+            //geometric
+            return multiply(firstValue, power(b, nodeFactor));
+        }
+    }
+    else {
+        //arithmetic
+        return add(firstValue, multiply(c, nodeFactor));
+    }
+};
+const getStrPythonProgramIncomplete = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { firstValue, rankAsked } = identifiers;
+    return `u = ${firstValue}
+for i in range(${rankAsked - firstRank}):
+  ...
+print(u)
+`;
+};
+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) => {
+    const { coeffs } = identifiers;
+    const nodeUNext = createNodeUNext(coeffs);
+    const strPythonNodeUNext = createStrPythonForNodeUNext(nodeUNext);
+    return codify(`u = ${strPythonNodeUNext}`);
+};
+const getHint = () => {
+    return `Trouve une instruction dont l'exécution réalisera ces $3$ actions : 
+- récupérer la valeur contenue dans $u$
+- calculer une nouvelle valeur en effectuant des opérations avec la valeur récupérée dans $u$ 
+- affecter cette nouvelle valeur à $u$
+`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { firstValue, rankAsked, coeffs } = identifiers;
+    const nodeUNext = createNodeUNext(coeffs);
+    const strPythonNodeUNext = createStrPythonForNodeUNext(nodeUNext);
+    return `Dans le programme proposé, la ligne
+
+${codify(`u = ${firstValue}`)}
+
+traduit l'égalité : 
+
+$$
+u_{${firstRank}} = ${firstValue.frenchify()}
+$$
+
+La variable $u$ est bien initialisée.
+
+$\\ $
+
+Ensuite, pour calculer $u_{${rankAsked}}$, on calcule $u_{${firstRank + 1}}$ à partir de $u_{${firstRank}}$, puis $u_{${firstRank + 2}}$ à partir de $u_{${firstRank + 1}}$, et ainsi de suite de proche en proche.
+
+Le bout de code ${codifyChunk(strPythonNodeUNext)} :
+- récupère la valeur au rang précédent
+- calcule une nouvelle valeur en effectuant des opérations avec la valeur au rang précédent.
+
+$\\ $
+
+Il n'y a plus qu'à mettre à jour $u$ avec cette valeur pour pouvoir répéter la procédure.
+On écrit donc :
+
+${codify(`u = ${strPythonNodeUNext}`)}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    const correctAnswer = answer;
+    addValidProp(propositions, correctAnswer, "raw");
+    const { firstValue, coeffs } = identifiers;
+    const nodeUNext = createNodeUNext(coeffs);
+    const strPythonNodeUNext = createStrPythonForNodeUNext(nodeUNext);
+    // oublie l'assignation
+    {
+        const strProgramChunk = codify(strPythonNodeUNext);
+        tryToAddWrongProp(propositions, strProgramChunk, "raw");
+    }
+    // prend u pour une liste
+    {
+        const strProgramChunk = codify(`u[i+1] = ${strPythonNodeUNext.replaceAll("u", "u[i]")}`);
+        tryToAddWrongProp(propositions, strProgramChunk, "raw");
+    }
+    // fait une tambouille avec i
+    {
+        const strProgramChunk = codify(`u = ${strPythonNodeUNext.replaceAll("u", "i")}`);
+        tryToAddWrongProp(propositions, strProgramChunk, "raw");
+    }
+    // oublie l'assignation + fait une tambouille avec i
+    {
+        const strProgramChunk = codify(`${strPythonNodeUNext.replaceAll("u", "i")}`);
+        tryToAddWrongProp(propositions, strProgramChunk, "raw");
+    }
+    // prend u pour une liste + toujours la même chose
+    {
+        const strProgramChunk = codify(`u[i+1] = ${strPythonNodeUNext}`);
+        tryToAddWrongProp(propositions, strProgramChunk, "raw");
+    }
+    // avec la forme explicite
+    const nodeUExplicit = createNodeUExplicit(firstValue, firstRank, coeffs);
+    if (nodeUExplicit !== undefined) {
+        const strPythonNodeUExplicit = createStrPythonForNodeUNext(nodeUExplicit);
+        //laisse n au lieu de i
+        {
+            const strProgramChunk = codify(`u = ${strPythonNodeUExplicit}`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //NE PAS DECOMMENTER CAR C'EST AUSSI REPONSE VALIDE (discutable)
+        // //utilise la forme explicite
+        // {
+        //   const strProgramChunk = codify(
+        //     `u = ${strPythonNodeUExplicit.replaceAll("n", "i")}`,
+        //   );
+        //   tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        // }
+        //utilise la forme explicite avec u[i+1]
+        {
+            const strProgramChunk = codify(`u[i+1] = ${strPythonNodeUExplicit.replaceAll("n", "i")}`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //oublie l'assignation
+        {
+            const strProgramChunk = codify(`${strPythonNodeUExplicit.replaceAll("n", "i")}`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+        //diabolique: u au lieu de i
+        {
+            const strProgramChunk = codify(`u = ${strPythonNodeUExplicit.replaceAll("n", "u")}`);
+            tryToAddWrongProp(propositions, strProgramChunk, "raw");
+        }
+    }
+    //terror
+    {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        const strWrong = getAnswer(identifiersWrong, opts);
+        tryToAddWrongProp(propositions, strWrong, "raw");
+    }
+    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 identifiers = { firstValue, rankAsked, coeffs };
+    return identifiers;
+};
+const getPySequenceTermForLoopInstructionCompletionQuestion = (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 pySequenceTermForLoopInstructionCompletion = {
+    id: "pySequenceTermForLoopInstructionCompletion",
+    label: "Compléter un algorithme de calcul de terme à l'aide d'une boucle \"for\" (sans fonction)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceTermForLoopInstructionCompletionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    firstValue: number;
+    coeffs: number[];
+    rankAsked: number;
+    keyIncomplete: string;
+};
+type Options = OptionFirstTermRankOne;
+export declare const pySequenceTermFromFunctionCallInstructionCompletion: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pySequenceTermFromFunctionCallInstructionCompletion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pySequenceTermFromFunctionCallInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/pySequenceTermFromFunctionCallInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAqD3D,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAwbF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,mDAAmD,EAAE,QAAQ,CACxE,WAAW,EACX,OAAO,CAoBR,CAAC"}