math-exercises 3.0.64 → 3.0.65

package/lib/exercises/math/percent/evolutions/findEndValueAfterEvolution.js

@@ -0,0 +1,102 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { euroParser } from "../../../../tree/parsers/euroParser.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getPropositions = (n, { answer, percentRate, vd }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const cm = 1 + percentRate / 100;
+    tryToAddWrongProp(propositions, round(vd * percentRate, 2).frenchify());
+    const invCm = 1 - percentRate / 100;
+    tryToAddWrongProp(propositions, round(vd * invCm, 2).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, round(randfloat(1, 100, 2), 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const cm = 1 + identifiers.percentRate / 100;
+    const vf = round(identifiers.vd * cm, 2);
+    return vf.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    return `Le prix initial d'un objet est $${identifiers.vd.frenchify()}€$. Quel sera son prix après une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$ ? Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Transforme le taux d'évolution en coefficient multiplicateur. Puis multiplie le prix initial par ce coefficient multiplicateur.`;
+};
+const getCorrection = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    const answer = getAnswer(identifiers);
+    const cm = round(1 + identifiers.percentRate / 100, 4);
+    const vd = identifiers.vd;
+    const percentRate = identifiers.percentRate;
+    return `Le coefficient multiplicateur associé à une ${evolution} de $${percentRate.frenchify()}\\%$ est : 
+      
+${alignTex([
+        ["CM", "=", "1+\\frac{t}{100}"],
+        ["", "=", `1+\\frac{${percentRate.frenchify()}}{100}`],
+        ["", "=", cm.frenchify()],
+    ])}
+
+Si on note $V_d$ la valeur de départ et $V_a$ la valeur d'arrivée, alors on sait que :
+
+$$
+V_d\\times CM = V_a
+$$
+
+Le prix final arrondi au centième est donc : 
+
+${alignTex([
+        ["V_a", "=", multiply(vd.frenchify(), cm.frenchify()).toTex()],
+        ["", ...approxOrEqual(cm * vd, 2)],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return euroParser(ans) === answer + "€";
+};
+const getFindEndValueAfterEvolutionQuestion = () => {
+    const vd = randfloat(1, 100, 2);
+    const percentRate = randfloat(-100, 100, 2, [0]);
+    const identifiers = {
+        vd,
+        percentRate,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findEndValueAfterEvolution = {
+    id: "findEndValueAfterEvolution",
+    connector: "=",
+    label: "Retrouver un prix final à partir du prix initial et du taux d'évolution",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getFindEndValueAfterEvolutionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/percent/evolutions/findRightCalculForPriceEvolution.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    type: number;
+    price: number;
+    evolution: number;
+    askingFinalPrice: boolean;
+};
+export declare const findRightCalculForPriceEvolution: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findRightCalculForPriceEvolution.d.ts.map

package/lib/exercises/math/percent/evolutions/findRightCalculForPriceEvolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRightCalculForPriceEvolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/findRightCalculForPriceEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAyIF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

package/lib/exercises/math/percent/evolutions/findRightCalculForPriceEvolution.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../../tree/nodes/operators/divideNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer, evolution, price, type }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (evolution > 0) {
+        tryToAddWrongProp(propositions, multiply(price, add(1, frac(Math.abs(evolution), 100))).toTex());
+        tryToAddWrongProp(propositions, multiply(price, Math.abs(evolution) / 100).toTex());
+        tryToAddWrongProp(propositions, divide(price, Math.abs(evolution)).toTex());
+        tryToAddWrongProp(propositions, divide(price, add(1, frac(Math.abs(evolution), 100))).toTex());
+    }
+    else {
+        tryToAddWrongProp(propositions, multiply(price, substract(1, frac(Math.abs(evolution), 100))).toTex());
+        tryToAddWrongProp(propositions, multiply(price, Math.abs(evolution) / 100).toTex());
+        tryToAddWrongProp(propositions, divide(price, Math.abs(evolution)).toTex());
+        tryToAddWrongProp(propositions, divide(price, substract(1, frac(Math.abs(evolution), 100))).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { type, price, evolution, askingFinalPrice } = identifiers;
+    if (askingFinalPrice)
+        return multiply(price, (evolution > 0 ? add : substract)(1, frac(Math.abs(evolution), 100))).toTex();
+    else
+        return multiply(price, Math.abs(evolution) / 100).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { type, price, evolution, askingFinalPrice } = identifiers;
+    switch (type) {
+        case 1:
+            return `Un manteau coûte $${price}€$. Le magasin propose une réduction de $${Math.abs(evolution)}\\%$ sur cet article. Quel calcul peut-on faire pour trouver le ${askingFinalPrice
+                ? "nouveau prix de l'article"
+                : "montant de la réduction"} ?`;
+        case 2:
+            return `Le budget d'un club de sport est de $${price}€$. Suite à des pertes d'abonnés, ce budget diminuera de $${Math.abs(evolution)}\\%$ l'année prochaine. Quel calcul peut-on faire pour trouver le ${askingFinalPrice
+                ? "budget du club l'an prochain"
+                : "montant de la diminution"} ?`;
+        case 3:
+            return `L'abonnement à une plateforme de streaming coûte $${price}€$. Le mois prochain, ce prix augmentera de $${evolution}\\%$. Quel calcul peut-on faire pour trouver le ${askingFinalPrice
+                ? "nouveau prix de l'abonnement"
+                : "montant de l'augmentation"} ?`;
+        case 4:
+            return `Le salaire de M. Moulin est de $${price}€$. Le mois prochain, il recevra une augmentation de $${evolution}\\%$. Quel calcul peut-on faire pour trouver le ${askingFinalPrice
+                ? "nouveau salaire de M. Moulin"
+                : "montant de l'augmentation"} ?`;
+    }
+    return "";
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getFindRightCalculQuestion = (ops) => {
+    const evolution = randint(-6, 7, [0]) * 10;
+    const type = evolution < 0 ? random([1, 2]) : random([3, 4]);
+    const price = type === 1
+        ? randint(30, 400)
+        : type === 2
+            ? 10000 * randint(5, 20)
+            : type === 3
+                ? randint(10, 50)
+                : randint(1300, 2000);
+    const askingFinalPrice = coinFlip();
+    const identifiers = {
+        type,
+        price,
+        evolution,
+        askingFinalPrice,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findRightCalculForPriceEvolution = {
+    id: "findRightCalculForPriceEvolution",
+    connector: "=",
+    label: "Choisir le bon calcul pour appliquer une évolution en pourcentage",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindRightCalculQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    answerType: "QCU",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/percent/evolutions/findStartValueAfterEvolution.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    vf: number;
+    percentRate: number;
+};
+export declare const findStartValueAfterEvolution: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findStartValueAfterEvolution.d.ts.map

package/lib/exercises/math/percent/evolutions/findStartValueAfterEvolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findStartValueAfterEvolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/findStartValueAfterEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAiGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAgB9D,CAAC"}

package/lib/exercises/math/percent/evolutions/findStartValueAfterEvolution.js

@@ -0,0 +1,100 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { euroParser } from "../../../../tree/parsers/euroParser.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, percentRate, vf }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const invCm = 1 - percentRate / 100;
+    tryToAddWrongProp(propositions, round(vf * invCm, 2).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, round(randfloat(1, 100, 2), 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const cm = 1 + identifiers.percentRate / 100;
+    const vd = round(identifiers.vf / cm, 2);
+    return vd.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    return `Après une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$, le prix d'un objet est de $${identifiers.vf.frenchify()}€$. 
+  
+Quel était son prix initial ? Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Transforme le taux d'évolution en coefficient multiplicateur. Puis divise le prix final par ce coefficient multiplicateur.`;
+};
+const getCorrection = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    const answer = getAnswer(identifiers);
+    const cm = round(1 + identifiers.percentRate / 100, 4);
+    return `Le coefficient multiplicateur associé à une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$ est : 
+  
+
+${alignTex([
+        ["CM", "=", "1+\\frac{t}{100}"],
+        ["", "=", `1+\\frac{${identifiers.percentRate.frenchify()}}{100}`],
+        ["", "=", cm.frenchify()],
+    ])}
+
+
+Si on note $V_d$ la valeur de départ et $V_a$ la valeur d'arrivée, alors on sait que :
+
+$$
+V_d\\times CM = V_a
+$$
+
+Donc, pour trouver $V_d$, il faut diviser $V_a$ par le coefficient multiplicateur : 
+
+${alignTex([
+        ["V_d", "=", `\\frac{${identifiers.vf.frenchify()}}{${cm.frenchify()}}`],
+        ["", "\\approx", answer],
+    ])}
+  `;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return euroParser(ans) === answer + "€";
+};
+const getFindStartValueAfterEvolutionQuestion = () => {
+    const vf = randfloat(1, 100, 2);
+    const percentRate = randfloat(-99, 100, 2, [0]);
+    const identifiers = {
+        vf,
+        percentRate,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findStartValueAfterEvolution = {
+    id: "findStartValueAfterEvolution",
+    connector: "=",
+    label: "Retrouver un prix initial à partir du prix final et du taux d'évolution",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getFindStartValueAfterEvolutionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/percent/evolutions/globalPercent.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../exercise.js";
+type Identifiers = {
+    evolutions: string[];
+};
+export declare const globalPercent: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=globalPercent.d.ts.map

package/lib/exercises/math/percent/evolutions/globalPercent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalPercent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/globalPercent.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAO9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}

package/lib/exercises/math/percent/evolutions/globalPercent.js

@@ -0,0 +1,104 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { round } from "../../../../math/utils/round.js";
+import { percentParser } from "../../../../tree/parsers/percentParser.js";
+const getInstruction = (identifiers) => {
+    let instruction = "Le prix d'un article subit une ";
+    identifiers.evolutions.forEach((evolution, i) => {
+        const type = evolution[0] === "-" ? "baisse" : "hausse";
+        if (i === 0)
+            instruction += `${type} de $${evolution.substring(1)}\\%$`;
+        else
+            instruction += `, puis une ${type} de $${evolution.substring(1)}\\%$`;
+    });
+    instruction += `. 
+
+Déterminer le taux d'évolution global du prix de cet article (arrondir au centième de pourcentage).`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { evolutions } = identifiers;
+    const cms = evolutions.map((e) => 1 + Number(e) / 100);
+    const prod = cms.reduce((acc, curr) => acc * curr, 1);
+    const answer = round((prod - 1) * 100, 2).frenchify() + "\\%";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "Transforme chaque taux d'évolution en coefficient multiplicateur, puis multiplie ces coefficients multiplicateurs entre eux pour obtenir le coefficient multiplicateur global. Transforme alors ce CM global en taux d'évolution.";
+};
+const getCorrection = (identifiers) => {
+    const { evolutions } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `On transforme les taux d'évolution en coefficients multiplicateurs puis on les multiplie entre eux : 
+
+$$
+${evolutions
+        .map((e) => round(1 + Number(e) / 100, 2).frenchify())
+        .join(" \\times ")} = ${round(evolutions.reduce((acc, curr) => acc * round(1 + Number(curr) / 100, 2), 1), 4).frenchify()}
+$$
+    
+Enfin, on transforme ce CM global en taux d'évolution : 
+
+$$
+(${round(evolutions.reduce((acc, curr) => acc * round(1 + Number(curr) / 100, 2), 1), 4).frenchify()} - 1)\\times 100 = ${answer.replace("\\%", "")}
+$$
+
+Le taux d'évolution global est donc de $${answer}$.
+    `;
+};
+const getGlobalPercentQuestion = () => {
+    const indice = randint(2, 4);
+    const evolutions = [];
+    for (let i = 0; i < indice; i++) {
+        const randPercent = randint(1, 50);
+        let a = randint(0, 2);
+        evolutions.push((a === 0 ? "+" : "-") + randPercent);
+    }
+    const identifiers = { evolutions };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        let wrongAnswer = Number(answer.replace(",", ".").replace(`\\%`, ""));
+        const deviation = Math.random() < 0.5 ? -1 : 1;
+        const percentDeviation = Math.random() * 20 + 1;
+        wrongAnswer += deviation * percentDeviation;
+        wrongAnswer = round(wrongAnswer, 2);
+        tryToAddWrongProp(propositions, `${(wrongAnswer + "").replace(".", ",")} \\%`);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = percentParser(ans);
+    return parsed === answer.replace("+", "");
+};
+export const globalPercent = {
+    id: "globalPercent",
+    connector: "=",
+    label: "Calculer un taux d'évolution global à partir de taux d'évolution successifs",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getGlobalPercentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/percent/evolutions/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./applyPercent.js";
+export * from "./averageEvolutionRate.js";
+export * from "./evolutionToCM.js";
+export * from "./globalPercent.js";
+export * from "./reciprocalPercentage.js";
+export * from "./cmToEvolution.js";
+export * from "./evolutionRateFromValues.js";
+export * from "./findStartValueAfterEvolution.js";
+export * from "./findEndValueAfterEvolution.js";
+export * from "./findRightCalculForPriceEvolution.js";
+export * from "./compoundInterest.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/percent/evolutions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mCAAmC,CAAC;AAClD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uCAAuC,CAAC;AACtD,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/percent/evolutions/index.js

@@ -0,0 +1,11 @@
+export * from "./applyPercent.js";
+export * from "./averageEvolutionRate.js";
+export * from "./evolutionToCM.js";
+export * from "./globalPercent.js";
+export * from "./reciprocalPercentage.js";
+export * from "./cmToEvolution.js";
+export * from "./evolutionRateFromValues.js";
+export * from "./findStartValueAfterEvolution.js";
+export * from "./findEndValueAfterEvolution.js";
+export * from "./findRightCalculForPriceEvolution.js";
+export * from "./compoundInterest.js";

package/lib/exercises/math/percent/evolutions/reciprocalPercentage.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercise.js";
+type Identifiers = {
+    randPercent: number;
+    isUp: boolean;
+};
+export declare const reciprocalPercentage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=reciprocalPercentage.d.ts.map

package/lib/exercises/math/percent/evolutions/reciprocalPercentage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reciprocalPercentage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/percent/evolutions/reciprocalPercentage.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAM9B,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AA6HF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/percent/evolutions/reciprocalPercentage.js

@@ -0,0 +1,108 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { round } from "../../../../math/utils/round.js";
+import { percentParser } from "../../../../tree/parsers/percentParser.js";
+const getCorrection = (identifiers) => {
+    let ans = 0;
+    const { isUp, randPercent } = identifiers;
+    ans = identifiers.isUp
+        ? (1 / (1 + identifiers.randPercent / 100) - 1) * 100
+        : (1 / (1 - identifiers.randPercent / 100) - 1) * 100;
+    const answer = `${(ans > 0
+        ? "+" + round(ans, 2)
+        : "" + round(ans, 2)).replace(".", ",")}\\%`;
+    const cm = round(1 + (identifiers.isUp ? identifiers.randPercent / 100 : -randPercent / 100), 4);
+    const recipCm = round(1 / cm, 4);
+    return `Le coefficient multiplicateur correspondant à une ${isUp ? "hausse" : "baisse"} de $${randPercent}\\%$ est :
+    
+$$
+1${isUp ? "+" : "-"}\\frac{${randPercent}}{100} = ${cm.frenchify()}
+$$
+
+Le coefficient multiplicateur réciproque est l'inverse du coefficient multiplicateur : 
+
+$$
+\\frac{1}{${cm.frenchify()}} = ${recipCm.frenchify()}
+$$
+
+On transforme ce coefficient multiplicateur en taux d'évolution : 
+
+$$
+(${recipCm.frenchify()}-1)\\times 100 = ${round(ans, 2).frenchify()}\\%
+$$
+
+Ainsi, le taux d'évolution permettant de revenir au prix initial est de $${answer}$.
+    `;
+};
+const getHint = (identifiers) => {
+    const { isUp, randPercent } = identifiers;
+    return `Calcule le coefficient multiplicateur associé à une ${isUp ? "hausse" : "baisse"} de $${randPercent}\\%$. Puis calcule le coefficient multiplicateur réciproque : c'est l'inverse du coefficient multiplicateur. Il ne reste alors plus qu'à transformer le coefficient multiplicateur réciproque en taux d'évolution.`;
+};
+const getInstruction = (identifiers) => {
+    const { isUp, randPercent } = identifiers;
+    let instruction = `Le prix d'un article subit une ${isUp ? "hausse" : "baisse"} de $${randPercent}\\%$. Quelle évolution devra-t-il subir pour revenir à son prix initial ? Arrondir au centième de pourcentage.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { isUp, randPercent } = identifiers;
+    let ans = 0;
+    ans = isUp
+        ? (1 / (1 + randPercent / 100) - 1) * 100
+        : (1 / (1 - randPercent / 100) - 1) * 100;
+    const answer = `${(ans > 0
+        ? "+" + round(ans, 2)
+        : "" + round(ans, 2)).replace(".", ",")}\\%`;
+    return answer;
+};
+const getReciprocalPercentageQuestion = () => {
+    const randPercent = randint(1, 50);
+    const isUp = coinFlip();
+    const identifiers = { isUp, randPercent };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        let wrongAnswer = Number(answer.replace(",", ".").replace("+", "").replace(`\\%`, ""));
+        const deviation = Math.random() < 0.5 ? -1 : 1;
+        const percentDeviation = Math.random() * 20 + 1;
+        wrongAnswer += deviation * percentDeviation;
+        wrongAnswer = round(wrongAnswer, 2);
+        tryToAddWrongProp(propositions, `${(wrongAnswer > 0 ? "+" + wrongAnswer : "" + wrongAnswer).replace(".", ",")} \\%`);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = percentParser(ans);
+    return parsed === answer.replace("+", "");
+};
+export const reciprocalPercentage = {
+    id: "reciprocalPercentage",
+    connector: "=",
+    label: "Calculer un taux d'évolution réciproque",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getReciprocalPercentageQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/percent/findEndValueAfterEvolution.js

@@ -28,7 +28,7 @@ const getInstruction = (identifiers) => {
     return `Le prix initial d'un objet est $${identifiers.vd.frenchify()}€$. Quel sera son prix après une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$ ? Arrondir au centième.`;
 };
 const getHint = (identifiers) => {
-    return `Transforme le taux d'évolution en coefficient multiplicateur. Puis, multiplie le prix initial par ce coefficient multiplicateur.`;
+    return `Transforme le taux d'évolution en coefficient multiplicateur. Puis multiplie le prix initial par ce coefficient multiplicateur.`;
 };
 const getCorrection = (identifiers) => {
     const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";

package/lib/exercises/math/percent/findProportion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA0EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAoBhD,CAAC"}
+{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}