math-exercises 3.0.0 → 3.0.3

package/lib/exercises/math/calculLitteral/distributivity/simpleDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simpleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}
+{"version":3,"file":"simpleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/simpleDistributivity.js

@@ -80,7 +80,6 @@ const getPropositions = (n, { answer, a, b, coeff }) => {
 };
 const isAnswerValid = (ans, { answer, a, b, coeff }) => {
     try {
-        console.log(ans, answer);
         const parsed = polynomialParser(ans);
         if (!parsed)
             return false;

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAmBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAgKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAmBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA8JF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.js

@@ -101,7 +101,6 @@ const getPropositions = (n, { answer, affinesCoeffs, operation }) => {
 };
 const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
-        console.log(ans, answer);
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
@@ -116,7 +115,6 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
             forbidFactorize: true,
         });
         // const simp = parsed.simplify({});
-        console.log(simp.toTex());
         return simp.toTex() === answerSimp.toTex();
     }
     catch (err) {

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

@@ -1,3 +1,2 @@
 export * from "./tableReading.js";
-export * from "./barChartReading.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

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

@@ -1,2 +1,2 @@
 export * from "./tableReading.js";
-export * from "./barChartReading.js";
+// export * from "./barChartReading.js";

package/lib/exercises/math/powers/powersProduct.d.ts

@@ -9,8 +9,9 @@ type Identifiers = {
 };
 type Options = {
     useOnlyPowersOfTen: boolean;
+    forbidNegativePower?: boolean;
 };
-export declare const powersOfTenProduct: Exercise<Identifiers>;
+export declare const powersOfTenProduct: Exercise<Identifiers, Options>;
 export declare const powersProduct: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=powersProduct.d.ts.map

package/lib/exercises/math/powers/powersProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AA2HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CA8BpD,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBxD,CAAC"}
+{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAgBT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AAsIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA+B7D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBxD,CAAC"}

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

@@ -8,7 +8,7 @@ import { multiply, } from "../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../tree/nodes/operators/powerNode.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 import { rationalParser } from "../../../tree/parsers/rationalParser.js";
 import { powerParser } from "../../../tree/parsers/powerParser.js";
@@ -65,7 +65,7 @@ const getAnswer = (identifiers) => {
 };
 const getPowersProductQuestion = (opts) => {
     const a = opts?.useOnlyPowersOfTen ? 10 : randint(-11, 11, [0]);
-    const [b, c] = [1, 2].map((el) => randint(-11, 11));
+    const [b, c] = [1, 2].map((el) => opts?.forbidNegativePower ? randint(0, 11) : randint(-11, 11));
     const identifiers = { a, b, c };
     const question = {
         instruction: getInstruction(identifiers, opts),
@@ -102,6 +102,15 @@ const isAnswerValid = (ans, { a, b, c }) => {
         return true;
     return false;
 };
+const options = [
+    {
+        id: "forbidNegativePower",
+        label: "Ne pas utiliser les puissances négatives",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const powersOfTenProduct = {
     id: "powersOfTenProduct",
     connector: "=",
@@ -121,13 +130,14 @@ export const powersOfTenProduct = {
     ],
     sections: ["Puissances"],
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(() => getPowersProductQuestion({ useOnlyPowersOfTen: true }), nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getPowersProductQuestion({ ...opts, useOnlyPowersOfTen: true }), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    options,
 };
 export const powersProduct = {
     id: "powersProduct",
@@ -136,7 +146,7 @@ export const powersProduct = {
     levels: ["4ème", "3ème", "2nde"],
     sections: ["Puissances"],
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getPowersProductQuestion({ useOnlyPowersOfTen: false }), nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getPowersProductQuestion({ ...opts, useOnlyPowersOfTen: false }), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -148,4 +158,5 @@ export const powersProduct = {
     getHint,
     getInstruction,
     getStartStatement,
+    options,
 };

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    caracType: string;
+    k: number;
+    nbEssais: number;
+};
+export declare const calculateFrequency: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateFrequency.d.ts.map

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA+FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/probaStat/basicStats/calculateFrequency.js

@@ -0,0 +1,100 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { k, nbEssais } = identifiers;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, k + "");
+    tryToAddWrongProp(propositions, frac(k, 100).toTex());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { k, nbEssais } = identifiers;
+    return frac(k, nbEssais).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { type, k, nbEssais, caracType } = identifiers;
+    switch (type) {
+        case 0: //pièce
+            return `On lance une pièce de monnaie $${nbEssais}$ fois. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+        case 1: //dé 6 faces
+            return `On lance un dé à $6$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+        case 2: // dé X faces
+            return `On lance un dé à $12$ faces $${nbEssais}$ fois. On tombe  $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+        case 3:
+        default: //deux dés 6 faces
+            return `On lance deux dés à $6$ faces $${nbEssais}$ fois. On note la somme obtenue. On tombe $${k}$ fois sur ${caracType}. Quelle est la fréquence d'apparition de ${caracType} ?`;
+    }
+};
+const getHint = (identifiers) => {
+    const { type, k, nbEssais, caracType } = identifiers;
+    return `La fréquence est le nombre de fois qu'on a obtenu ${caracType} divisée par le nombre total d'essais.`;
+};
+const getCorrection = (identifiers) => {
+    const { type, k, nbEssais, caracType } = identifiers;
+    return `On a obtenu $${k}$ fois ${caracType} sur les $${nbEssais}$ lancers. La fréquence d'apparition de ${caracType} est donc : 
+  
+$$
+${frac(k, nbEssais).toSimplificationString()}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer, { decimalPrecision: 2 });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateFrequencyQuestion = (ops) => {
+    const type = randint(0, 4);
+    const nbEssais = 5 * randint(10, 100);
+    const k = randint(1, nbEssais);
+    const caracType = type === 0
+        ? random(["Pile", "Face"])
+        : type === 1
+            ? `la face $${randint(1, 7)}$`
+            : type === 2
+                ? `la face $${randint(1, 13)}$`
+                : `la somme $${randint(1, 13)}$`;
+    const identifiers = { type, k, nbEssais, caracType };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const calculateFrequency = {
+    id: "calculateFrequency",
+    connector: "=",
+    label: "Calculer une fréquence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateFrequencyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export * from "./calculateFrequency.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./calculateFrequency.js";

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

@@ -10,4 +10,5 @@ export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
+export * from "./basicStats/index.js";
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -10,3 +10,4 @@ export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
+export * from "./basicStats/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsCF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"arithmeticFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAoDF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

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

@@ -2,22 +2,31 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { random } from "../../../../utils/alea/random.js";
-const getArithmeticFirstTermsSumQuestion = () => {
-    const firstRank = random([0, 1]);
-    const firstValue = randint(-9, 10);
-    const reason = randint(-5, 5, [0]);
-    const nbTerms = randint(4, 9);
+const getInstruction = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    return `Soit $u$ une suite arithmétique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
     const lastRank = firstRank + nbTerms - 1;
     const answer = (lastRank - firstRank + 1) *
         (firstRank === 0 ? firstValue : firstValue - reason) +
         (reason * (lastRank * (lastRank + 1))) / 2;
     const answerTex = answer + "";
+    return answerTex;
+};
+const getArithmeticFirstTermsSumQuestion = () => {
+    const firstRank = random([0, 1]);
+    const firstValue = randint(-9, 10);
+    const reason = randint(-5, 5, [0]);
+    const nbTerms = randint(4, 9);
+    const identifiers = { firstRank, firstValue, reason, nbTerms };
     const question = {
-        answer: answerTex,
-        instruction: `Soit $u$ une suite arithmétique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { firstRank, firstValue, reason, nbTerms },
+        identifiers,
     };
     return question;
 };
@@ -45,4 +54,6 @@ export const arithmeticFirstTermsSum = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiCF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8EF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAmBlD,CAAC"}

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

@@ -1,16 +1,33 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { final } = identifiers;
+    return `Calculer la somme suivante : 
+
+$$
+1+2+3+\\ldots + ${final}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { final } = identifiers;
+    return `${(final * (final + 1)) / 2}`;
+};
 const getFirstIntegersSumQuestion = () => {
     const final = randint(20, 100);
-    const answer = `${(final * (final + 1)) / 2}`;
+    const identifiers = { final };
     const question = {
-        answer,
-        instruction: `Calculer la somme suivante : $1+2+3+\\ldots + ${final}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { final },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -28,6 +45,32 @@ const getPropositions = (n, { answer, final }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const getHint = (identifiers) => {
+    return `La somme des $n$ premiers entiers est : 
+ 
+$$
+S_n = \\frac{n(n+1)}{2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const final = identifiers.final;
+    return `La somme des $n$ premiers entiers est : 
+ 
+$$
+S_n = \\frac{n(n+1)}{2}
+$$
+
+Ici, on a $n = ${final}$. 
+
+On a donc : 
+
+${alignTex([
+        ["", `1+2+3+\\ldots + ${final}`],
+        ["=", frac(multiply(final, final + 1), 2).toTex()],
+        ["=", getAnswer(identifiers)],
+    ])}
+`;
+};
 export const firstIntegersSum = {
     id: "firstIntegersSum",
     connector: "=",
@@ -41,4 +84,9 @@ export const firstIntegersSum = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA+CF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAyDF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}

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

@@ -2,23 +2,32 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { random } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    return `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    const answer = (firstValue * (1 - Math.pow(reason, nbTerms))) / (1 - reason);
+    return answer.frenchify();
+};
 const getGeometricFirstTermsGeneralSumQuestion = () => {
     const firstRank = random([0, 1]);
     const firstValue = randint(-9, 10, [0]);
     const reason = randint(-5, 5, [0, 1]);
     const nbTerms = randint(4, 9);
-    const answer = (firstValue * (1 - Math.pow(reason, nbTerms))) / (1 - reason);
+    const identifiers = {
+        firstRank,
+        firstValue,
+        reason,
+        nbTerms,
+    };
     const question = {
-        answer: answer + "",
-        instruction: `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            firstRank,
-            firstValue,
-            reason,
-            nbTerms,
-        },
+        identifiers,
     };
     return question;
 };
@@ -50,4 +59,6 @@ export const geometricFirstTermsGeneralSum = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2CF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAsBxD,CAAC"}
+{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -2,16 +2,29 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { raison, final } = identifiers;
+    return `Calculer la somme suivante : 
+  
+$$
+1 + ${raison} + ${raison}^2 + \\ldots + ${raison}^{${final}}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { raison, final } = identifiers;
+    const answer = (raison ** (final + 1) - 1) / (raison - 1) + "";
+    return answer;
+};
 const getGeometricFirstTermsSumQuestion = () => {
     const raison = randint(2, 8);
     const final = randint(5, 10);
-    const answer = (raison ** (final + 1) - 1) / (raison - 1) + "";
+    const identifiers = { raison, final };
     const question = {
-        answer: answer,
-        instruction: `Calculer la somme suivante : $1 + ${raison} + ${raison}^2 + \\ldots + ${raison}^{${final}}$`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { raison, final },
+        identifiers,
     };
     return question;
 };
@@ -33,21 +46,13 @@ export const geometricFirstTermsSum = {
     id: "geometricFirstTermsSum",
     connector: "=",
     label: "Somme des termes d'une suite géométrique",
-    levels: [
-        "1reESM",
-        "1rePro",
-        "1reSpé",
-        "1reTech",
-        "TermPro",
-        "TermSpé",
-        "TermTech",
-    ],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getGeometricFirstTermsSumQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
 };

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { Exercise, Question } from "./exercises/exercise.js";
 import "./prototypesEnhancement.js";
+import { parseAlgebraic } from "./tree/parsers/latexParser.js";
 declare const mathExercises: (Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -1365,12 +1366,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
-    a: number;
-    b: number;
-    c: number;
 }, {
     useOnlyPowersOfTen: boolean;
+    forbidNegativePower?: boolean;
 }> | Exercise<{
     tenPower: number;
     decimal: number;
@@ -1531,6 +1529,11 @@ declare const mathExercises: (Exercise<{
 }, {
     instructionType: string;
 }> | Exercise<{
+    type: number;
+    caracType: string;
+    k: number;
+    nbEssais: number;
+}, {}> | Exercise<{
     firstValue: number;
     askedRank: number;
     reason: number;
@@ -1820,8 +1823,6 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     values: number[][];
     caseAsked: number;
-}, {}> | Exercise<{
-    a: number;
 }, {}>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];
@@ -2269,5 +2270,5 @@ declare const pcExercises: (Exercise<{
     E: number;
     S: number;
 }, {}>)[];
-export { mathExercises, pcExercises, Exercise, Question };
+export { mathExercises, pcExercises, Exercise, Question, parseAlgebraic };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -1,6 +1,8 @@
 import * as MathExercises from "./exercises/math/index.js";
 import * as PCExercises from "./exercises/pc/index.js";
 import "./prototypesEnhancement.js";
+import { parseAlgebraic } from "./tree/parsers/latexParser.js";
+parseAlgebraic;
 const mathExercises = Object.values(MathExercises);
 const pcExercises = Object.values(PCExercises);
-export { mathExercises, pcExercises };
+export { mathExercises, pcExercises, parseAlgebraic };

package/lib/playground.d.ts

@@ -1,2 +1,2 @@
-export declare const playground: () => false | undefined;
+export declare const playground: () => void;
 //# sourceMappingURL=playground.d.ts.map

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,yBAgBtB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,UAAU,YAAW,CAAC"}