math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/probaStat/tchebychev/tchebychevMinorizeProbaOfXInCenteredInterval.js

@@ -0,0 +1,155 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsA } = identifiers;
+    const [nodeE, nodeV, nodeA] = [nodeIdsE, nodeIdsV, nodeIdsA].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("X");
+    const nodeBoundLow = substract(nodeE, nodeA).simplify();
+    const nodeBoundHigh = add(nodeE, nodeA).simplify();
+    const texPWithinBounds = `P( ${nodeBoundLow.toTex()} < ${nodeVarX.toTex()} < ${nodeBoundHigh.toTex()} )`;
+    const nodeErrorMin = frac(nodeV, square(nodeA));
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        texPWithinBounds,
+        nodeErrorMin,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPWithinBounds } = getHydrated(identifiers);
+    return `Soit $X$ une variable aléatoire d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. 
+À l'aide du théorème de Bienaymé-Tchebychev, donner une minoration de $${texPWithinBounds}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeErrorMin } = getHydrated(identifiers);
+    return nodeErrorMin.simplify().toTex();
+};
+const getHint = () => {
+    const nodeE = new VariableNode("E(Y)");
+    const nodeV = new VariableNode("V(Y)");
+    const nodeA = new VariableNode("a");
+    const nodeVarY = new VariableNode("Y");
+    const nodeBoundLow = substract(nodeE, nodeA);
+    const nodeBoundHigh = add(nodeE, nodeA);
+    const texPWithinBounds = `P( ${nodeBoundLow.toTex()} < ${nodeVarY.toTex()} < ${nodeBoundHigh.toTex()} )`;
+    const nodeLhs = abs(substract(nodeVarY, nodeE).simplify());
+    const texPOutside = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const texPInside = `P( ${nodeLhs.toTex()} < ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, square(nodeA));
+    return `Soit $Y$ une variable aléatoire. Soit $a$ un réel strictement positif.
+
+D'après le théorème de Bienaymé-Tchebychev :
+
+${alignTex([
+        [texPOutside, "\\leq", nodeErrorMax.toTex()],
+        [`1 - ${texPOutside}`, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+        [texPInside, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+        [texPWithinBounds, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+    ])}
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeA, nodeE, texPWithinBounds, nodeErrorMin } = getHydrated(identifiers);
+    const nodeVarX = new VariableNode("X");
+    const nodeLhs = abs(substract(nodeVarX, nodeE).simplify());
+    const texPInside = `P( ${nodeLhs.toTex()} < ${nodeA.toTex()} )`;
+    return `D'après le théorème de Bienaymé-Tchebychev :
+
+${alignTex([
+        [
+            `P( \\lvert X - E(X) \\rvert \\geq ${nodeA.toTex()})`,
+            `\\leq`,
+            `\\frac{V(X)}{${square(nodeA).toTex()}}`,
+        ],
+        [
+            `1 - P( \\lvert X - E(X) \\rvert \\geq ${nodeA.toTex()})`,
+            `\\geq`,
+            `1 - \\frac{V(X)}{${square(nodeA).toTex()}}`,
+        ],
+        [texPInside, `\\geq`, nodeErrorMin.toTex()],
+        [texPWithinBounds, `\\geq`, nodeErrorMin.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodeA = randint(2, Math.ceil(3 * nodeV.evaluate())).toTree();
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsA: nodeA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevMinorizeProbaOfXInCenteredIntervalQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+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),
+    };
+};
+export const tchebychevMinorizeProbaOfXInCenteredInterval = {
+    id: "tchebychevMinorizeProbaOfXInCenteredInterval",
+    label: "Utiliser le théorème de Bienaymé Tchebychev pour donner une minoration de la probabilité de tomber dans un intervalle centré sur l'espérance",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevMinorizeProbaOfXInCenteredIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.d.ts

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

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTreeBernoulli.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/buildTreeBernoulli.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA4HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.js

@@ -0,0 +1,124 @@
+import { treeTableVEA } from "../../../../exercises/vea/treeTableVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { n, nodeIdsProba } = identifiers;
+    const nodeProba = NodeConstructor.fromIdentifiers(nodeIdsProba);
+    return {
+        n,
+        nodeProba,
+    };
+};
+const getAnswerTreeTable = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    const arrBranch = [
+        [`${nodeProba.toTex()}`, "S"],
+        [`${substract(1, nodeProba).simplify().toTex()}`, "\\overline{S}"],
+    ];
+    return [
+        [arrBranch],
+        [arrBranch, arrBranch],
+        [arrBranch, arrBranch, arrBranch, arrBranch],
+    ].slice(0, n);
+};
+const getInstruction = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    return `Donner l'arbre qui représente un schéma de Bernoulli de paramètres $${n.frenchify()}$ et $${nodeProba.toTex()}$.`;
+};
+const getHint = () => {
+    return `Dans une épreuve de Bernoulli, les probabilités des $2$ seules issues possibles (succès $S$ et échec $\\overline{S}$) sont respectivement $p$ et $1-p$.
+
+Un schéma de Bernoulli de paramètres $n$ et $p$ est la répétitions de $n$ épreuves de Bernoulli identiques et indépendantes (toutes ayant la même probabilité de succès $p$).
+
+Commence donc par réprésenter les branches correspondant à la première épreuve, puis celles de la deuxième à partir des branches de la première, etc.`;
+};
+const getCorrection = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    return `Puisque c'est la même épreuve que l'on réalise $${n.frenchify()}$ fois, l'arbre va comporter un motif qui va se répéter.
+
+Ce motif est constitué des $2$ branches correspondant l'épreuve de Bernoulli : 
+  
+- la branche de l'issue succès $S$ avec une probabilité de $${nodeProba.toTex()}$
+- la branche de l'issue échec $\\overline{S}$ avec une probabilité de $${substract(1, nodeProba)
+        .simplify()
+        .toTex()}$
+
+On inscrit ce motif $1$ fois pour la première épreuve, 
+$2$ fois pour la deuxième épreuve (car la première épreuve a $2$ issues), 
+$4$ fois pour la troisième épreuve (car la séquence "première épreuve puis deuxième épreuve" a $4$ issues), ..., $2^{k-1}$ fois pour la $k$-ième épreuve.`;
+};
+const getKeys = (_identifiers) => {
+    return ["S", "overlineS"];
+};
+const isAnswerTreeTableValid = (ans, { answerTreeTable }) => {
+    try {
+        return treeTableVEA(ans, answerTreeTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getBuildTreeBernoulliQuestion = () => {
+    const n = coinFlip() ? 2 : 3;
+    const nodeProba = randfloat(0.2, 0.8, 1).toTree();
+    const identifiers = {
+        n,
+        nodeIdsProba: nodeProba.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { n } = identifiers;
+    return {
+        answerTreeTable: getAnswerTreeTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTreeTable: (() => {
+            const arrBranch = [
+                ["", ""],
+                ["", ""],
+            ];
+            switch (n) {
+                case 2: {
+                    return [[arrBranch], [arrBranch, arrBranch]];
+                }
+                case 3: {
+                    return [
+                        [arrBranch],
+                        [arrBranch, arrBranch],
+                        [arrBranch, arrBranch, arrBranch, arrBranch],
+                    ];
+                }
+                default: {
+                    throw new Error("Unsupported n: " + n);
+                }
+            }
+        })(),
+    };
+};
+export const buildTreeBernoulli = {
+    id: "buildTreeBernoulli",
+    label: "Donner l'arbre qui permet de représenter un schéma de Bernoulli de paramètres $n$ et $p$ (decontextualisé)",
+    isSingleStep: true,
+    generator: (nb, opts) => 
+    // getDistinctQuestions(() => getBuildTreeBernoulliQuestion(opts), nb),
+    [...Array(nb).keys()].map(() => getBuildTreeBernoulliQuestion(opts)),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTreeTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTreeTable,
+    getQuestionFromIdentifiers,
+    answerType: "treeDiagram",
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,5 @@ export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProba
 export * from "./fillProbaTreeWithComplementaryProbabilities.js";
 export * from "./buildTreeFromSituation.js";
 export * from "./probaTreeSituationTotalProbaFormula.js";
+export * from "./buildTreeBernoulli.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,sBAAsB,CAAC;AAC9B,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,sBAAsB,CAAC;AAC9B,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC;AACzD,cAAc,yBAAyB,CAAC"}

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

@@ -2,3 +2,4 @@ export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProba
 export * from "./fillProbaTreeWithComplementaryProbabilities.js";
 export * from "./buildTreeFromSituation.js";
 export * from "./probaTreeSituationTotalProbaFormula.js";
+export * from "./buildTreeBernoulli.js";

package/lib/exercises/math/sequences/geometric/graph/index.d.ts

@@ -2,4 +2,8 @@ export * from "./recognizeGeometricFromGraph.js";
 export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
 export * from "./readGeometricExpressionFromGraph.js";
 export * from "./compareGeometricReasonWithOneFromGraph.js";
+export * from "./geometricPlaceFirstPoints.js";
+export * from "./geometricSignOfReasonFromGraph.js";
+export * from "./geometricFindThresholdFromGraph.js";
+export * from "./geometricFindThresholdUsingCalculator.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,oDAAoD,CAAC;AACnE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,oDAAoD,CAAC;AACnE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/index.js

@@ -2,3 +2,7 @@ export * from "./recognizeGeometricFromGraph.js";
 export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
 export * from "./readGeometricExpressionFromGraph.js";
 export * from "./compareGeometricReasonWithOneFromGraph.js";
+export * from "./geometricPlaceFirstPoints.js";
+export * from "./geometricSignOfReasonFromGraph.js";
+export * from "./geometricFindThresholdFromGraph.js";
+export * from "./geometricFindThresholdUsingCalculator.js";

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

@@ -1,6 +1,7 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
 export * from "./geometricFindExplicitFormulaFirstRankOne.js";
+export * from "./geometricFindRecurrenceFormula.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
@@ -15,5 +16,6 @@ export * from "./situations/index.js";
 export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
 export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
+export * from "./geometricFindNextTermFromTwoConsecutiveTerms.js";
 export * from "./graph/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,0BAA0B,CAAC;AAEzC,cAAc,0CAA0C,CAAC;AAEzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AAEtC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,qDAAqD,CAAC;AACpE,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,qCAAqC,CAAC;AAEpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,0BAA0B,CAAC;AAEzC,cAAc,0CAA0C,CAAC;AAEzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AAEtC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,qDAAqD,CAAC;AACpE,cAAc,mDAAmD,CAAC;AAElE,cAAc,kBAAkB,CAAC"}

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

@@ -1,6 +1,7 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
 export * from "./geometricFindExplicitFormulaFirstRankOne.js";
+export * from "./geometricFindRecurrenceFormula.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
@@ -15,4 +16,5 @@ export * from "./situations/index.js";
 export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
 export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
+export * from "./geometricFindNextTermFromTwoConsecutiveTerms.js";
 export * from "./graph/index.js";

package/lib/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAGzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0JF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzE,CAAC"}
+{"version":3,"file":"geometricFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAGzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuNF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzE,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.js

@@ -10,65 +10,46 @@ const situations = situationsGeometric;
 const getInstruction = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
-    const { situationIndex, initial, reason, superfluousData } = identifiers;
+    const { situationIndex, initial, reason, superfluousData, valueAsked } = identifiers;
     const situation = situations[situationIndex];
     return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
 
-situation.variationFindRank.getStrQuestion!(
-  initial,
-  reason,
-  firstRank,
-  valueAsked,
-)`;
+${situation.variationFindRank.getStrQuestion(initial, reason, firstRank, valueAsked)}`;
 };
-const getAnswerNode = (_identifiers, _opts) => {
-    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
-    // const { situationIndex, initial, reason, valueAsked } = identifiers;
-    // const situation = situations[situationIndex];
-    // return situation.variationFindRank.getAnswerNode(
-    //   initial,
-    //   reason,
-    //   firstRank,
-    //   valueAsked,
-    // );
-    return (0).toTree();
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, valueAsked } = identifiers;
+    const situation = situations[situationIndex];
+    const { rankDecoder, digitsValue, digitsTarget } = situation;
+    return situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, rankDecoder, digitsValue, digitsTarget).answerNode;
 };
 const getAnswer = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;
     return getAnswerNode(identifiers, opts).simplify().toTex();
 };
