math-exercises 3.0.172 → 3.0.173

package/lib/exercises/math/geometry/lines/readLineNormalVectorOnGraph.js

@@ -0,0 +1,195 @@
+import { addValidProp, shuffleProps, GeneratorOptionType, GeneratorOptionTarget, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { colinearVectorVEA } from "../../../../exercises/vea/colinearVectorVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const vec = VectorConstructor.random("v");
+        const sol = vectorParser(answer);
+        if (!sol)
+            throw new Error("answer malformed in readLineNormalVectorOnGraph");
+        if (vec.isColinear(sol))
+            return;
+        tryToAddWrongProp(propositions, vec.toBinomCoords().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    if (point3Ids) {
+        //perp tracée
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        const vector = VectorConstructor.fromPoints(point2, point3);
+        return vector.simplify().toBinomCoords().toTex();
+    }
+    else {
+        const vector = VectorConstructor.fromPoints(point1, point2);
+        const normal = vector.getOrthogonal();
+        return normal.toBinomCoords().toTex();
+    }
+};
+const getInstruction = (_identifiers, opts) => {
+    if (opts?.withoutPerp) {
+        return `Ci-dessous est tracée une droite $d$.
+        
+Déterminer graphiquement les coordonnées d'un vecteur normal à $d$.`;
+    }
+    return `Ci-dessous sont tracées deux droites perpendiculaires $d$ et $d'$.
+    
+Déterminer graphiquement les coordonnées d'un vecteur normal à $d$.`;
+};
+const getHint = (_identifiers, opts) => {
+    if (opts?.withoutPerp) {
+        const u = new Vector("u", "a".toTree(), "b".toTree());
+        const v = new Vector("v", opposite("b"), "a".toTree());
+        return `Détermine un vecteur directeur de $d$. Puis, utilise la propriété suivante : si $${u.toTexWithBinomCoords()}$ est un vecteur directeur de $d$, alors $${v.toTexWithBinomCoords()}$ est un vecteur normal à $d$.`;
+    }
+    return `Un vecteur normal d'une droite est un vecteur qui est orthogonal à un vecteur directeur de cette droite. 
+  
+Ici, un vecteur normal à $d$ est donc également un vecteur directeur de $d'$.`;
+};
+const getCorrection = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    if (point3Ids) {
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        return `Un vecteur normal à la droite $d$ est un vecteur directeur de la droite $d'$.
+    
+On lit donc graphiquement un vecteur directeur de $d'$.
+
+Cette droite passe par les points de coordonnées $${point2.toCoords()}$ et $${point3.toCoords()}$. Un vecteur directeur de $d'$ est donc : 
+
+$$
+${VectorConstructor.fromPoints(point2, point3).toBinomCoords().toTex()}
+$$
+
+C'est un vecteur normal à $d$.`;
+    }
+    const u = new Vector("u", "a".toTree(), "b".toTree());
+    const v = new Vector("v", opposite("b"), "a".toTree());
+    return `La droite $d$ passe par les points de coordonnées $${point1.toCoords()}$ et $${point2.toCoords()}$. Un vecteur directeur de $d$ est donc :
+  
+$$
+${VectorConstructor.fromPoints(point1, point2).toBinomCoords().toTex()}
+$$
+
+On sait que si $${u.toTexWithBinomCoords()}$ est un vecteur directeur de $d$, alors $${v.toTexWithBinomCoords()}$ est un vecteur normal à $d$.
+
+Ici, les coordonnées d'un vecteur normal à $d$ sont donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { point1Ids, point2Ids, point3Ids } = identifiers;
+    const point1 = PointConstructor.fromIdentifiers(point1Ids);
+    const point2 = PointConstructor.fromIdentifiers(point2Ids);
+    const line = new Line(point1, point2, "d");
+    const ggb = new GeogebraConstructor({
+        commands: line.toGGBCommands(true, {
+            isFixed: true,
+            isSelectionnable: false,
+            showLabel: true,
+            showUnderlyingPoints: false,
+        }),
+    });
+    if (point3Ids) {
+        const point3 = PointConstructor.fromIdentifiers(point3Ids);
+        ggb.commands?.push(`d' = PerpendicularLine(${point2.name}, d)`);
+        ggb.commands?.push(`alpha = Angle(d,d')`);
+        ggb.commands?.push(`ShowLabel(d', true)`);
+        ggb.commands?.push(`ShowLabel(alpha, false)`);
+        return ggb.getOptions({
+            coords: ggb.getCoordsForPoints([point1, point2, point3]),
+        });
+    }
+    else {
+        return ggb.getOptions({
+            coords: ggb.getCoordsForPoints([point1, point2]),
+        });
+    }
+};
+const getKeys = () => {
+    return ["binom", "semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return colinearVectorVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadLineNormalVectorOnGraphQuestion = (opts) => {
+    const point1 = PointConstructor.random("A");
+    const ratio = RationalConstructor.randomIrreductibleWithSign(6);
+    const translation = new Vector("u", ratio.num.toTree(), ratio.denum.toTree());
+    const point2 = translation.getEndPoint(point1);
+    let point3;
+    if (!opts?.withoutPerp) {
+        const vector = VectorConstructor.fromPoints(point1, point2);
+        const normal = vector.getOrthogonal();
+        point3 = normal.getEndPoint(point2);
+    }
+    const identifiers = {
+        point1Ids: point1.toIdentifiers(),
+        point2Ids: point2.toIdentifiers(),
+        point3Ids: point3?.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "withoutPerp",
+        label: "Ne pas tracer de droite perpendiculaire",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+        tooltipText: "S'il n'y a pas de droite perpendiculaire tracée, l'élève devra utiliser le vecteur directeur de la droite puis la propriété qui donne un vecteur normal à partir d'un vecteur directeur.",
+    },
+];
+export const readLineNormalVectorOnGraph = {
+    id: "readLineNormalVectorOnGraph",
+    label: "Déterminer graphiquement les coordonnées d'un vecteur normal à une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadLineNormalVectorOnGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/index.d.ts

@@ -11,4 +11,5 @@ export * from "./randomVariableSituationVariance.js";
 export * from "./randomVariableSituationStandardDeviation.js";
 export * from "./randomVariableSituationIsGameFavorable.js";
 export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./missingValueInRandomVariableProbabilityLaw.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,iDAAiD,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/index.js

@@ -13,3 +13,4 @@ export * from "./randomVariableSituationStandardDeviation.js";
 export * from "./randomVariableSituationIsGameFavorable.js";
 export * from "./randomVariableSituationProbabilityLaw.js";
 // export * from "./decideWhichGameIsLessRisky.js";
+export * from "./missingValueInRandomVariableProbabilityLaw.js";

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    xValues: NodeIdentifiers[];
+    pValues: NodeIdentifiers[];
+};
+export declare const missingValueInRandomVariableProbabilityLaw: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=missingValueInRandomVariableProbabilityLaw.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missingValueInRandomVariableProbabilityLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAgHF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAsB1E,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/missingValueInRandomVariableProbabilityLaw.js

@@ -0,0 +1,119 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { RandomVariable, RandomVariableConstructor, } from "../../../../math/probability/randomVariable.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const getPropositions = (n, { answer }) => {
+    const props = [];
+    addValidProp(props, answer);
+    propWhile(props, n, () => {
+        const numeric = answer.unfrenchify();
+        const offset = randfloat(-0.2, 0.2, 2);
+        const candidate = round(numeric + offset, 2).frenchify();
+        tryToAddWrongProp(props, candidate);
+    });
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ pValues }) => {
+    const probas = pValues
+        .map((e) => reifyAlgebraic(e))
+        .filter((p) => !isVariableNode(p));
+    const sum = operatorComposition(AddNode, probas).simplify();
+    return substract(1, sum).simplify().toTex();
+};
+const getInstruction = ({ pValues, xValues }) => {
+    const va = new RandomVariable(xValues.map((e) => reifyAlgebraic(e)), pValues.map((e) => reifyAlgebraic(e)));
+    return `On considère une variable aléatoire $X$ dont la loi de probabilité est la suivante : 
+  
+${va.getLawMdTable()}
+
+Que vaut $x$ ?`;
+};
+const getHint = () => {
+    return `Dans une loi de probabilité, la somme des probabilités est égale à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pValues, xValues } = identifiers;
+    const probas = pValues.map((e) => reifyAlgebraic(e));
+    const index = probas.findIndex((p) => isVariableNode(p));
+    const xs = xValues.map((e) => reifyAlgebraic(e));
+    const sum = operatorComposition(AddNode, probas.filter((_p, i) => i !== index));
+    return `
+On additionne les probabilités connues :
+
+$$
+${sum.toTex()} = ${sum.simplify().toTex()}
+$$
+
+Puisque la somme des probabilités d'une loi de probabilité vaut $1$, on peut en déduire la probabilité manquante : 
+
+
+$$
+P(X = ${xs[index].toTex()}) = 1 - ${sum.simplify().toTex()} = ${getAnswer(identifiers)}.
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const a = parseAlgebraic(ans);
+        const b = parseAlgebraic(answer);
+        return a.simplify().equals(b.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetMissingProbabilityValueQuestion = () => {
+    const va = RandomVariableConstructor.random();
+    const pValues = [...va.yValues];
+    pValues[randint(0, pValues.length)] = new VariableNode("x");
+    const identifiers = {
+        pValues: pValues.map((e) => e.toIdentifiers()),
+        xValues: va.xValues.map((e) => e.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
+});
+export const missingValueInRandomVariableProbabilityLaw = {
+    id: "missingValueInRandomVariableProbabilityLaw",
+    label: "Déterminer une valeur manquante dans la loi de probabilité d'une variable aléatoire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetMissingProbabilityValueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+export * from "./pySequenceTermForLoopInstructionCompletion.js";
+export * from "./pySequenceTermFromFunctionCallInstructionCompletion.js";
+export * from "./pySequenceFirstTermsListInstructionCompletion.js";
+export * from "./pySequenceFirstTermsSumInstructionCompletion.js";
+export * from "./pySequenceProgramReading.js";
+export * from "./pySequenceFactorialInstructionFalseOneOut.js";
+export * from "./pySequenceThresholdInstructionCompletion.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC;AAChE,cAAc,0DAA0D,CAAC;AACzE,cAAc,oDAAoD,CAAC;AACnE,cAAc,mDAAmD,CAAC;AAClE,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gDAAgD,CAAC;AAC/D,cAAc,+CAA+C,CAAC"}

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

@@ -0,0 +1,7 @@
+export * from "./pySequenceTermForLoopInstructionCompletion.js";
+export * from "./pySequenceTermFromFunctionCallInstructionCompletion.js";
+export * from "./pySequenceFirstTermsListInstructionCompletion.js";
+export * from "./pySequenceFirstTermsSumInstructionCompletion.js";
+export * from "./pySequenceProgramReading.js";
+export * from "./pySequenceFactorialInstructionFalseOneOut.js";
+export * from "./pySequenceThresholdInstructionCompletion.js";

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionIsUsePythonDef } from "../../../../exercises/options/optionIsUsePythonDef.js";
+type Identifiers = {
+    nAsked: number;
+    cyRandModFour?: number;
+    arrRandForStr: number[];
+};
+type Options = OptionIsUsePythonDef;
+export declare const pySequenceFactorialInstructionFalseOneOut: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=pySequenceFactorialInstructionFalseOneOut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pySequenceFactorialInstructionFalseOneOut.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/sequences/pySequenceFactorialInstructionFalseOneOut.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,oBAAoB,EACrB,MAAM,iDAAiD,CAAC;AA2BzD,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA8UF,KAAK,OAAO,GAAG,oBAAoB,CAAC;AAQpC,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAmBR,CAAC"}

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

@@ -0,0 +1,274 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getOptionIsUsePythonDefStuff, } from "../../../../exercises/options/optionIsUsePythonDef.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const _createStrPythonForNode = (nodeUNext) => {
+    return nodeUNext.toMathString().replaceAll("^", "**");
+};
+const uncypherRandModFour = (cyRandModFour) => {
+    return (cyRandModFour - 1) % 4;
+};
+const cypherRandModFour = (randModFour) => {
+    return randModFour + 1;
+};
+const _getStrPythonProgram = (opts) => {
+    const { isUsePythonDef } = opts;
+    if (isUsePythonDef) {
+        return `def factorielle(n):
+  v = 1
+  for i in range(1,n):
+    v = v * i
+  return v
+
+print(factorielle(n))
+`;
+    }
+    else {
+        return `v = 1
+for i in range(1,n):
+  v = v * i
+print(v)
+`;
+    }
+};
+const getStrPythonProgramValid = (identifiers, opts) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        cyRandModFour: undefined,
+    };
+    return getStrPythonProgramInvalid(identifiersTweaked, opts);
+};
+const getStrPythonProgramInvalid = (identifiers, opts) => {
+    const { isUsePythonDef } = opts;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const { strInitialization, strForLoop, strLoopBody, strPrint } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers, opts)).map(([key, miniDict], i) => i === randModFour ? [key, miniDict.invalid] : [key, miniDict.valid]));
+    if (isUsePythonDef) {
+        return `def factorielle(n):
+  ${strInitialization}
+  ${strForLoop}
+    ${strLoopBody}
+  return v
+
+${strPrint}
+`;
+    }
+    else {
+        return `${strInitialization}
+${strForLoop}
+  ${strLoopBody}
+${strPrint}
+`;
+    }
+};
+const getDictStrCompletion = (identifiers, opts) => {
+    const { isUsePythonDef } = opts;
+    const { nAsked, arrRandForStr } = identifiers;
+    const [randStrInitialization, randStrForLoop, randStrLoopBody, randStrPrint] = arrRandForStr;
+    function getStrFromArr(arrStr, rand) {
+        const i = rand % arrStr.length;
+        return arrStr[i];
+    }
+    if (isUsePythonDef) {
+        return {
+            strInitialization: {
+                valid: getStrFromArr(["v = 1"], randStrInitialization),
+                invalid: getStrFromArr([
+                    //inits with 0
+                    "v = 0",
+                    //wrong variable
+                    "x = 1",
+                    "n = 1",
+                ], randStrInitialization),
+            },
+            strForLoop: {
+                valid: getStrFromArr(["for i in range(1,n+1):"], randStrForLoop),
+                invalid: getStrFromArr([
+                    //starts at 0
+                    "for i in range(n+1):",
+                    "for i in range(n):",
+                    "for i in range(n-1):",
+                    //missing :
+                    "for i in range(1,n+1)",
+                    "for i in range(1,n)",
+                    "for i in range(1,n-1)",
+                ], randStrForLoop),
+            },
+            strLoopBody: {
+                valid: getStrFromArr(["v = v * i", "v = i * v"], randStrLoopBody),
+                invalid: getStrFromArr([
+                    //uses n
+                    "n = n * i",
+                    "n = i * n",
+                    "v = i * n",
+                    "v = n * i",
+                    //i -> (i+1)
+                    "v = v * (i+1)",
+                    "v = (i+1) * v",
+                ], randStrLoopBody),
+            },
+            strPrint: {
+                valid: getStrFromArr([`print(factorielle(${nAsked}))`], randStrPrint),
+                invalid: getStrFromArr([
+                    "print(factorielle(n))",
+                    "factorielle(n)",
+                    `print(factorielle(${nAsked - 1}))`,
+                    `factorielle(${nAsked - 1})`,
+                    `factorielle(${nAsked})`,
+                    "print(factorielle)",
+                    `print(factorielle[${nAsked}])`,
+                ], randStrPrint),
+            },
+        };
+    }
+    else {
+        return {
+            strInitialization: {
+                valid: getStrFromArr(["v = 1"], randStrInitialization),
+                invalid: getStrFromArr([
+                    //inits with 0
+                    "v = 0",
+                    //wrong variable
+                    "x = 1",
+                    "n = 1",
+                ], randStrInitialization),
+            },
+            strForLoop: {
+                valid: getStrFromArr([`for i in range(1,${nAsked + 1}):`], randStrForLoop),
+                invalid: getStrFromArr([
+                    //starts at 0
+                    `for i in range(${nAsked + 1}):`,
+                    `for i in range(${nAsked}):`,
+                    `for i in range(${nAsked - 1}):`,
+                    //missing :
+                    `for i in range(1,${nAsked + 1})`,
+                    `for i in range(1,${nAsked})`,
+                    `for i in range(1,${nAsked - 1})`,
+                ], randStrForLoop),
+            },
+            strLoopBody: {
+                valid: getStrFromArr(["v = v * i", "v = i * v"], randStrLoopBody),
+                invalid: getStrFromArr([
+                    //uses n
+                    "n = n * i",
+                    "n = i * n",
+                    "v = i * n",
+                    "v = n * i",
+                    //i -> (i+1)
+                    "v = v * (i+1)",
+                    "v = (i+1) * v",
+                ], randStrLoopBody),
+            },
+            strPrint: {
+                valid: getStrFromArr([`print(v)`], randStrPrint),
+                invalid: getStrFromArr([
+                    "v",
+                    "print(n)",
+                    `print(i)`,
+                    `print(v*${nAsked})`,
+                    `print(v[${nAsked}])`,
+                ], randStrPrint),
+            },
+        };
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { nAsked } = identifiers;
+    return `Quelqu'un a codé ce programme Python dans le but d'afficher la valeur de $${nAsked}!$ (pour $n \\geq 1$, $n!$ ("factorielle $n$") est le produit des entiers compris entre $1$ et $n$ inclus).
+
+${codify(getStrPythonProgramInvalid(identifiers, opts))}
+
+Quelle instruction est erronée dans ce programme ?
+
+`;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const arrEntry = Object.entries(getDictStrCompletion(identifiers, opts));
+    const [_, miniDict] = arrEntry[randModFour];
+    const strInstructionInvalid = miniDict.invalid;
+    return codifyChunk(strInstructionInvalid);
+};
+const getHint = () => {
+    return `Regarde s'il y a des erreurs de syntaxe et s'il n'y en a pas, essaye d'exécuter le programme pour détecter ce qui ne va pas.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return `Voici le programme corrigé : 
+  
+${codify(getStrPythonProgramValid(identifiers, opts))}
+
+`;
+};
+const getPropositions = (_n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { cyRandModFour } = identifiers;
+    const randModFour = cyRandModFour ? uncypherRandModFour(cyRandModFour) : -1;
+    const propositions = [];
+    Object.entries(getDictStrCompletion(identifiers, opts)).forEach(([_, miniDict], i) => {
+        if (i === randModFour) {
+            const strInstruction = miniDict.invalid;
+            addValidProp(propositions, codifyChunk(strInstruction), "raw");
+        }
+        else {
+            const strInstruction = miniDict.valid;
+            tryToAddWrongProp(propositions, codifyChunk(strInstruction), "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = (_opts) => {
+    const cyRandModFour = cypherRandModFour(randint(20, 100));
+    const nAsked = randint(9, 20);
+    const arrRandForStr = [...Array(4).keys()].map(() => randint(10, 50));
+    const identifiers = { cyRandModFour, nAsked, arrRandForStr };
+    return identifiers;
+};
+const getPySequenceFactorialInstructionFalseOneOutQuestion = (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 { optsDefaultIsUsePythonDef, generatorOptionIsUsePythonDef } = getOptionIsUsePythonDefStuff(false);
+const optsDefault = {
+    ...optsDefaultIsUsePythonDef,
+};
+const options = [generatorOptionIsUsePythonDef];
+export const pySequenceFactorialInstructionFalseOneOut = {
+    id: "pySequenceFactorialInstructionFalseOneOut",
+    label: "Déterminer l'instruction fausse dans un algorithme de calcul de factorielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPySequenceFactorialInstructionFalseOneOutQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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