math-exercises 3.0.214 → 3.0.216

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"findLeftInHugeNumberDivision.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/findLeftInHugeNumberDivision.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAqMF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}

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

@@ -0,0 +1,194 @@
+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 { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.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, mod }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(0, mod).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, mod, n } = identifiers;
+    const aMod = a % mod;
+    let cycle = 1;
+    let currentMod = aMod;
+    let cycleFound = false;
+    while (!cycleFound) {
+        cycle++;
+        currentMod = (currentMod * aMod) % mod;
+        if (currentMod === 1)
+            cycleFound = true;
+    }
+    const left = n % cycle;
+    currentMod = aMod;
+    for (let i = 1; i < left; i++) {
+        currentMod = (currentMod * aMod) % mod;
+    }
+    return currentMod.frenchify();
+    //a^cycle = 1 [mod]
+};
+const getInstruction = (identifiers) => {
+    const { a, mod, n } = identifiers;
+    return `Déterminer le reste de la division euclidienne de $${power(a, n).toTex()}$ par $${mod}$.`;
+};
+const getHint = (identifiers) => {
+    const { a, mod, n } = identifiers;
+    return `Calcule d'abord $${a} \\pmod ${mod}$. 
+  
+Puis, par calculs successifs, détermine un nombre $n$ tel que $${a ^ n}\\equiv 1\\ [${mod}]$.
+  
+Cela permettra de simplifier le calcul.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, mod, n } = identifiers;
+    const aMod = a % mod;
+    let cycle = 1;
+    let currentMod = aMod;
+    let cycleFound = false;
+    const powers = [];
+    while (!cycleFound) {
+        cycle++;
+        currentMod = (currentMod * aMod) % mod;
+        powers.push([
+            `${power(aMod, cycle).toTex()}`,
+            "\\equiv",
+            `${currentMod} \\ [${mod}]`,
+        ]);
+        if (currentMod === 1)
+            cycleFound = true;
+    }
+    const left = n % cycle;
+    currentMod = aMod;
+    for (let i = 1; i < left; i++) {
+        currentMod = (currentMod * aMod) % mod;
+    }
+    const answer = currentMod.frenchify();
+    const quot = Math.floor(n / cycle);
+    //a^cycle = 1 [mod]
+    return `On commence par déterminer le reste de la division euclidienne de $${a}$ par $${mod}$ : 
+  
+$$
+${a} \\equiv ${aMod} \\ [${mod}]
+$$
+
+Ainsi,
+
+$$
+${power(a, n).toTex()} \\equiv ${power(aMod, n).toTex()} \\ [${mod}]
+$$
+
+Puis, on calcule les puissances successives de $${aMod}$ modulo $${mod}$ :
+
+${alignTex(powers)}
+
+On effectue alors la division euclidienne de $${n}$ par $${cycle}$ :
+
+$$
+${n} = ${cycle}\\times ${quot} + ${left}
+$$
+
+Alors :
+
+$$
+${power(aMod, n).toTex()} = ${multiply(power(power(aMod, cycle), quot), power(aMod, left)).toTex()}
+$$
+
+Et donc, modulo $${mod}$ :
+
+$$
+${power(aMod, n).toTex()} \\equiv 1^{${quot}} \\times ${power(aMod, left).toTex()} \\equiv ${power(aMod, left).toTex()} \\ [${mod}]
+$$
+
+d'où, finalement : 
+
+$$
+${power(a, n).toTex()}\\equiv ${answer} \\ [${mod}]
+$$
+
+Le reste de la division euclidienne de $${power(a, n).toTex()}$ par $${mod}$ est donc $${answer}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindLeftInHugeNumberDivisionQuestion = () => {
+    let a = 0;
+    let mod = 0;
+    let found = false;
+    let counter = 0;
+    let n = 0;
+    do {
+        let cycle = 1;
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in getFindLeftInHugeNumberDivisionQuestion");
+        mod = randint(5, 20);
+        a = randint(mod + 5, mod + 100);
+        n = doWhile(() => randint(100, 1000), (x) => x % mod === 0);
+        const aMod = a % mod;
+        if (aMod === 0 || aMod === 1 || aMod === mod - 1)
+            continue;
+        let currentMod = a % mod;
+        for (let i = 0; i < 5; i++) {
+            if (currentMod === 1) {
+                if (n % cycle === 0)
+                    break;
+                found = true;
+                break;
+            }
+            cycle++;
+            currentMod = (currentMod * aMod) % mod;
+        }
+    } while (!found);
+    const identifiers = {
+        a,
+        mod,
+        n,
+    };
+    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 findLeftInHugeNumberDivision = {
+    id: "findLeftInHugeNumberDivision",
+    connector: "=",
+    label: "Calculer le reste de la division euclidienne de $a^n$ par $b$, pour des grandes valeurs de $a$ et $n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindLeftInHugeNumberDivisionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"findMissingNumberToMakeNumberDivisibleBy9.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/findMissingNumberToMakeNumberDivisibleBy9.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAgHF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAuBzE,CAAC"}

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

@@ -0,0 +1,121 @@
+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 { randTupleInt } from "../../../math/utils/random/randTupleInt.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(0, 100).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { numbers } = identifiers;
+    const quotient = 9;
+    const sum = numbers.reduce((acc, curr) => acc + curr, 0);
+    const modulo = (sum + quotient) % quotient;
+    const missing = quotient - modulo;
+    return missing.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { numbers, missingIndex } = identifiers;
+    const trueNb = [
+        ...numbers.slice(0, missingIndex).map((e) => e + ""),
+        "a",
+        ...numbers.slice(missingIndex).map((e) => e + ""),
+    ];
+    return `On considère un nombre qui a pour écriture décimale : 
+  
+$$
+${trueNb.join("")}
+$$
+
+Déterminer la valeur de $a$ pour que ce nombre soit divisible par $9$.`;
+};
+const getHint = () => {
+    return `Un nombre entier est divisible par $9$ si la somme de ses chiffres est divisible par $9$.`;
+};
+const getCorrection = (identifiers) => {
+    const { numbers, missingIndex } = identifiers;
+    const quotient = 9;
+    const sum = numbers.reduce((acc, curr) => acc + curr, 0);
+    const modulo = (sum + quotient) % quotient;
+    const missing = quotient - modulo;
+    const trueNb = [
+        ...numbers.slice(0, missingIndex).map((e) => e + ""),
+        missing.frenchify(),
+        ...numbers.slice(missingIndex).map((e) => e + ""),
+    ];
+    return `Un nombre entier est divisible par $9$ si la somme de ses chiffres est divisible par $9$.
+  
+La somme des chiffres connus du nombre proposé est : 
+
+$$
+${numbers.join("+")}=${sum}
+$$
+
+Le reste de la division euclidienne de $${sum}$ par $9$ est $${modulo}$.
+
+Pour obtenir un multiple de $9$, il suffit donc d'ajouter $${missing}$ à cette somme.
+
+Le nombre recherché est donc : 
+
+$$
+${trueNb.join("")}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindMissingNumberToMakeNumberDivisibleByXQuestion = () => {
+    const numbers = doWhile(() => randTupleInt(randint(4, 8), {
+        from: 1,
+        to: 10,
+    }), (arr) => arr.reduce((acc, curr) => acc + curr, 0) % 9 === 0);
+    const identifiers = {
+        numbers,
+        missingIndex: randint(0, numbers.length),
+    };
+    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 findMissingNumberToMakeNumberDivisibleBy9 = {
+    id: "findMissingNumberToMakeNumberDivisibleBy9",
+    connector: "=",
+    label: "Déterminer la valeur de $a$ pour que le nombre $xxaxx$ soit divisible par $9$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindMissingNumberToMakeNumberDivisibleByXQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -7,4 +7,11 @@ export * from "./diophantianEquationSimpleSolution.js";
 export * from "./pgcdHomogenuity.js";
 export * from "./pgcdFromPrimeDecomposition.js";
 export * from "./fermatUsageOnBigPowers.js";
+export * from "./whichDayInXDays.js";
+export * from "./findMissingNumberToMakeNumberDivisibleBy9.js";
+export * from "./findLeftInHugeNumberDivision.js";
+export * from "./pgcdFromEuclid.js";
+export * from "./isBigNumberPrime.js";
+export * from "./solveDiophantianEquationByUsingPrimality.js";
+export * from "./numberOfEndingZerosOfBigProduct.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;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"}
+{"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;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,gDAAgD,CAAC;AAC/D,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,sCAAsC,CAAC"}

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

@@ -7,3 +7,10 @@ export * from "./diophantianEquationSimpleSolution.js";
 export * from "./pgcdHomogenuity.js";
 export * from "./pgcdFromPrimeDecomposition.js";
 export * from "./fermatUsageOnBigPowers.js";
+export * from "./whichDayInXDays.js";
+export * from "./findMissingNumberToMakeNumberDivisibleBy9.js";
+export * from "./findLeftInHugeNumberDivision.js";
+export * from "./pgcdFromEuclid.js";
+export * from "./isBigNumberPrime.js";
+export * from "./solveDiophantianEquationByUsingPrimality.js";
+export * from "./numberOfEndingZerosOfBigProduct.js";

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

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

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

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

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

@@ -0,0 +1,107 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../math/numbers/integer/primes.js";
+import { isPrime } from "../../../math/utils/arithmetic/isPrime.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { sqrt } from "../../../tree/nodes/functions/sqrtNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a } = identifiers;
+    return isPrime(a) ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { a } = identifiers;
+    return `$${a}$ est-il un nombre premier ?`;
+};
+const getHint = () => {
+    return `Utilise le test de primalité : si $n$ n'est divisible par aucun nombre premier inférieur ou égal à $\\sqrt{n}$, alors $n$ est premier.`;
+};
+const getCorrection = (identifiers) => {
+    const { a } = identifiers;
+    const nextSquare = (Math.floor(Math.sqrt(a)) + 1) ** 2;
+    const squareRootFloor = Math.floor(Math.sqrt(a));
+    const primesToTest = primes.filter((p) => p > 5 && p <= squareRootFloor);
+    const isPremier = isPrime(a);
+    const divisor = primesToTest.find((p) => a % p === 0);
+    return `On a $${a}<${nextSquare}$ et $${sqrt(nextSquare).toSimplificationTex()}$, donc :
+  
+$$
+${sqrt(a).toTex()}\\leq ${squareRootFloor}
+$$
+
+On teste donc la divisibilité de $${a}$ par tous les entiers premiers inférieurs ou égaux à $${squareRootFloor}$.
+
+$${a}$ n'est pas divisible par $2$, $3$ et $5$ d'après les critères de divisibilité.
+
+${isPremier
+        ? `On effectue les divisions euclidiennes par les nombres premiers restants :
+  
+${alignTex(primesToTest.map((p) => [
+            a.frenchify(),
+            "=",
+            `${p}\\times ${Math.floor(a / p).frenchify()}+ ${(a % p).frenchify()}`,
+        ]))}
+
+$${a}$ n'est donc divisible par aucun nombre premier inférieur ou égal à sa racine carrée : c'est un nombre premier.`
+        : `On trouve cependant en effectuant des divisions euclidiennes : 
+  
+$$
+${a} = ${divisor}\\times ${Math.floor(a / divisor)} + 0
+$$
+
+$${a}$ est donc divisible par $${divisor}$, donc il n'est pas premier.`}
+ 
+`;
+};
+const getIsBigNumberPrimeQuestion = () => {
+    //a n'est pas un carré, ni divisible par 2, 3, 5,
+    //la racine doit etre strictement supérieur à 11 pour tester au moins 7 et 11
+    const generatePrime = coinFlip();
+    const a = doWhile(() => randint(127, 400), (x) => x % 2 === 0 ||
+        x % 3 === 0 ||
+        x % 5 === 0 ||
+        Math.sqrt(x) === Math.floor(Math.sqrt(x)) ||
+        (generatePrime && !isPrime(x)) ||
+        (!generatePrime && isPrime(x)));
+    const identifiers = { a };
+    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 isBigNumberPrime = {
+    id: "isBigNumberPrime",
+    connector: "=",
+    label: "Déterminer si un nombre (relativement grand) est premier",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsBigNumberPrimeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"numberOfEndingZerosOfBigProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/numberOfEndingZerosOfBigProduct.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;CACX,CAAC;AA2IF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAsBjE,CAAC"}

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

@@ -0,0 +1,139 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { primeDecompNode } from "../../../math/utils/arithmetic/primeDecompNode.js";
+import { primeDecomposition } from "../../../math/utils/arithmetic/primeDecomposition.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 { 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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(0, 8).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const aDecomp = primeDecomposition(a);
+    const bDecomp = primeDecomposition(b);
+    const twoPower = (aDecomp.find((el) => el.value === 2)?.power ?? 0) +
+        (bDecomp.find((el) => el.value === 2)?.power ?? 0);
+    const fivePower = (aDecomp.find((el) => el.value === 5)?.power ?? 0) +
+        (bDecomp.find((el) => el.value === 5)?.power ?? 0);
+    const commonPower = Math.min(twoPower, fivePower);
+    return commonPower.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Après avoir écrit la décomposition en facteurs premiers de chaque facteur, déterminer combien de zéros terminent l'écriture décimale du produit : 
+  
+$$
+${a}\\times ${b}
+$$`;
+};
+const getHint = () => {
+    return `L'écriture décimale d'un nombre se termine par $n$ zéros si et seulement si ce nombre est divisible par $10^n$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const aDecomp = primeDecomposition(a);
+    const bDecomp = primeDecomposition(b);
+    const twoPower = (aDecomp.find((el) => el.value === 2)?.power ?? 0) +
+        (bDecomp.find((el) => el.value === 2)?.power ?? 0);
+    const fivePower = (aDecomp.find((el) => el.value === 5)?.power ?? 0) +
+        (bDecomp.find((el) => el.value === 5)?.power ?? 0);
+    const commonPower = Math.min(twoPower, fivePower);
+    return `On écrit la décomposition en facteurs premiers de chaque facteur du produit : 
+  
+$$
+${a} = ${primeDecompNode(a).toTex()}
+$$
+
+$$
+${b} = ${primeDecompNode(b).toTex()}
+$$
+
+Le produit de ces deux nombres est donc divisible par $2^{${twoPower}}$ et par $5^{${fivePower}}$, donc il est divisible par $(2\\times 5)^{${commonPower}} = 10^{${commonPower}}$.
+
+L'écriture décimle de ce produit se terminent donc par $${commonPower}$ zéro(s).
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getNumberOfEndingZerosOfBigProductQuestion = () => {
+    const primes = [2, 3, 5, 7];
+    let a = 0;
+    let b = 0;
+    let answer = "";
+    do {
+        const aPrimes = randomMany(primes, randint(2, 4)).sort((a, b) => a - b);
+        const bPrimes = doWhile(() => randomMany(primes, randint(2, 4)), (list) => list.every((p) => !aPrimes.includes(p))).sort((a, b) => a - b);
+        const aPowers = randTupleInt(aPrimes.length, {
+            from: 1,
+            to: 5,
+        });
+        const bPowers = randTupleInt(bPrimes.length, {
+            from: 1,
+            to: 5,
+            excludes: [aPowers],
+        });
+        a = operatorComposition(MultiplyNode, aPrimes.map((p, i) => power(p, aPowers[i]))).evaluate();
+        b = operatorComposition(MultiplyNode, bPrimes.map((p, i) => power(p, bPowers[i]))).evaluate();
+        answer = getAnswer({ a, b });
+    } while (isNaN(a) ||
+        isNaN(b) ||
+        a < 1000 ||
+        b < 1000 ||
+        answer.unfrenchify() < 1);
+    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 numberOfEndingZerosOfBigProduct = {
+    id: "numberOfEndingZerosOfBigProduct",
+    connector: "=",
+    label: "Déterminer le nombre de zéros terminant l'écriture décimale d'un produit de grands nombres",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getNumberOfEndingZerosOfBigProductQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

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