math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.js

@@ -0,0 +1,120 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getInstruction = () => {
+    return `Soit a un nombre non nul. 
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return `$0$ divisé par un nombre non nul donne $0$.
+
+$0$ multiplié par n'importe quel nombre donne $0$.`;
+};
+const getCorrection = () => {
+    return `
+
+$$
+0 \\times a = 0
+$$ 
+
+et  
+
+$$
+\\frac{0}{a} = 0
+$$ 
+
+donc 
+
+$$
+0 \\times a = \\frac{0}{a} = 0
+$$
+
+`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getCompareATimes0Question = () => {
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.5],
+        [2, 0.45],
+        [3, 0.03],
+        [4, 0.02],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const arrayOfTex = [`0 \\times a`, `\\frac{0}{a}`, `0`];
+    const permutations = permute(arrayOfTex);
+    const validItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${[tex1, tex2, tex3].join("=")}$`,
+            `$${tex1}=${tex2}$ et $${tex2}=${tex3}$`,
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: true,
+            };
+        });
+    });
+    const invalidItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${tex1}>${tex2}$ et $${tex2}=${tex3}$`,
+            `$${tex1}=${tex2}$ et $${tex2}>${tex3}$`,
+            ...(tex3 === `\\frac{0}{a}`
+                ? [`$${tex1}=${tex2}$ et $${tex3}$ n'existe pas`]
+                : []),
+            ...(tex1 === `\\frac{0}{a}`
+                ? [`$${tex1}$ n'existe pas et $${tex2}=${tex3}$`]
+                : []),
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: false,
+            };
+        });
+    });
+    const items = shuffle([
+        ...shuffle(validItems).slice(0, nbValid),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ items });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const compareATimes0 = {
+    id: "compareATimes0",
+    label: "Comparer $0$ , $0 \\times a$ et $\\frac{0}{a}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareATimes0Question(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/simplifying/compareFracXA.d.ts

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

package/lib/exercises/math/calculLitteral/simplifying/compareFracXA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareFracXA.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareFracXA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAkFF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/compareFracXA.js

@@ -0,0 +1,67 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Paul a tracé sur sa calculatrice la représentation graphique de $y=${nodes[0].toTex()}$
+et Virginie a tracé sur sa calculatrice la représentation graphique de $y=${nodes[1].leftChild.toTex()} \\times ${nodes[1].rightChild.toTex()}$.
+
+Quelle affirmation est exacte ?`;
+};
+const getHint = () => {
+    return `Compare $\\frac{x}{a}$ et $\\frac{1}{a}\\times x$ avec $a$ différent de $0$.`;
+};
+const getCorrection = () => {
+    return `Pour $a$ différent de $0$, on a 
+  
+$$
+\\frac{x}{a} = \\frac{1}{a}\\times x
+$$
+
+Par conséquent, les deux fonctions sont les mêmes donc les courbes tracées sont les mêmes.`;
+};
+const getPropositions = () => {
+    const propositions = [];
+    addValidProp(propositions, "Les deux courbes tracées sont les mêmes.", "raw");
+    tryToAddWrongProp(propositions, "La courbe de Paul est au dessus de celle de Virginie.", "raw");
+    tryToAddWrongProp(propositions, "La courbe de Paul est en dessous de celle de Virginie.", "raw");
+    tryToAddWrongProp(propositions, "La courbe de Paul est au dessus de celle de Virginie pour $x<0$ puis c'est l’inverse pour $x>0$.", "raw");
+    return propositions;
+};
+const getCompareFracXAQuestion = () => {
+    const a = randint(1, 100);
+    const nodes = [frac("x", a), multiply(frac(1, a), "x")];
+    return getQuestionFromIdentifiers({
+        nodeIds: nodes.map((node) => node.toIdentifiers()),
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareFracXA = {
+    id: "compareFracXA",
+    label: "Tracé des courbes $\\frac{x}{a} = \\frac{1}{a} \\times x$ pour $a$ non nul",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareFracXAQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Item = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type Identifiers = {
+    items: Item[];
+};
+export declare const compareMinusA: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareMinusA.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareMinusA.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareMinusA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAkHF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAe/C,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.js

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getInstruction = () => {
+    return `Soit a un nombre non nul. 
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return "La règle des signes est la même pour une multiplication et pour une division.";
+};
+const getCorrection = () => {
+    return `
+
+$$
+(−1) \\times a = -a
+$$ 
+
+et  
+
+$$
+\\frac{a}{-1} = -a
+$$ 
+
+donc 
+
+$$
+(−1) \\times a = \\frac{a}{-1} = -a
+$$
+
+`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getCompareMinusAQuestion = () => {
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.5],
+        [2, 0.45],
+        [3, 0.03],
+        [4, 0.02],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const arrayOfTex = [`(−1) \\times a`, `\\frac{a}{-1}`, `-a`];
+    const permutations = permute(arrayOfTex);
+    const validItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${[tex1, tex2, tex3].join("=")}$`,
+            `$${tex1}=${tex2}$ et $${tex2}=${tex3}$`,
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: true,
+            };
+        });
+    });
+    const invalidItems = permutations.flatMap(([tex1, tex2, tex3]) => {
+        return [
+            `$${tex1}>${tex2}$ et $${tex2}=${tex3}$`,
+            `$${tex1}<${tex2}$ et $${tex2}=${tex3}$`,
+            `$${tex1}=${tex2}$ et $${tex2}>${tex3}$`,
+            `$${tex1}=${tex2}$ et $${tex2}<${tex3}$`,
+        ].map((tex) => {
+            return {
+                tex,
+                isValidAnswer: false,
+            };
+        });
+    });
+    const items = shuffle([
+        ...shuffle(validItems).slice(0, nbValid),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ items });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const compareMinusA = {
+    id: "compareMinusA",
+    label: "Comparer $(−1) \\times a$ ; $\\frac{a}{-1}$ et $-a$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareMinusAQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/simplifying/index.d.ts

@@ -2,4 +2,9 @@ export * from "./evaluateExpression.js";
 export * from "./reduceExpression.js";
 export * from "./distributeAndSimplify.js";
 export * from "./valuateExpression.js";
+export * from "./pickSameAsAPercentOfB.js";
+export * from "./compareMinusA.js";
+export * from "./pickSameAsInverseOfFracAB.js";
+export * from "./compareATimes0.js";
+export * from "./compareFracXA.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/index.js

@@ -2,3 +2,8 @@ export * from "./evaluateExpression.js";
 export * from "./reduceExpression.js";
 export * from "./distributeAndSimplify.js";
 export * from "./valuateExpression.js";
+export * from "./pickSameAsAPercentOfB.js";
+export * from "./compareMinusA.js";
+export * from "./pickSameAsInverseOfFracAB.js";
+export * from "./compareATimes0.js";
+export * from "./compareFracXA.js";

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsAPercentOfB.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Item = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type Identifiers = {
+    a: number;
+    b: number;
+    items: Item[];
+};
+export declare const pickSameAsAPercentOfB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pickSameAsAPercentOfB.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsAPercentOfB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickSameAsAPercentOfB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/pickSameAsAPercentOfB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AA+IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsAPercentOfB.js

@@ -0,0 +1,125 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Quelles sont la ou les propositions qui sont égales à $${a}\\%$ de $${b}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `$${a}\\%$ signifie  $\\frac{${a}}{100}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Pour calculer $${a}\\%$ de  $${b}$, on calcule $\\frac{${a}}{100}\\times ${b}$.
+
+$$
+\\frac{${a}}{100} \\times ${b} = \\frac{${a} \\times ${b}}{100} = ${a} \\times \\frac{${b}}{100}
+$$
+
+On peut aussi multiplier par $0,01$, au lieu de diviser par $100$.
+
+$$
+\\frac{${a}}{100} \\times ${b} = (${a} \\times 0,01) \\times ${b}
+$$
+
+`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "tex");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "tex");
+        }
+    });
+    return propositions;
+};
+const getPickSameAsAPercentOfBQuestion = () => {
+    const a = randint(0, 100, [0]);
+    const b = random([20, 30, 40, 50, 60, 80, 90, 120, 130, 140, 150]);
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.5],
+        [2, 0.45],
+        [3, 0.03],
+        [4, 0.02],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const validItems = [
+        ...new Set([
+            `\\frac{a}{100} \\times {b}`,
+            `{b} \\times \\frac{a}{100}`,
+            `\\frac{{a} \\times {b}}{100}`,
+            `\\frac{{b} \\times {a}}{100}`,
+            `{a} \\times \\frac{b}{100}`,
+            `\\frac{b}{100} \\times {a}`,
+            `({a} \\times 0,01) \\times {b}`,
+            `({a} \\times {b}) \\times 0,01`,
+            `{a} \\times ({b} \\times 0,01)`,
+        ].map((tex) => tex.replaceAll("{a}", `{${a}}`).replaceAll("{b}", `{${b}}`))).values(),
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: true,
+        };
+    });
+    const invalidItems = [
+        ...new Set([
+            `\\frac{100}{a} \\times {b}`,
+            `{b} \\times \\frac{100}{a}`,
+            `{a} \\times {b} \\times 100`,
+            `{a} \\times 100 \\times {b}`,
+            `{a} \\times \\frac{100}{b}`,
+            `\\frac{100}{b} \\times {a}`,
+            `0,01 \\times {a} \\times {b} \\times 0,01`,
+            `0,01 \\times {a} \\times 0,01 \\times {b}`,
+            `\\frac{a}{100} \\times 0,01 \\times {b}`,
+            `\\frac{0,01 \\times {a} }{b}`,
+            `\\frac{0,01 \\times {b} }{a}`,
+            `\\frac{a}{0,01} \\times {b}`,
+        ].map((tex) => tex.replaceAll("{a}", `{${a}}`).replaceAll("{b}", `{${b}}`))).values(),
+    ].map((tex) => {
+        return {
+            tex,
+            isValidAnswer: false,
+        };
+    });
+    const items = shuffle([
+        ...shuffle(validItems).slice(0, nbValid),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ a, b, items });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const pickSameAsAPercentOfB = {
+    id: "pickSameAsAPercentOfB",
+    label: "Utiliser $\\frac{ab}{c} = a \\times \\frac{b}{c} = \\frac{a}{c} \\times b$ pour calculer des pourcentages",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getPickSameAsAPercentOfBQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsInverseOfFracAB.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Item = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type Identifiers = {
+    a: number;
+    b: number;
+    items: Item[];
+};
+export declare const pickSameAsInverseOfFracAB: Exercise<Identifiers>;
+export declare const pickSameAsInverseOfFrac1A: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pickSameAsInverseOfFracAB.d.ts.map

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsInverseOfFracAB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickSameAsInverseOfFracAB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/pickSameAsInverseOfFracAB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAqJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/pickSameAsInverseOfFracAB.js

@@ -0,0 +1,148 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Parmi ces propositions, laquelle ou lesquelles sont égales à $\\frac{1}{\\frac{${a}}{${b}}}$ ?`;
+};
+const getHint = () => {
+    return "Diviser par un nombre c'est multiplier par son inverse.";
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Ici $1$ est divisé par $\\frac{${a}}{${b}}$.
+  
+Or diviser par un nombre, c'est multiplier par son inverse.
+
+$1$ est donc multiplié par $\\frac{${b}}{${a}}$, 
+
+ce qui donne $\\frac{${b}}{${a}}$${a === 1 ? `, c'est à dire par  $${b}$.` : `.`}`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "tex");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "tex");
+        }
+    });
+    return propositions;
+};
+const getPickSameAsInverseOfFracABQuestion = () => {
+    const p = random(primes);
+    const [a, b] = shuffle([p, randint(0, p, [0])]);
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.5],
+        [2, 0.45],
+        [3, 0.05],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const validItems = [
+        `\\frac{b}{a}`,
+        `{b} \\times \\frac{1}{a}`,
+        `\\frac{1}{a} \\times {b}`,
+    ].map((tex) => {
+        return {
+            tex: tex.replaceAll("{a}", `{${a}}`).replaceAll("{b}", `{${b}}`),
+            isValidAnswer: true,
+        };
+    });
+    const invalidItems = [
+        `\\frac{a}{b}`,
+        `{a} \\times \\frac{1}{b}`,
+        `\\frac{1}{b} \\times {a}`,
+        `\\frac{1}{ {b} \\times {a} } `,
+        `\\frac{1}{ {a} \\times {b} } `,
+        `{a} + {b}`,
+        `{b} + {a}`,
+        `{a} \\times {b}`,
+        `{b} \\times {a}`,
+    ].map((tex) => {
+        return {
+            tex: tex.replaceAll("{a}", `{${a}}`).replaceAll("{b}", `{${b}}`),
+            isValidAnswer: false,
+        };
+    });
+    const items = shuffle([
+        validItems[0],
+        ...shuffle(validItems.slice(1)).slice(0, nbValid - 1),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ a, b, items });
+};
+const getPickSameAsInverseOfFrac1AQuestion = () => {
+    const [a, b] = [1, randint(2, 107)];
+    const nbTotal = 4;
+    const nbValid = probaLawFlip([
+        [1, 0.8],
+        [2, 0.2],
+    ]);
+    const nbInvalid = nbTotal - nbValid;
+    const validItems = [`{b}`, `\\frac{b}{1}`].map((tex) => {
+        return {
+            tex: tex.replaceAll("{b}", `{${b}}`),
+            isValidAnswer: true,
+        };
+    });
+    const invalidItems = [`\\frac{1}{b}`, `{b} + 1`, `1`].map((tex) => {
+        return {
+            tex: tex.replaceAll("{b}", `{${b}}`),
+            isValidAnswer: false,
+        };
+    });
+    const items = shuffle([
+        validItems[0],
+        ...shuffle(validItems.slice(1)).slice(0, nbValid - 1),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({ a, b, items });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const pickSameAsInverseOfFracAB = {
+    id: "pickSameAsInverseOfFracAB",
+    label: "Calculer $\\frac{1}{\\frac{a}{b}}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getPickSameAsInverseOfFracABQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};
+export const pickSameAsInverseOfFrac1A = {
+    id: "pickSameAsInverseOfFrac1A",
+    label: "Calculer $\\frac{1}{\\frac{1}{a}}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getPickSameAsInverseOfFrac1AQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    hasHintAndCorrection: true,
+};