-const getHint = (_identifiers, _optsIn) => {
-    // const opts = optsIn ?? optsDefault;
-    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
-    // const { situationIndex, valueAsked } = identifiers;
-    // const situation = situations[situationIndex];
-    // return situation.variationFindRank.getHint(firstRank, valueAsked);
-    return "hint";
+const getHint = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, valueAsked } = identifiers;
+    const situation = situations[situationIndex];
+    const { rankDecoder, digitsValue, digitsTarget } = situation;
+    return situation.variationFindRank.getHint(firstRank, valueAsked, rankDecoder, digitsValue, digitsTarget);
 };
-const getCorrection = (_identifiers, _optsIn) => {
-    // const opts = optsIn ?? optsDefault;
-    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
-    // const { situationIndex, initial, reason, valueAsked } = identifiers;
-    // const situation = situations[situationIndex];
-    // return situation.variationFindRank.getCorrectionStuff(
-    //   initial,
-    //   reason,
-    //   firstRank,
-    //   valueAsked,
-    // ).str as string;
-    return "correction";
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, valueAsked } = identifiers;
+    const situation = situations[situationIndex];
+    const { rankDecoder, digitsValue, digitsTarget } = situation;
+    return situation.variationFindRank.getCorrectionStuff(initial, reason, firstRank, valueAsked, rankDecoder, digitsValue, digitsTarget).str;
 };
