math-exercises 3.0.171 → 3.0.173

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

@@ -0,0 +1,498 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsUsePythonDefStuff, } from "../../../../exercises/options/optionIsUsePythonDef.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const _getStrPythonProgram = (identifiers, opts) => {
+    const { isUsePythonDef, isUsePythonList, typeSequence } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { valueThreshold, valueLimit, nodeIdsDistanceMax } = identifiers;
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    const strUI = isUsePythonList
+        ? `u[i]`
+        : `terme_u(${firstRank === 1 ? "1 +" : ""}i)`;
+    const strDef = typeSequence === "convergente" ? `def seuil(u, l, d):` : `def seuil(u, v):`;
+    const strPrint = typeSequence === "convergente"
+        ? `print(seuil(u, ${valueLimit}, ${strDistanceMax}))`
+        : `print(seuil(u, ${valueThreshold}))`;
+    if (isUsePythonDef) {
+        const strWhile = typeSequence === "convergente"
+            ? `while abs(${strUI} - ${valueLimit}) < ${strDistanceMax}:`
+            : `while ${strUI} < v:`;
+        return `${strDef}
+  i = 0
+  ${strWhile}
+    i = i + 1
+  return i
+
+${strPrint}
+`;
+    }
+    else {
+        const strWhile = typeSequence === "convergente"
+            ? `while abs(${strUI} - ${valueLimit}) < ${strDistanceMax}:`
+            : `while ${strUI} < ${valueThreshold}:`;
+        return `i = 0
+  ${strWhile}
+    i = i + 1
+print(i)
+`;
+    }
+};
+const getStrPythonProgramComplete = (identifiers, opts) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        keyIncomplete: "",
+    };
+    return getStrPythonProgramIncomplete(identifiersTweaked, opts);
+};
+const getStrPythonProgramIncomplete = (identifiers, opts) => {
+    const { isUsePythonDef, typeSequence } = opts;
+    const { keyIncomplete } = identifiers;
+    const { strInitialization, strWhile, strLoopBody, strPrint } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers, opts)).map(([key, str]) => (key === keyIncomplete ? [key, "..."] : [key, str])));
+    if (isUsePythonDef) {
+        const strDef = typeSequence === "convergente" ? `def seuil(l, d):` : `def seuil(v):`;
+        return `${strDef}
+  ${strInitialization}
+  ${strWhile}
+    ${strLoopBody}
+  return i
+
+${strPrint}
+`;
+    }
+    else {
+        return `${strInitialization}
+${strWhile}
+  ${strLoopBody}
+${strPrint}
+`;
+    }
+};
+const getDictStrCompletion = (identifiers, opts) => {
+    const { isUsePythonDef, isUsePythonList, typeSequence } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { valueThreshold, valueLimit, nodeIdsDistanceMax } = identifiers;
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    const strUI = isUsePythonList
+        ? `u[i]`
+        : `terme_u(${firstRank === 1 ? "1+" : ""}i)`;
+    if (isUsePythonDef) {
+        return {
+            strInitialization: `i = 0`,
+            strWhile: typeSequence === "convergente"
+                ? `while abs(${strUI} - l) > d:`
+                : `while ${strUI} < v:`,
+            strLoopBody: `i = i + 1`,
+            strPrint: typeSequence === "convergente"
+                ? `print(seuil(${valueLimit}, ${strDistanceMax}))`
+                : `print(seuil(${valueThreshold}))`,
+        };
+    }
+    else {
+        return {
+            strInitialization: `i = 0`,
+            strWhile: typeSequence === "convergente"
+                ? `while abs(${strUI} - ${valueLimit}) > ${createStrPythonForNode(nodeDistanceMax)}:`
+                : `while ${strUI} < ${valueThreshold}:`,
+            strLoopBody: `i = i + 1`,
+            strPrint: `print(i)`,
+        };
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { isUsePythonList, typeSequence } = opts;
+    const { valueLimit } = identifiers;
+    return `On considère une suite $(u_{n})$ positive, strictement croissante et ${typeSequence}.
+${typeSequence === "convergente"
+        ? `Sa limite vaut $${valueLimit.frenchify()}$.`
+        : ``}
+
+Dans le programme suivant, on suppose que l'on dispose ${(() => {
+        if (isUsePythonList) {
+            return `d'une liste ${codifyChunk("u")} qui contient les éléments $u_${firstRank}$, $u_${firstRank + 1}$, etc.`;
+        }
+        else {
+            return `d'une fonction ${codifyChunk("terme_u")} telle que ${codifyChunk("terme_u(n)")} retourne $u_{n}$.`;
+        }
+    })()}
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant pour afficher le rang $N$ ${(() => {
+        switch (typeSequence) {
+            case "divergente": {
+                const { valueThreshold } = identifiers;
+                return `à partir duquel la suite dépasse $${valueThreshold.frenchify()}$`;
+            }
+            case "convergente": {
+                const { nodeIdsDistanceMax } = identifiers;
+                const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+                return `à partir duquel l'écart entre la suite et sa limite est strictement inférieur à $${nodeDistanceMax.toTex()}$`;
+            }
+        }
+    })()} ?
+
+${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 "strInitialization":
+            return `Quelle variable faut-il initialiser et avec quelle valeur ?`;
+        case "strWhile":
+            return `Comment écrire une boucle "tant que ..." en Python ?`;
+        case "strLoopBody":
+            return `Qu'est-ce que l'on veut faire croître jusqu'à une certaine valeur dans ce programme ?`;
+        case "strPrint":
+            return `Quel est le résultat que l'on souhaite afficher et comment l'afficher en Python ?`;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return `Voici le programme complet :
+
+${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 { isUsePythonDef, isUsePythonList, typeSequence } = opts;
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { keyIncomplete, valueThreshold, valueLimit, nodeIdsDistanceMax } = identifiers;
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    const strFirstValue = isUsePythonList ? `u[0]` : `terme_u(${firstRank})`;
+    const strUI = isUsePythonList
+        ? `u[i]`
+        : `terme_u(${firstRank === 1 ? "1+" : ""}i)`;
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    switch (keyIncomplete) {
+        case "strInitialization":
+            {
+                //student: i = firstRankWrong
+                {
+                    const strWrong = `i = ${firstRankWrong}`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: i = firstValue
+                {
+                    const strWrong = `i = ${strFirstValue}`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                switch (typeSequence) {
+                    case "divergente":
+                        {
+                            //student: i = valueThreshold
+                            {
+                                const strWrong = `i = ${valueThreshold}`;
+                                tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                            }
+                        }
+                        break;
+                    case "convergente":
+                        {
+                            //student: i = valueLimit
+                            {
+                                const strWrong = `i = ${valueLimit}`;
+                                tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                            }
+                        }
+                        break;
+                }
+                //student: u = 0
+                {
+                    const strWrong = `u = 0`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+                //student: u = firstValue
+                {
+                    const strWrong = `u = ${strFirstValue}`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+            }
+            break;
+        case "strWhile":
+            {
+                switch (typeSequence) {
+                    case "divergente":
+                        {
+                            if (isUsePythonDef) {
+                                //student: wrong ineq symbol
+                                {
+                                    {
+                                        const strWrong = `while ${strUI} >= v:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while ${strUI} > v:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while v <= ${strUI}:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while v < ${strUI} :`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                }
+                            }
+                            else {
+                                //student: wrong ineq symbol
+                                {
+                                    {
+                                        const strWrong = `while ${strUI} >= ${valueThreshold}:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while ${strUI} > ${valueThreshold}:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while ${valueThreshold} <= ${strUI}:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                    {
+                                        const strWrong = `while ${valueThreshold} < ${strUI}:`;
+                                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case "convergente":
+                        {
+                            //student: swaps limit and distance
+                            {
+                                {
+                                    const strWrong = `while abs(${strUI} - d) > l:`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                                {
+                                    const strWrong = `while l < abs(${strUI} - d):`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                            }
+                            //student: wrong inequality symbol
+                            {
+                                {
+                                    const strWrong = `while abs(${strUI} - ${valueLimit}) < ${createStrPythonForNode(nodeDistanceMax)}:`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                                {
+                                    const strWrong = `while ${createStrPythonForNode(nodeDistanceMax)} < abs(${strUI} - ${valueLimit}):`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                            }
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported typeSequence: " + typeSequence);
+                }
+            }
+            break;
+        case "strLoopBody":
+            {
+                //student: focuses on value, not on rank
+                {
+                    {
+                        const strWrong = `u = ${strUI}`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `u = u + ${strUI}`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    {
+                        const strWrong = `i = ${strUI}`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                }
+                //student: forgets to assign
+                {
+                    const strWrong = `i+1`;
+                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                }
+            }
+            break;
+        case "strPrint":
+            {
+                if (isUsePythonDef) {
+                    //student: no-args call
+                    {
+                        const strWrong = `print(seuil())`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    //student: no function call
+                    {
+                        const strWrong = `print(${valueThreshold})`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    //student: i
+                    {
+                        const strWrong = `print(i)`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    switch (typeSequence) {
+                        case "divergente":
+                            break;
+                        case "convergente":
+                            {
+                                //student: swaps args
+                                {
+                                    const strWrong = `print(seuil(${strDistanceMax}, ${valueLimit}))`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                                //student: missing arg
+                                {
+                                    const strWrong = `print(seuil(${valueLimit}))`;
+                                    tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                                }
+                            }
+                            break;
+                        default:
+                            throw new Error("Unsupported typeSequence: " + typeSequence);
+                    }
+                }
+                else {
+                    //student: value instead of rank
+                    {
+                        const strWrong = `print(${strUI})`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    //student: value instead of rank
+                    {
+                        const strWrong = `print(u)`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    //student: offset
+                    {
+                        const strWrong = `print(i-1)`;
+                        tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                    }
+                    //student: forgets to call print
+                    {
+                        {
+                            const strWrong = `i`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                        {
+                            const strWrong = `${strUI}`;
+                            tryToAddWrongProp(propositions, codifyChunk(strWrong), "raw");
+                        }
+                    }
+                }
+            }
+            break;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = (_opts) => {
+    const valueThreshold = randfloat(100, 200, 1);
+    const valueLimit = randfloat(0, 200, 1, [0]);
+    const nodeDistanceMax = power(10, randint(-8, -1));
+    const keyIncomplete = random([
+        "strInitialization",
+        "strWhile",
+        "strLoopBody",
+        "strPrint",
+    ]);
+    const identifiers = {
+        valueThreshold,
+        valueLimit,
+        nodeIdsDistanceMax: nodeDistanceMax.toIdentifiers(),
+        keyIncomplete,
+    };
+    return identifiers;
+};
+const getPySequenceThresholdInstructionCompletionQuestion = (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 { optsDefaultIsUsePythonDef, generatorOptionIsUsePythonDef } = getOptionIsUsePythonDefStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, optsDefaultIsUsePythonDef, {
+    isUsePythonList: false,
+}, {
+    typeSequence: "divergente",
+});
+const options = [
+    generatorOptionFirstTermRankOne,
+    generatorOptionIsUsePythonDef,
+    {
+        id: "isUsePythonList",
+        label: "Utiliser une liste python",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isUsePythonList,
+    },
+    {
+        id: "typeSequence",
+        label: "Type de suite",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["divergente", "convergente"],
+        defaultValue: optsDefault.typeSequence,
+    },
+];
+export const pySequenceThresholdInstructionCompletion = {
+    id: "pySequenceThresholdInstructionCompletion",
+    label: "Compléter un algorithme de calcul de seuil",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceThresholdInstructionCompletionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFromTwoTerms.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+};
+type Options = OptionFirstTermRankOne;
+export declare const arithmeticFindExplicitFormulaFromTwoTerms: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindExplicitFormulaFromTwoTerms.d.ts.map

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFromTwoTerms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindExplicitFormulaFromTwoTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFromTwoTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAiB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwOF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}