math-exercises 3.0.209 → 3.0.212

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"congruenceBasicEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/congruenceBasicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA6GF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

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

@@ -0,0 +1,116 @@
+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 { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, mod } = identifiers;
+    const r = (b - a) % mod;
+    tryToAddWrongProp(propositions, r.frenchify());
+    propWhile(propositions, n, () => {
+        const fakeR = doWhile(() => randint(-10, 10), (x) => (x - r) % mod === 0);
+        tryToAddWrongProp(propositions, add(multiply(mod, "k"), fakeR).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    const r = (b - a) % mod;
+    return add(multiply(mod, "k"), r).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    return `Résoudre l'équation suivante dans $\\mathbb{Z}$ :
+  
+$$
+${add("x", a).toTex()} \\equiv ${b} \\ [${mod}]
+$$
+
+Donner la forme des solutions pour $k\\in \\mathbb{Z}$.`;
+};
+const getHint = () => {
+    return `L'addition est compatible avec la congruence : c'est à dire qu'on peut ajouter ou soustraire un même nombre aux deux membres de l'équation.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    const r = (b - a) % mod;
+    return `Puisque l'addition est compatible avec la congruence, on a :
+  
+${alignTex([
+        ["", `${add("x", a).toTex()} \\equiv ${b} \\ [${mod}]`],
+        ["\\iff", `x \\equiv ${r} \\ [${mod}]`],
+    ])}
+
+Les solutions sont donc de la forme : 
+
+$$
+${add(multiply(mod, "k"), r).toTex()}
+$$
+
+avec $k \\in \\mathbb{Z}$.
+  `;
+};
+const getKeys = () => {
+    return ["k"];
+};
+const isAnswerValid = (ans, { answer, mod }) => {
+    try {
+        const parsed = parseAlgebraic(ans).simplify();
+        const answerNode = parseAlgebraic(answer).simplify();
+        return (substract(parsed, answerNode)
+            .simplify({ towardsDistribute: true })
+            .evaluate() %
+            mod ===
+            0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCongruenceBasicEquationQuestion = () => {
+    const mod = randint(3, 8);
+    const a = randint(1, mod);
+    const b = randint(1, mod, [a]);
+    const identifiers = {
+        a,
+        b,
+        mod,
+    };
+    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 congruenceBasicEquation = {
+    id: "congruenceBasicEquation",
+    connector: "\\iff",
+    label: "Résoudre une équation de congruence du type $x+a \\equiv b \\ [n]$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCongruenceBasicEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"diophantianEquationSimpleSolution.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/diophantianEquationSimpleSolution.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;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA8GF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAsBnE,CAAC"}

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

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../math/geometry/point.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../math/utils/random/randTupleInt.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { pointParser } from "../../../tree/parsers/pointParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const u = randint(-3, 3, [0]);
+        const v = randint(-3, 3, [0]);
+        if (a * u + b * v === c)
+            return;
+        tryToAddWrongProp(propositions, new Point("A", u, v).toCoords());
+    });
+    return shuffleProps(propositions, n);
+};
+const getCoeffs = (identifiers) => {
+    const { a, b, c } = identifiers;
+    //permet d'avoir les valeurs les plus simples en premier
+    for (let u = 1; u < 4; u++) {
+        for (let v = 1; v < 4; v++) {
+            if (a * u + b * v === c)
+                return [u, v];
+            if (a * u - b * v === c)
+                return [u, -v];
+            if (-a * u + b * v === c)
+                return [-u, v];
+            if (-a * u - b * v === c)
+                return [-u, -v];
+        }
+    }
+    throw new Error("No solution");
+};
+const getAnswer = (identifiers) => {
+    const [u, v] = getCoeffs(identifiers);
+    return new Point("A", u, v).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return `Déterminer une solution particulière de l'équation suivante, où $(x;y)\\in \\mathbb{Z}$ : 
+  
+$$
+${add(multiply(a, "x"), multiply(b, "y")).toTex()} = ${c}
+$$
+
+On donnera le couple solution sous la forme $(u;v)$.`;
+};
+const getHint = () => {
+    return `Essaie des couples simples, avec des valeurs pour $x$ et $y$ qui rendent les calculs faciles.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const [u, v] = getCoeffs(identifiers);
+    return `En essayant avec des valeurs simples pour $x$ et $y$, on remarque que : 
+  
+$$
+${add(multiply(a, u), multiply(b, v)).toTex()} = ${c}
+$$
+
+Le couple $(${u};${v})$ est donc une solution particulière de l'équation.`;
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    try {
+        const parsed = pointParser(ans);
+        if (!parsed)
+            return false;
+        const [u, v] = [parsed.x.evaluate(), parsed.y.evaluate()];
+        return a * u + b * v === c;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDiophantianEquationSimpleSolutionQuestion = () => {
+    let a = 0;
+    let b = 0;
+    let c = 10000;
+    //(1, x) / (-1, x) pour x<4
+    //(2, x) pour x <4
+    while (Math.abs(c) > 50) {
+        const [u, v] = randTupleInt(2, {
+            from: -3,
+            to: 4,
+            elExcludes: [0],
+        });
+        a = randint(3, 50);
+        b = randint(-50, 50, [-1, 0, 1]);
+        c = a * u + b * v;
+    }
+    const identifiers = { a, b, c };
+    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 diophantianEquationSimpleSolution = {
+    id: "diophantianEquationSimpleSolution",
+    connector: "\\iff",
+    label: "Trouver une solution particulière simple d'une équation diophantienne $ax+by=c$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDiophantianEquationSimpleSolutionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fermatUsageOnBigPowers.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/fermatUsageOnBigPowers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA2IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

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

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.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 { power } from "../../../tree/nodes/operators/powerNode.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, p }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(0, p).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { p, a, pow } = identifiers;
+    const r = pow % (p - 1);
+    return (a ** r % p).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { p, a, pow } = identifiers;
+    return `Donner le reste dans la division euclidienne de $${power(a, pow).toTex()}$ par $${p}$.`;
+};
+const getHint = () => {
+    return `Utilise le petit théorème de Fermat : si $p$ est un nombre premier ne divisant pas $n$, alors 
+  
+$$
+n^{p-1} \\equiv 1\\ [p]
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { p, a, pow } = identifiers;
+    const q = Math.floor(pow / (p - 1));
+    const r = pow % (p - 1);
+    const finalIsCalculable = a ** r < 100;
+    const answer = getAnswer(identifiers);
+    return `Puisque $${p}$ est un nombre premier et qu'il ne divise pas $${a}$, d'après le petit théorème de Fermat : 
+  
+$$
+${power(a, p - 1).toTex()} \\equiv 1\\ [${p}]
+$$
+
+On écrit la division euclidienne de $${pow}$ par $${p - 1}$ :
+
+$$
+${pow} = ${q}\\times ${p - 1} + ${r}
+$$
+
+On a donc : 
+
+${alignTex([
+        [
+            power(a, pow).toTex(),
+            "\\equiv",
+            power(a, add(multiply(q, p - 1), r)).toTex() + `\\ [${p}]`,
+        ],
+        [
+            "",
+            "\\equiv",
+            multiply(power(power(a, p - 1), q), power(a, r)).toTex() + `\\ [${p}]`,
+        ],
+        ["", "\\equiv", multiply(power("1", q), power(a, r)).toTex() + `\\ [${p}]`],
+        ["", "\\equiv", power(a, r).toTex() + `\\ [${p}]`],
+    ])}
+
+${finalIsCalculable
+        ? `Or, $${power(a, r).toTex()} \\equiv ${power(a, r)
+            .evaluate()
+            .frenchify()} \\equiv ${answer} \\ [${p}]$
+        
+`
+        : `Or, on a : 
+    
+$$
+${power(a, 2).toTex()} \\equiv ${power(a, 2).evaluate().frenchify()}\\equiv  ${power(a, 2).evaluate() % p} \\ [${p}]
+$$
+
+donc 
+
+$$
+${power(a, r).toTex()} \\equiv ${power(a, r).evaluate() % p} \\ [${p}]
+$$`}
+
+Le reste de la division euclidienne de $${power(a, pow).toTex()}$ par $${p}$ est donc $${answer}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFermatUsageOnBigPowersQuestion = () => {
+    const p = random([5, 7, 11, 13]);
+    const pow = random([100, 2026, 2025, 2027, 1000, 1234].filter((e) => e % (p - 1) !== 0));
+    const a = randint(2, p - 1);
+    const identifiers = {
+        a,
+        p,
+        pow,
+    };
+    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 fermatUsageOnBigPowers = {
+    id: "fermatUsageOnBigPowers",
+    label: "Utiliser le petit théorème de Fermat pour calculer le reste d'une division euclidienne",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFermatUsageOnBigPowersQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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

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

@@ -0,0 +1,106 @@
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { valueTableVEA } from "../../../exercises/vea/valueTableVEA.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 { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    const aff = add(multiply(a, "x"), b).toTex();
+    const table = [
+        [`\\text{Si } x\\equiv \\ldots \\ [${mod}]`],
+        [`\\text{alors } ${aff} \\equiv \\ldots \\ [${mod}]`],
+    ];
+    for (let i = 0; i < mod; i++) {
+        table[0].push(i.frenchify());
+        table[1].push(((a * i + b) % mod).frenchify());
+    }
+    return table;
+};
+const getInstruction = () => {
+    return `Remplir le tableau de congruence suivant :
+  
+`;
+};
+const getHint = () => {
+    return `La congruence est compatible avec la multiplication et l'addition.
+
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    const aff = add(multiply(a, "x"), b);
+    const indexes = Array.from({ length: mod }, (_, i) => i);
+    const lines = indexes.map((i) => {
+        const raw = aff.toDetailedEvaluation({ x: i.toTree() }).simplify();
+        const simp = raw.simplify();
+        const modulo = simp.evaluate() % mod;
+        const isNotModuled = simp.toTex() !== modulo.frenchify();
+        return `- Si $x\\equiv ${i} \\ [${mod}]$ alors $${aff.toTex()} \\equiv ${raw.toTex()} \\ [${mod}] ${isNotModuled ? `\\equiv ${modulo} \\ [${mod}]` : ""}$`;
+    });
+    return `La congruence est compatible avec la multiplication et l'addition. On a donc : 
+  
+${lines.join("\n \n")}
+  `;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return valueTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFillCongruenceTableFirstDegreeQuestion = () => {
+    const mod = randint(3, 6);
+    const a = randint(2, mod);
+    const b = randint(-mod + 1, mod, [0]);
+    const identifiers = {
+        a,
+        b,
+        mod,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { a, b, mod } = identifiers;
+    const aff = add(multiply(a, "x"), b).toTex();
+    const table = [
+        [`\\text{Si } x\\equiv \\ldots \\ [${mod}]`],
+        [`\\text{alors } ${aff} \\equiv \\ldots \\ [${mod}]`],
+    ];
+    for (let i = 0; i < mod; i++) {
+        table[0].push(i.frenchify());
+        table[1].push("");
+    }
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: table,
+    };
+};
+export const fillCongruenceTableFirstDegree = {
+    id: "fillCongruenceTableFirstDegree",
+    label: "Remplir le tableau de congruence d'une expression du type $ax+b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFillCongruenceTableFirstDegreeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"findBezoutCoefficients.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/findBezoutCoefficients.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA0KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}