-const getPropositions = (n, { answer, ..._identifiers }, _optsIn) => {
-    // const opts = optsIn ?? optsDefault;
-    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
-    // const { situationIndex, initial, reason, valueAsked } = identifiers;
-    // const situation = situations[situationIndex];
+const getPropositions = (n, { answer }, _optsIn) => {
     const propositions = [];
     addValidProp(propositions, answer);
     //filler
     {
         propWhile(propositions, n, () => {
-            tryToAddWrongProp(propositions, randint(1, 25).frenchify());
+            tryToAddWrongProp(propositions, randint(3, 16).frenchify());
         });
     }
     return shuffleProps(propositions, n);
@@ -81,10 +62,9 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
-const getGeometricFindRankFromSituationQuestion = (optsIn) => {
-    const opts = optsIn ?? optsDefault;
+const createRandomIdentifiers = (opts) => {
     const { isWithSuperfluousData } = opts;
-    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
     const situationIndex = randint(0, situations.length);
     const situation = situations[situationIndex];
     const initial = situation.randInitial();
@@ -92,9 +72,10 @@ const getGeometricFindRankFromSituationQuestion = (optsIn) => {
     const superfluousData = isWithSuperfluousData
         ? situation.randSuperfluousData()
         : undefined;
+    const { rankDecoder, digitsValue, digitsTarget } = situation;
     const rankAsked = randint(4, 15);
     const valueAsked = situation.variationFindRandomTerm
-        .getAnswerNode(initial, reason, firstRank, rankAsked)
+        .getAnswerNode(initial, reason, firstRank, rankAsked, rankDecoder, digitsValue, digitsTarget)
         .evaluate();
     const identifiers = {
         situationIndex,
@@ -103,6 +84,48 @@ const getGeometricFindRankFromSituationQuestion = (optsIn) => {
         superfluousData,
         valueAsked,
     };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+        }
+        catch (e) {
+            console.log("e", e);
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(opts);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            situationIndex: 0,
+            initial: 3600,
+            reason: 1.0213,
+            valueAsked: 4172.3,
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getGeometricFindRankFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createQCPassedIdentifiers(opts);
     return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
@@ -128,7 +151,7 @@ const options = [
 export const geometricFindRankFromSituation = {
     id: "geometricFindRankFromSituation",
     connector: "=",
-    label: "À partir d'une situation décrivant une évolution géométrique, retrouver le rang d'une valeur donnée",
+    label: "À partir d'une situation décrivant une évolution géométrique, retrouver le rang d'une valeur donnée, en utilisant la calculatrice",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRankFromSituationQuestion(opts), nb),
     options,

package/lib/exercises/math/sequences/geometric/situations/index.d.ts

@@ -1,4 +1,5 @@
+export * from "./geometricFindExplicitFormulaFromSituation.js";
 export * from "./geometricFindRecurrenceFormulaFromSituation.js";
 export * from "./geometricFindTermFromSituation.js";
-export * from "./geometricFindExplicitFormulaFromSituation.js";
+export * from "./geometricFindRankFromSituation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/situations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC;AAGpD,cAAc,gDAAgD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/index.js

@@ -1,5 +1,5 @@
+export * from "./geometricFindExplicitFormulaFromSituation.js";
 export * from "./geometricFindRecurrenceFormulaFromSituation.js";
 export * from "./geometricFindTermFromSituation.js";
-// export * from "./geometricFindRankFromSituation.js";
+export * from "./geometricFindRankFromSituation.js";
 // export * from "./geometricFindThresholdFromSituation.js";
-export * from "./geometricFindExplicitFormulaFromSituation.js";

package/lib/exercises/math/sets/index.d.ts

@@ -3,4 +3,7 @@ export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
 export * from "./isNumberDecimal.js";
+export * from "./cartesianProduct/index.js";
+export * from "./partialPermutations/index.js";
+export * from "./combinations/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/sets/index.js

@@ -3,3 +3,6 @@ export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
 export * from "./isNumberDecimal.js";
+export * from "./cartesianProduct/index.js";
+export * from "./partialPermutations/index.js";
+export * from "./combinations/index.js";

package/lib/exercises/math/spaceGeometry/basis/index.d.ts

@@ -1,3 +1,9 @@
 export * from "./spaceCoordinatesInPrism.js";
 export * from "./findSpacePointOnRectangularPrism.js";
+export * from "./spaceCoordinatesOfPointInCubeCoordSystem.js";
+export * from "./spaceCoordinatesOfVectorInCubeCoordSystem.js";
+export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
+export * from "./spaceVectorLinearCombinationFromCoords.js";
+export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
+export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AACzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/index.js

@@ -1,2 +1,8 @@
 export * from "./spaceCoordinatesInPrism.js";
 export * from "./findSpacePointOnRectangularPrism.js";
+export * from "./spaceCoordinatesOfPointInCubeCoordSystem.js";
+export * from "./spaceCoordinatesOfVectorInCubeCoordSystem.js";
+export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
+export * from "./spaceVectorLinearCombinationFromCoords.js";
+export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
+export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";

package/lib/exercises/math/spaceGeometry/basis/lineLineRelativePositionsFromCubeOuterPoints.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    spacePointIdsCubeOrigin: SpacePointIdentifiers;
+    spacePointIdsCubeVecsEndPoint: SpacePointIdentifiers[];
+    spacePointIdsBaseVecsEndPoint: SpacePointIdentifiers[];
+    spacePointIdsWrtBaseVecs: SpacePointIdentifiers[];
+};
+export declare const lineLineRelativePositionsFromCubeOuterPoints: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=lineLineRelativePositionsFromCubeOuterPoints.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/lineLineRelativePositionsFromCubeOuterPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lineLineRelativePositionsFromCubeOuterPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/lineLineRelativePositionsFromCubeOuterPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAgT3C,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,wBAAwB,EAAE,qBAAqB,EAAE,CAAC;CACnD,CAAC;AAqhBF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAsB5E,CAAC"}