math-exercises 3.0.211 → 3.0.213

package/lib/exercises/math/arithmetic/findBezoutCoefficients.js

@@ -0,0 +1,175 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../math/geometry/point.js";
+import { bezout } from "../../../math/utils/arithmetic/bezout.js";
+import { coprimesOf } from "../../../math/utils/arithmetic/coprimesOf.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { pointParser } from "../../../tree/parsers/pointParser.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const u = randint(-30, 30, [0]);
+        const v = randint(-30, 30, [0]);
+        if (a * u + b * v === 1)
+            return;
+        const tex = new Point("A", u, v).toCoords();
+        tryToAddWrongProp(propositions, tex);
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const [u, v] = bezout(a, b);
+    return new Point("A", u, v).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `À l'aide de l'algorithme d'Euclide, déterminer deux entiers relatifs $u$ et $v$ tels que :
+  
+$$
+${a}u+${b}v=1
+$$
+
+Donner la réponse sous la forme $(u;v)$.`;
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Écris l'algorithme d'Euclide pour la division de $${a}$ par $${b}$, et isole les restes non nuls.
+
+Puis, remonte l'algorithme en partant du dernier reste non nul et en remplaçant les restes obtenus précedemment.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    let dividend = a;
+    let divisor = b;
+    let q = Math.floor(dividend / divisor);
+    let r = a % b;
+    const coeffs = [[dividend, q, divisor, r]];
+    while (r !== 0) {
+        dividend = divisor;
+        divisor = r;
+        q = Math.floor(dividend / divisor);
+        r = dividend % divisor;
+        coeffs.push([dividend, divisor, q, r]);
+    }
+    let oneLine = "";
+    if (coeffs.length === 3) {
+        // 3 lignes :
+        // 1 = b-(1e exp)*q
+        // où q est le quotient pour 1=..
+        oneLine = substract(b, multiply(substract(coeffs[0][0], multiply(coeffs[0][1], coeffs[0][2])), coeffs[1][2])).toTex();
+    }
+    else {
+        // 4 lignes:
+        // 1 = (1ere exp) - (2e)*q2
+        // où q2=quotient dans 1=..
+        // et 2e = b-(1ere)*q1
+        // où q1=quotient dans 2e ligne
+        const firstExp = substract(coeffs[0][0], multiply(coeffs[0][1], coeffs[0][2]));
+        const secondExp = substract(b, multiply(firstExp, coeffs[1][2]));
+        oneLine = substract(firstExp, multiply(secondExp, coeffs[2][2])).toTex();
+    }
+    const [u, v] = bezout(a, b);
+    const answerTex = add(multiply(a, u), multiply(b, v)).toTex();
+    return `On écrit l'algorithme d'Euclide :
+  
+${alignTex(coeffs.map((arr) => [
+        `${arr[0]}`,
+        "=",
+        `${arr[1]} \\times ${arr[2]} + ${arr[3]}`,
+    ]))}
+
+On isole les restes non nuls : 
+
+${alignTex(coeffs
+        .slice(0, coeffs.length - 1)
+        .map((arr) => [
+        `${arr[3]}`,
+        "=",
+        substract(arr[0], multiply(arr[1], arr[2])).toTex(),
+    ]))}
+
+On remonte l'algorithme à partir du dernier reste non nul ($1$), et on remplace les restes par les expressions obtenues ci-dessus. On obtient : 
+
+${alignTex([
+        ["1", "=", oneLine],
+        ["", "=", answerTex],
+    ])}
+
+On en conclut qu'un couple solution est :
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { a, b }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        const [u, v] = [parsed.x.evaluate(), parsed.y.evaluate()];
+        return a * u + b * v === 1;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindBezoutCoefficientsQuestion = () => {
+    let a = 0;
+    let b = 0;
+    let ite = 10;
+    let _u;
+    let _v;
+    //pour un algo d'euclide à 3 ou 4 lignes
+    while (ite > 5 || ite < 4) {
+        a = randint(10, 100);
+        b = random(coprimesOf(a));
+        [_u, _v, ite] = bezout(a, b, 0);
+        console.log(a, b, ite);
+    }
+    const identifiers = {
+        a,
+        b,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findBezoutCoefficients = {
+    id: "findBezoutCoefficients",
+    label: "Calculer les coefficients de Bézout ($au+bv = 1$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindBezoutCoefficientsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/arithmetic/hasDiophantianEquationSolution.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+export declare const hasDiophantianEquationSolution: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=hasDiophantianEquationSolution.d.ts.map

package/lib/exercises/math/arithmetic/hasDiophantianEquationSolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasDiophantianEquationSolution.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/hasDiophantianEquationSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAgGF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}

package/lib/exercises/math/arithmetic/hasDiophantianEquationSolution.js

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { gcd } from "../../../math/utils/arithmetic/gcd.js";
+import { nonCoprimesOf } from "../../../math/utils/arithmetic/nonCoprimesOf.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { doWhile } from "../../../utils/doWhile.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "Oui");
+    tryToAddWrongProp(propositions, "Non");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const pgcd = gcd(a, b);
+    const isMult = Math.floor(c / pgcd) === c / pgcd;
+    return isMult ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return `On considère l'équation $(E)$ suivante :
+  
+$$
+(E): \\ \\ ${add(multiply(a, "x"), multiply(b, "y")).toTex()} = ${c}
+$$
+
+$(E)$ admet-elle au moins une solution ?`;
+};
+const getHint = () => {
+    return `Soient $a$,$b$ et $c$ trois entiers relatifs non nuls. 
+  
+L'équation $ax+by=c$ admet des solutions si et seulement si $c$ est un multiple du PGCD de $a$ et $b$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const pgcd = gcd(a, b);
+    const isMult = Math.floor(c / pgcd) === c / pgcd;
+    return `L'équation $ax+by=c$ admet des solutions si et seulement si $c$ est un multiple du PGCD de $a$ et $b$.
+  
+Ici, on a : 
+
+$$
+\\text{PGCD}(${a};${b}) = ${pgcd}
+$$
+
+${isMult
+        ? `Puisque $${c}$ est un multiple de $${pgcd}$, l'équation $(E)$ admet bien au moins une solution.`
+        : `Puisque $${c}$ n'est pas un multiple de $${pgcd}$, l'équation $(E)$ n'admet pas de solution.`}
+`;
+};
+const getHasDiophantianEquationSolutionQuestion = () => {
+    const hasSol = coinFlip();
+    let a;
+    let b;
+    let c;
+    let pgcd;
+    if (hasSol) {
+        a = randint(5, 50);
+        b = randint(-50, 50, [-1, 0, 1]);
+        pgcd = gcd(a, b);
+        c = pgcd * randint(-10, 10, [0]);
+    }
+    else {
+        a = randint(5, 50);
+        b = random(nonCoprimesOf(a));
+        pgcd = gcd(a, b);
+        c = doWhile(() => randint(-10, 10, [0]), (x) => Math.floor(x / pgcd) === x / pgcd);
+    }
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const hasDiophantianEquationSolution = {
+    id: "hasDiophantianEquationSolution",
+    label: "Déterminer si l'équation diophantienne $ax+by=c$ admet au moins une solution",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHasDiophantianEquationSolutionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1,2 +1,10 @@
 export * from "./congruenceBasicComputation.js";
+export * from "./congruenceBasicEquation.js";
+export * from "./fillCongruenceTableFirstDegree.js";
+export * from "./findBezoutCoefficients.js";
+export * from "./hasDiophantianEquationSolution.js";
+export * from "./diophantianEquationSimpleSolution.js";
+export * from "./pgcdHomogenuity.js";
+export * from "./pgcdFromPrimeDecomposition.js";
+export * from "./fermatUsageOnBigPowers.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qCAAqC,CAAC;AACpD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC"}

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

@@ -1 +1,9 @@
 export * from "./congruenceBasicComputation.js";
+export * from "./congruenceBasicEquation.js";
+export * from "./fillCongruenceTableFirstDegree.js";
+export * from "./findBezoutCoefficients.js";
+export * from "./hasDiophantianEquationSolution.js";
+export * from "./diophantianEquationSimpleSolution.js";
+export * from "./pgcdHomogenuity.js";
+export * from "./pgcdFromPrimeDecomposition.js";
+export * from "./fermatUsageOnBigPowers.js";

package/lib/exercises/math/arithmetic/pgcdFromPrimeDecomposition.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    aPrimes: number[];
+    aPowers: number[];
+    bPrimes: number[];
+    bPowers: number[];
+};
+export declare const pgcdFromPrimeDecomposition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pgcdFromPrimeDecomposition.d.ts.map

package/lib/exercises/math/arithmetic/pgcdFromPrimeDecomposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcdFromPrimeDecomposition.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/pgcdFromPrimeDecomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAsJF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

package/lib/exercises/math/arithmetic/pgcdFromPrimeDecomposition.js

@@ -0,0 +1,136 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../math/utils/random/randTupleInt.js";
+import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { aPrimes, aPowers, bPrimes, bPowers } = identifiers;
+    const commonPrimes = aPrimes.filter((p) => bPrimes.includes(p));
+    const maxPowers = [];
+    commonPrimes.forEach((p) => {
+        const aIndex = aPrimes.indexOf(p);
+        const bIndex = bPrimes.indexOf(p);
+        maxPowers.push(Math.max(aPowers[aIndex], bPowers[bIndex]));
+    });
+    tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, commonPrimes.map((p, i) => power(p, maxPowers[i]))).toTex({ hidePowerOfOne: true }));
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, commonPrimes.map((p) => power(p, randint(1, 5)))).toTex({ hidePowerOfOne: true }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aPrimes, aPowers, bPrimes, bPowers } = identifiers;
+    const commonPrimes = aPrimes.filter((p) => bPrimes.includes(p));
+    const minPowers = [];
+    commonPrimes.forEach((p) => {
+        const aIndex = aPrimes.indexOf(p);
+        const bIndex = bPrimes.indexOf(p);
+        minPowers.push(Math.min(aPowers[aIndex], bPowers[bIndex]));
+    });
+    return operatorComposition(MultiplyNode, commonPrimes.map((p, i) => power(p, minPowers[i]))).toTex({ hidePowerOfOne: true });
+};
+const getInstruction = (identifiers) => {
+    const { aPrimes, aPowers, bPrimes, bPowers } = identifiers;
+    return `On considère les nombres $a$ et $b$ suivants : 
+  
+$$
+a = ${operatorComposition(MultiplyNode, aPrimes.map((p, i) => power(p, aPowers[i]))).toTex({ hidePowerOfOne: true })}
+$$
+
+$$
+b = ${operatorComposition(MultiplyNode, bPrimes.map((p, i) => power(p, bPowers[i]))).toTex({ hidePowerOfOne: true })}
+$$
+
+Déterminer le PGCD de $a$ et $b$.
+
+On pourra donner la réponse sous forme non calculée.`;
+};
+const getHint = () => {
+    return `Repère les facteurs premiers communs à $a$ et $b$, et prend leurs plus petit exposant.`;
+};
+const getCorrection = (identifiers) => {
+    return `On repère les facteurs premiers communs à $a$ et $b$, et on prend leurs plus petit exposant :
+  
+$$
+${getAnswer(identifiers)}
+$$
+
+Ce nombre divise bien $a$ et $b$, et c'est bien le plus grand.
+
+C'est donc le PGCD de $a$ et $b$.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (parsed.simplify().toTex() === answer)
+            return true;
+        if (parsed.simplify({ calculatePowers: true }).toTex() ===
+            parseAlgebraic(answer).simplify({ calculatePowers: true }).toTex())
+            return true;
+        return false;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPgcdFromPrimeDecompositionQuestion = () => {
+    const primes = [2, 3, 5, 7, 11, 13];
+    const aPrimes = randomMany(primes, randint(3, 6)).sort((a, b) => a - b);
+    const bPrimes = doWhile(() => randomMany(primes, randint(3, 6)), (list) => list.every((p) => !aPrimes.includes(p))).sort((a, b) => a - b);
+    const aPowers = randTupleInt(aPrimes.length, {
+        from: 1,
+        to: 7,
+    });
+    const bPowers = randTupleInt(bPrimes.length, {
+        from: 1,
+        to: 7,
+        excludes: [aPowers],
+    });
+    const identifiers = {
+        aPrimes,
+        bPrimes,
+        aPowers,
+        bPowers,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pgcdFromPrimeDecomposition = {
+    id: "pgcdFromPrimeDecomposition",
+    connector: "=",
+    label: "Déterminer un PGCD en utilisant la décomposition en produit de facteurs premiers",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPgcdFromPrimeDecompositionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/arithmetic/pgcdHomogenuity.d.ts

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

package/lib/exercises/math/arithmetic/pgcdHomogenuity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgcdHomogenuity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/pgcdHomogenuity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/arithmetic/pgcdHomogenuity.js

@@ -0,0 +1,124 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { gcd } from "../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../math/utils/random/randTupleInt.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(1, 50).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    return gcd(a, b).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `En utilisant l'homogénéité du PGCD, calculer : 
+  
+$$
+\\text{PGCD}(${a} ; ${b})
+$$`;
+};
+const getHint = () => {
+    return `Le PGCD est homogène : c'est à dire que, pour tout entier naturel $k$ non nul, et tous entiers relatifs $a$ et $b$ non nuls, on a 
+  
+$$
+\\text{PGCD}(ka ; kb) = k\\text{PGCD}(a ; b)
+$$
+
+Sers toi de cette propriété pour simplifier le calcul du PGCD demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const absA = Math.abs(a);
+    const absB = Math.abs(b);
+    const pgcd = gcd(absA, absB);
+    const simpA = absA / pgcd;
+    const simpB = absB / pgcd;
+    const lines = [];
+    if (a < 0 || b < 0) {
+        lines.push([
+            `\\text{PGCD}(${a}; ${b})`,
+            "=",
+            `\\text{PGCD}(${absA}; ${absB})`,
+        ]);
+        lines.push(["", "=", `${pgcd}\\times \\text{PGCD}(${simpA}; ${simpB})`]);
+    }
+    else {
+        lines.push([
+            `\\text{PGCD}(${a}; ${b})`,
+            "=",
+            `${pgcd}\\times \\text{PGCD}(${simpA}; ${simpB})`,
+        ]);
+    }
+    return `Puisque le PGCD est homogène, on a : 
+  
+${alignTex(lines)}
+
+Or, $\\text{PGCD}(${simpA}, ${simpB}) = 1$ ; donc :
+
+$$
+\\text{PGCD}(${a}; ${b}) = ${pgcd}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPgcdHomogenuityQuestion = () => {
+    const [u, v] = randTupleInt(2, {
+        from: -10,
+        to: 11,
+        elExcludes: [-1, 0, 1],
+        allDifferent: true,
+    });
+    const k = random([2, 3, 4, 5]) * random([2, 3, 4, 5]);
+    const a = k * u;
+    const b = k * v;
+    const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pgcdHomogenuity = {
+    id: "pgcdHomogenuity",
+    connector: "=",
+    label: "Calculer un PGCD en utilisant son homogénéité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPgcdHomogenuityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ordering/compareFracAndDec.js

@@ -183,10 +183,10 @@ ${isPositive ? `` : `-`}\\frac{${2 * a}}{10} = ${strEv}`;
         },
     ];
     const invalidItems = permute(ascOrderedQuestionParams.map((questionParam) => opts.isUseABC ? questionParam.letter : questionParam.tex))
-        .filter(([D, E, F]) => `{${D}}>{${E}}>{${F}}` !== validItems[0].tex)
+        .filter(([D, E, F]) => `${D}>${E}>${F}` !== validItems[0].tex)
         .map(([D, E, F]) => {
         return {
-            tex: `{${D}}>{${E}}>{${F}}`,
+            tex: `${D}>${E}>${F}`,
             isValidAnswer: false,
         };
     });

package/lib/exercises/math/complex/argumentFromAlgebraicComplex.d.ts

@@ -1,7 +1,10 @@
 import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     arg: number;
     zTex: string;
+    reIds: NodeIdentifiers;
+    imIds: NodeIdentifiers;
 };
 export declare const argumentFromAlgebraicComplex: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/complex/argumentFromAlgebraicComplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"argumentFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/argumentFromAlgebraicComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAgEF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"argumentFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/argumentFromAlgebraicComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAoJF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}