math-exercises 2.2.7 → 2.2.9

package/lib/exercises/math/powers/scientificToDecimal.js

@@ -14,7 +14,6 @@ const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const getScientificToDecimalQuestion = () => {
     const decScientific = decimal_1.DecimalConstructor.randomScientific((0, randint_1.randint)(1, 4));
     const tenPower = (0, randint_1.randint)(-5, 6, [0, 1]);
-    console.log("scien to dec q");
     const answer = decScientific.multiplyByPowerOfTen(tenPower).toTree().toTex();
     const statement = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(decScientific.value), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(tenPower)));
     const statementTex = statement.toTex();
@@ -34,7 +33,6 @@ const getPropositions = (n, { answer, tenPower, decimal }) => {
     (0, exercise_1.addValidProp)(propositions, answer);
     (0, exercise_1.tryToAddWrongProp)(propositions, decScientific.multiplyByPowerOfTen(-tenPower).toTree().toTex());
     while (propositions.length < n) {
-        console.log("scien to dec qcm");
         const wrongAnswerTree = decScientific
             .multiplyByPowerOfTen((0, randint_1.randint)(-6, 6, [tenPower]))
             .toTree();

package/lib/exercises/math/primitive/expUPrimitive.js

@@ -57,7 +57,6 @@ const isExpUPrimitiveAnswerValid = (ans, { coeffs }) => {
     const integratedFuction = new expNode_1.ExpNode(u.toTree({ forbidPowerToProduct: true }));
     const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.isExpUPrimitiveAnswerValid = isExpUPrimitiveAnswerValid;

package/lib/exercises/math/primitive/exponentialPrimitive.js

@@ -53,7 +53,6 @@ const isExponentialPrimitiveAnswerValid = (ans, { a }) => {
     const integratedFuction = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new expNode_1.ExpNode(new variableNode_1.VariableNode("x")));
     const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.isExponentialPrimitiveAnswerValid = isExponentialPrimitiveAnswerValid;

package/lib/exercises/math/primitive/logarithmePrimitive.js

@@ -61,7 +61,6 @@ const isLogarithmePrimitiveAnswerValid = (ans, { coeffs }) => {
     const integratedFuction = new logNode_1.LogNode(new absNode_1.AbsNode(uTree));
     const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.logarithmePrimitive = {

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -41,7 +41,6 @@ const isPolynomialPrimitiveAnswerValid = (ans, { coeffs }) => {
     const polynomial = new polynomial_1.Polynomial(coeffs);
     const integralPolynomial = polynomial.integrateToNode(opts);
     const texs = integralPolynomial.toAllValidTexs(opts);
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.isPolynomialPrimitiveAnswerValid = isPolynomialPrimitiveAnswerValid;

package/lib/exercises/math/primitive/sinCosPrimitive.js

@@ -60,7 +60,6 @@ const isSinCosPrimitiveAnswerValid = (ans, { isCos, a }) => {
         : new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-a), new cosNode_1.CosNode(new variableNode_1.VariableNode("x")));
     const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.isSinCosPrimitiveAnswerValid = isSinCosPrimitiveAnswerValid;

package/lib/exercises/math/primitive/sinUCosUPrimitive.js

@@ -66,7 +66,6 @@ const isSinUCosUPrimitiveAnswerValid = (ans, { isCos, coeffs }) => {
         : new oppositeNode_1.OppositeNode(new cosNode_1.CosNode(u.toTree({ forbidPowerToProduct: true })));
     const answer = new addNode_1.AddNode(integratedFuction, new variableNode_1.VariableNode("C"));
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.isSinUCosUPrimitiveAnswerValid = isSinUCosUPrimitiveAnswerValid;

package/lib/exercises/math/probaStat/cardBasicProbas.js

@@ -86,7 +86,6 @@ const isAnswerValid = (ans, { questionType }) => {
         allowFractionToDecimal: true,
     });
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.cardBasicProbas = {

package/lib/exercises/math/probaStat/diceBasicProbas.js

@@ -59,7 +59,6 @@ const isAnswerValid = (ans, { isParityQuestion, isEvenQuestion, nbFaces }) => {
             : new rational_1.Rational(Math.ceil(nbFaces / 2), nbFaces).simplify().toTree(opts)
         : new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new numberNode_1.NumberNode(nbFaces), opts);
     const texs = answer.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.diceBasicProbas = {

package/lib/exercises/math/probaStat/probabilityTree.js

@@ -118,7 +118,6 @@ const getPropositions = (n, { answer, A, AC, AD, B, BC, BD, type }) => {
 const isAnswerValid = (ans, { A, AC, AD, B, BC, BD, type }) => {
     const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
     const texs = answer.toTree({ allowFractionToDecimal: true }).toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.probabilityTree = {

package/lib/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marginalAndConditionalFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkIF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"marginalAndConditionalFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA2IF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.js

@@ -8,6 +8,15 @@ const exercise_1 = require("../../../exercise");
 const getDistinctQuestions_1 = require("../../../utils/getDistinctQuestions");
 const getAnswer = (rand, x1, x2, x3, x4) => {
     const x = x1 + x2 + x3 + x4;
+    const total = x1 + x2 + x3 + x4;
+    const totalA = x1 + x3;
+    const totalB = x2 + x4;
+    const totalC = x1 + x2;
+    const totalD = x3 + x4;
+    const A_C = x1;
+    const A_D = x3;
+    const B_C = x2;
+    const B_D = x4;
     let freqString;
     let frequence;
     let answer;
@@ -43,8 +52,8 @@ const getAnswer = (rand, x1, x2, x3, x4) => {
             answer = new rational_1.Rational(x3, x3 + x4).simplify().toTree();
             break;
         case 6:
-            freqString = "conditionnelle de B parmi D";
-            frequence = "f_D(B)";
+            freqString = "conditionnelle de B parmi C";
+            frequence = "f_C(B)";
             answer = new rational_1.Rational(x2, x1 + x2).simplify().toTree();
             break;
         case 7:
@@ -60,12 +69,12 @@ const getAnswer = (rand, x1, x2, x3, x4) => {
         case 9:
             freqString = "conditionnelle de C parmi B";
             frequence = "f_B(C)";
-            answer = new rational_1.Rational(x3, x1 + x3).simplify().toTree();
+            answer = new rational_1.Rational(x2, x2 + x4).simplify().toTree();
             break;
         case 10:
             freqString = "conditionnelle de D parmi A";
             frequence = "f_A(D)";
-            answer = new rational_1.Rational(x2, x2 + x4).simplify().toTree();
+            answer = new rational_1.Rational(x3, x1 + x3).simplify().toTree();
             break;
         case 11:
             freqString = "conditionnelle de D parmi B";

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormula.js

@@ -56,7 +56,6 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.arithmeticFindExplicitFormula = {

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplictFormulaFirstTermRandom.js

@@ -40,7 +40,6 @@ const isAnswerValid = (ans, { reason, firstValue, firstRank }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    console.log(texs);
     return texs.includes(ans);
 };
 exports.arithmeticFindExplicitFormulaFirstTermRandom = {

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
+};
+export declare const arithmeticFindTerm: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=arithmeticFindTerm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindTerm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindTerm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindTerm.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arithmeticFindTerm = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/random");
+const getArithmeticFindTermQuestion = () => {
+    const firstRank = (0, random_1.random)([0, 1]);
+    const firstTerm = (0, randint_1.randint)(-15, 15);
+    const reason = (0, randint_1.randint)(-10, 10, [0]);
+    const askedRank = (0, randint_1.randint)(5, 15);
+    const answer = firstTerm + reason * (askedRank - firstRank);
+    const question = {
+        answer: answer + "",
+        instruction: `Soit $u$ la suite arithmétique de premier terme $u_${firstRank} = ${firstTerm}$ et de raison $r = ${reason}$. Calculer $u_{${askedRank}}$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { firstRank, askedRank, firstTerm, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, askedRank, firstRank, firstTerm, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const fake = firstTerm + reason * (askedRank - (0, randint_1.randint)(-4, 4, [firstRank]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, fake + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.arithmeticFindTerm = {
+    id: "arithmeticFindTerm",
+    connector: "=",
+    label: "Calculer un terme d'une suite arithmétique à partir de son premier terme et sa raison",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArithmeticFindTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -13,4 +13,5 @@ export * from "./arithmeticFirstTermsSum";
 export * from "./arithmeticFindExplictFormulaFirstTermRandom";
 export * from "./arithmeticFindReasonRandomRange";
 export * from "./arithmeticFindRandomTermFromTwoTerms";
+export * from "./arithmeticFindTerm";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qCAAqC,CAAC;AACpD,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qCAAqC,CAAC;AACpD,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+CAA+C,CAAC;AAC9D,cAAc,mCAAmC,CAAC;AAClD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sBAAsB,CAAC"}

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

@@ -29,3 +29,4 @@ __exportStar(require("./arithmeticFirstTermsSum"), exports);
 __exportStar(require("./arithmeticFindExplictFormulaFirstTermRandom"), exports);
 __exportStar(require("./arithmeticFindReasonRandomRange"), exports);
 __exportStar(require("./arithmeticFindRandomTermFromTwoTerms"), exports);
+__exportStar(require("./arithmeticFindTerm"), exports);

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

@@ -12,7 +12,7 @@ const alignTex_1 = require("../../../../utils/alignTex");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getGeometricExplicitFormulaUsage = () => {
     const askedRank = (0, randint_1.randint)(0, 10);
-    const firstValue = (0, randint_1.randint)(1, 10);
+    const firstValue = (0, randint_1.randint)(-5, 10, [0]);
     const reason = (0, randint_1.randint)(2, 10);
     const formula = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), new variableNode_1.VariableNode("n")));
     const formulaTex = formula.toTex();

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAiFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

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

@@ -56,7 +56,6 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    console.log(ans, texs);
     return texs.includes(ans);
 };
 exports.geometricFindExplicitFormula = {

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgFF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAgB3E,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+EF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAgB3E,CAAC"}

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

@@ -43,7 +43,6 @@ const isAnswerValid = (ans, { reason, firstValue, firstRank }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    console.log(ans, texs);
     return texs.includes(ans);
 };
 exports.geometricFindExplicitFormulaFirstTermRandom = {

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    firstRank: number;
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
+};
+export declare const geometricFindTerm: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFindTerm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindTerm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindTerm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqCF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricFindTerm = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/random");
+const getGeometricFindTermQuestion = () => {
+    const firstRank = (0, random_1.random)([0, 1]);
+    const firstTerm = (0, randint_1.randint)(-10, 10, [0]);
+    const reason = (0, randint_1.randint)(2, 6);
+    const askedRank = (0, randint_1.randint)(5, 12);
+    const answer = firstTerm * Math.pow(reason, askedRank - firstRank);
+    const question = {
+        answer: answer + "",
+        instruction: `Soit $u$ la suite géométrique de premier terme $u_${firstRank} = ${firstTerm}$ et de raison $q = ${reason}$. Calculer $u_{${askedRank}}$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { firstRank, askedRank, firstTerm, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, askedRank, firstRank, firstTerm, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const fake = firstTerm * Math.pow(reason, askedRank - (0, randint_1.randint)(-5, 3, [firstRank]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, fake + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.geometricFindTerm = {
+    id: "geometricFindTerm",
+    connector: "=",
+    label: "Calculer un terme d'une suite géométrique à partir de son premier terme et sa raison",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricFindTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    sequence: number[];
+    reason: number;
+};
+export declare const geometricRecognizeReasonFromFirstTerms: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricRecognizeReasonFromFirstTerms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricRecognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAqCF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAexE,CAAC"}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricRecognizeReasonFromFirstTerms = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const getGeometricRecognizeReasonFromFirstTermsQuestion = () => {
+    const firstTerm = (0, randint_1.randint)(1, 20);
+    const reason = (0, randint_1.randint)(-5, 6, [0, 1]);
+    const sequence = new Array(5)
+        .fill(0)
+        .map((el, index) => firstTerm * Math.pow(reason, index));
+    const question = {
+        answer: reason + "",
+        instruction: `Voici les premiers termes d'une suite géométrique $u$ : $${sequence.join("\\ ; \\ ")}$. Quelle est la raison de $u$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { sequence, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, reason + (0, randint_1.randint)(-5, 5, [0]) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.geometricRecognizeReasonFromFirstTerms = {
+    id: "geometricRecognizeReasonFromFirstTerms",
+    connector: "=",
+    label: "Reconnaître la raison d'une suite géométrique via ses premiers termes",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricRecognizeReasonFromFirstTermsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -5,4 +5,6 @@ export * from "./geometricFirstTermsSum";
 export * from "./geometricReasonUsage";
 export * from "./geometricRecurrenceFormulaUsage";
 export * from "./geometricFindExplicitFormulaFirstTermRandom";
+export * from "./geometricFindTerm";
+export * from "./geometricRecognizeReasonFromFirstTerms";
 //# 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,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC"}

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

@@ -21,3 +21,5 @@ __exportStar(require("./geometricFirstTermsSum"), exports);
 __exportStar(require("./geometricReasonUsage"), exports);
 __exportStar(require("./geometricRecurrenceFormulaUsage"), exports);
 __exportStar(require("./geometricFindExplicitFormulaFirstTermRandom"), exports);
+__exportStar(require("./geometricFindTerm"), exports);
+__exportStar(require("./geometricRecognizeReasonFromFirstTerms"), exports);

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

@@ -1,4 +1,5 @@
 export * from "./inequalityToInterval";
 export * from "./intervalsIntersection";
 export * from "./intervalsUnion";
+export * from "./intervalToInequality";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC"}

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./inequalityToInterval"), exports);
 __exportStar(require("./intervalsIntersection"), exports);
 __exportStar(require("./intervalsUnion"), exports);
+__exportStar(require("./intervalToInequality"), exports);

package/lib/exercises/math/sets/intervals/inequalityToInterval.d.ts

@@ -1,9 +1,8 @@
 import { Exercise } from "../../../../exercises/exercise";
 import { ClosureType } from "../../../../tree/nodes/sets/closure";
 type Identifiers = {
-    isIntervalToInequality: boolean;
-    intervalMin: number;
-    intervalMax: number;
+    intervalMin: number | string;
+    intervalMax: number | string;
     intervalClosure: ClosureType;
 };
 export declare const inequalityToInterval: Exercise<Identifiers>;

package/lib/exercises/math/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,OAAO,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAK5D,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,WAAW,CAAC;CAC9B,CAAC;AAoFF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/sets/intervals/inequalityToInterval.js

@@ -4,22 +4,14 @@ exports.inequalityToInterval = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../../math/sets/intervals/intervals");
-const inequationNode_1 = require("../../../../tree/nodes/inequations/inequationNode");
-const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const belongsNode_1 = require("../../../../tree/nodes/sets/belongsNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
-const coinFlip_1 = require("../../../../utils/coinFlip");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getInequalityToIntervalQuestion = () => {
-    const isIntervalToInequality = (0, coinFlip_1.coinFlip)();
     const interval = intervals_1.IntervalConstructor.random();
     const inequalityString = interval.toInequality();
-    const answer = isIntervalToInequality
-        ? inequalityString
-        : `x\\in${interval.toTex()}`;
-    const instruction = isIntervalToInequality
-        ? `Soit $x \\in ${interval.toTex()}$. Traduire cette appartenance en une inégalité.`
-        : `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
+    const answer = `x\\in${interval.toTex()}`;
+    const instruction = `Soit $${inequalityString}$. Traduire cette inégalité en appartenance à un intervalle.`;
     const question = {
         answer,
         instruction: instruction,
@@ -37,100 +29,40 @@ const getInequalityToIntervalQuestion = () => {
         ],
         answerFormat: "tex",
         identifiers: {
-            isIntervalToInequality: isIntervalToInequality,
-            intervalMin: interval.min,
-            intervalMax: interval.max,
+            intervalMin: interval.min === -Infinity ? "-infty" : interval.min,
+            intervalMax: interval.max === Infinity ? "infty" : interval.max,
             intervalClosure: interval.closure,
         },
     };
     return question;
 };
-const getPropositions = (n, { answer, isIntervalToInequality, intervalClosure, intervalMax, intervalMin }) => {
+const getPropositions = (n, { answer, intervalClosure, intervalMax, intervalMin }) => {
     const reverseBracket = (bracket) => {
         return bracket === "[" ? "]" : "[";
     };
-    const switchInclusion = (symbol) => {
-        if (symbol === "\\le")
-            return "<";
-        if (symbol === "<")
-            return "\\le";
-        if (symbol === ">")
-            return "\\ge";
-        return ">";
-    };
-    const reverseInequality = (symbol) => {
-        if (symbol === "\\le")
-            return "\\ge";
-        if (symbol === "<")
-            return ">";
-        if (symbol === ">")
-            return "<";
-        return "\\le";
-    };
-    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure);
+    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
+    const max = intervalMax === "infty" ? Infinity : intervalMax;
+    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const xNode = new variableNode_1.VariableNode("x");
-    if (isIntervalToInequality) {
-        let wrongIneqs = [];
-        if (interval.min === -Infinity) {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], switchInclusion(interval.rightInequalitySymbol)),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(switchInclusion(interval.rightInequalitySymbol))),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.max)], reverseInequality(interval.rightInequalitySymbol)),
-            ];
-        }
-        else if (interval.max === Infinity) {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], switchInclusion(interval.leftInequalitySymbol)),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(switchInclusion(interval.leftInequalitySymbol))),
-                new inequationNode_1.InequationNode([xNode, new numberNode_1.NumberNode(interval.min)], reverseInequality(interval.leftInequalitySymbol)),
-            ];
-        }
-        else {
-            wrongIneqs = [
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    switchInclusion(interval.leftInequalitySymbol),
-                    interval.rightInequalitySymbol,
-                ]),
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    interval.leftInequalitySymbol,
-                    switchInclusion(interval.rightInequalitySymbol),
-                ]),
-                new inequationNode_1.InequationNode([new numberNode_1.NumberNode(interval.min), xNode, new numberNode_1.NumberNode(interval.max)], [
-                    switchInclusion(interval.leftInequalitySymbol),
-                    switchInclusion(interval.rightInequalitySymbol),
-                ]),
-            ];
-        }
-        wrongIneqs.forEach((ineq) => {
-            (0, exercise_1.addWrongProp)(propositions, ineq.toTex());
-        });
-    }
-    else {
-        const wrongStatements = [
-            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
-            `x\\in${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
-            `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
-        ];
-        wrongStatements.forEach((ineq) => {
-            (0, exercise_1.addWrongProp)(propositions, ineq);
-        });
-    }
+    const wrongStatements = [
+        `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${interval.rightBracket}`,
+        `x\\in${interval.leftBracket}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+        `x\\in${reverseBracket(interval.leftBracket)}${interval.insideToTex()}${reverseBracket(interval.rightBracket)}`,
+    ];
+    wrongStatements.forEach((ineq) => {
+        (0, exercise_1.addWrongProp)(propositions, ineq);
+    });
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin, isIntervalToInequality }) => {
-    const interval = new intervals_1.Interval(intervalMin.toTree(), intervalMax.toTree(), intervalClosure).toTree();
-    console.log("int", interval.toTex());
-    const inequality = interval.toInequality();
-    const answer = isIntervalToInequality
-        ? inequality
-        : new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
-            allowRawRightChildAsSolution: true,
-        });
-    console.log("ans", answer);
+const isAnswerValid = (ans, { intervalClosure, intervalMax, intervalMin }) => {
+    const min = intervalMin === "-infty" ? -Infinity : intervalMin;
+    const max = intervalMax === "infty" ? Infinity : intervalMax;
+    const interval = new intervals_1.Interval(min.toTree(), max.toTree(), intervalClosure).toTree();
+    const answer = new belongsNode_1.BelongsNode(new variableNode_1.VariableNode("x"), interval, {
+        allowRawRightChildAsSolution: true,
+    });
     const texs = answer.toAllValidTexs();
-    console.log("texs", texs);
     return texs.includes(ans);
 };
 exports.inequalityToInterval = {