math-exercises 2.0.11 → 2.0.13

package/lib/exercises/combinatory/anagrams.js

@@ -1,161 +1,161 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.anagrams = void 0;
-const exercise_1 = require("../../exercises/exercise");
-const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
-const randint_1 = require("../../math/utils/random/randint");
-const random_1 = require("../../utils/random");
-const words = [
-    "angle",
-    "armoire",
-    "banc",
-    "bureau",
-    "cabinet",
-    "carreau",
-    "chaise",
-    "classe",
-    "clé",
-    "coin",
-    "couloir",
-    "dossier",
-    "eau",
-    "école",
-    "écriture",
-    "entrée",
-    "escalier",
-    "étagère",
-    "étude",
-    "extérieur",
-    "fenêtre",
-    "intérieur",
-    "lavabo",
-    "lecture",
-    "lit",
-    "marche",
-    "matelas",
-    "maternelle",
-    "meuble",
-    "mousse",
-    "mur",
-    "peluche",
-    "placard",
-    "plafond",
-    "porte",
-    "portemanteau",
-    "poubelle",
-    "radiateur",
-    "rampe",
-    "récréation",
-    "rentrée",
-    "rideau",
-    "robinet",
-    "salle",
-    "savon",
-    "serrure",
-    "serviette",
-    "siège",
-    "sieste",
-    "silence",
-    "sol",
-    "sommeil",
-    "sonnette",
-    "sortie",
-    "table",
-    "tableau",
-    "tabouret",
-    "tapis",
-    "tiroir",
-    "toilette",
-    "vitre",
-];
-const letters = [
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "é",
-    "è",
-    "à",
-    "ç",
-];
-const getAnagramsQuestion = () => {
-    const word = (0, random_1.random)(words);
-    const repeats = [];
-    const wordLetters = word.split("");
-    letters.forEach((letter) => {
-        const nbOfRepeats = wordLetters.filter((l) => l === letter).length;
-        if (nbOfRepeats > 1)
-            repeats.push(nbOfRepeats);
-    });
-    const getFacto = (n) => {
-        if (n === 1)
-            return 1;
-        return n * getFacto(n - 1);
-    };
-    const facto = word
-        .split("")
-        .map((el, index) => index + 1)
-        .reduce((acc, curr) => acc * curr, 1);
-    let arrangements = 1;
-    repeats.forEach((nbOfRepeats) => {
-        arrangements *= getFacto(nbOfRepeats);
-    });
-    const answer = facto / arrangements + "";
-    const question = {
-        answer,
-        instruction: `Combien d'anagrammes mathématiques du mot ${word} sont possibles ? `,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { word },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, word }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    (0, exercise_1.tryToAddWrongProp)(propositions, Math.pow(word.length, word.length) + "");
-    (0, exercise_1.tryToAddWrongProp)(propositions, (word.length * (word.length + 1)) / 2 + "");
-    (0, exercise_1.tryToAddWrongProp)(propositions, word.length * word.length + "");
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(1000, 10000) + "");
-    }
-    return (0, exercise_1.shuffleProps)(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-exports.anagrams = {
-    id: "anagrams",
-    connector: "=",
-    label: "Compter le nombre d'anagrammes d'un mot",
-    levels: ["TermSpé"],
-    isSingleStep: true,
-    sections: ["Combinatoire et dénombrement"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAnagramsQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anagrams = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const random_1 = require("../../utils/random");
+const words = [
+    "angle",
+    "armoire",
+    "banc",
+    "bureau",
+    "cabinet",
+    "carreau",
+    "chaise",
+    "classe",
+    "clé",
+    "coin",
+    "couloir",
+    "dossier",
+    "eau",
+    "école",
+    "écriture",
+    "entrée",
+    "escalier",
+    "étagère",
+    "étude",
+    "extérieur",
+    "fenêtre",
+    "intérieur",
+    "lavabo",
+    "lecture",
+    "lit",
+    "marche",
+    "matelas",
+    "maternelle",
+    "meuble",
+    "mousse",
+    "mur",
+    "peluche",
+    "placard",
+    "plafond",
+    "porte",
+    "portemanteau",
+    "poubelle",
+    "radiateur",
+    "rampe",
+    "récréation",
+    "rentrée",
+    "rideau",
+    "robinet",
+    "salle",
+    "savon",
+    "serrure",
+    "serviette",
+    "siège",
+    "sieste",
+    "silence",
+    "sol",
+    "sommeil",
+    "sonnette",
+    "sortie",
+    "table",
+    "tableau",
+    "tabouret",
+    "tapis",
+    "tiroir",
+    "toilette",
+    "vitre",
+];
+const letters = [
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "é",
+    "è",
+    "à",
+    "ç",
+];
+const getAnagramsQuestion = () => {
+    const word = (0, random_1.random)(words);
+    const repeats = [];
+    const wordLetters = word.split("");
+    letters.forEach((letter) => {
+        const nbOfRepeats = wordLetters.filter((l) => l === letter).length;
+        if (nbOfRepeats > 1)
+            repeats.push(nbOfRepeats);
+    });
+    const getFacto = (n) => {
+        if (n === 1)
+            return 1;
+        return n * getFacto(n - 1);
+    };
+    const facto = word
+        .split("")
+        .map((el, index) => index + 1)
+        .reduce((acc, curr) => acc * curr, 1);
+    let arrangements = 1;
+    repeats.forEach((nbOfRepeats) => {
+        arrangements *= getFacto(nbOfRepeats);
+    });
+    const answer = facto / arrangements + "";
+    const question = {
+        answer,
+        instruction: `Combien d'anagrammes mathématiques du mot ${word} sont possibles ? `,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { word },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, word }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, Math.pow(word.length, word.length) + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, (word.length * (word.length + 1)) / 2 + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, word.length * word.length + "");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(1000, 10000) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.anagrams = {
+    id: "anagrams",
+    connector: "=",
+    label: "Compter le nombre d'anagrammes d'un mot",
+    levels: ["TermSpé"],
+    isSingleStep: true,
+    sections: ["Combinatoire et dénombrement"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAnagramsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/combinatory/ballsCounting.d.ts

@@ -1,10 +1,10 @@
-import { MathExercise } from "../../exercises/exercise";
-type Identifiers = {
-    type: number;
-    reds: number;
-    greens: number;
-    blacks: number;
-};
-export declare const ballsCounting: MathExercise<Identifiers>;
-export {};
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    type: number;
+    reds: number;
+    greens: number;
+    blacks: number;
+};
+export declare const ballsCounting: MathExercise<Identifiers>;
+export {};
 //# sourceMappingURL=ballsCounting.d.ts.map

package/lib/exercises/combinatory/ballsCounting.js

@@ -1,112 +1,112 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ballsCounting = void 0;
-const exercise_1 = require("../../exercises/exercise");
-const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
-const randint_1 = require("../../math/utils/random/randint");
-const getBallsCountingQuestion = () => {
-    const type = (0, randint_1.randint)(0, 6);
-    let instruction = "";
-    let answer = "";
-    const blacks = (0, randint_1.randint)(2, 6);
-    const greens = (0, randint_1.randint)(2, 6);
-    const reds = (0, randint_1.randint)(3, 6);
-    const total = blacks + greens + reds;
-    switch (type) {
-        case 0:
-            instruction = ``;
-            answer = total * (total - 1) * (total - 2) + "";
-            break;
-        case 1:
-            instruction = `comportant trois boules rouges`;
-            answer = reds * (reds - 1) * (reds - 2) + "";
-            break;
-        case 2:
-            instruction = `ne comportant pas de boule noire`;
-            answer = (reds + greens) * (reds + greens - 1) * (reds + greens - 2) + "";
-            break;
-        case 3:
-            instruction = `comportant au moins une boule noire`;
-            answer =
-                total * (total - 1) * (total - 2) -
-                    (reds + greens) * (reds + greens - 1) * (reds + greens - 2) +
-                    "";
-            break;
-        case 4:
-            instruction = `comportant trois boules de trois couleurs différentes`;
-            answer = 6 * (blacks * greens * reds) + "";
-            break;
-        case 5:
-            instruction = `comportant exactement une boule verte et deux boules noires`;
-            answer = 6 * (greens * blacks * (blacks - 1)) + "";
-            break;
-        case 6:
-            instruction = `comportant exactement une boule verte`;
-            answer = 6 * greens * (reds + blacks) * (reds + blacks - 1) + "";
-    }
-    const question = {
-        answer: answer,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ballsCounting = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const getBallsCountingQuestion = () => {
+    const type = (0, randint_1.randint)(0, 6);
+    let instruction = "";
+    let answer = "";
+    const blacks = (0, randint_1.randint)(2, 6);
+    const greens = (0, randint_1.randint)(2, 6);
+    const reds = (0, randint_1.randint)(3, 6);
+    const total = blacks + greens + reds;
+    switch (type) {
+        case 0:
+            instruction = ``;
+            answer = total * (total - 1) * (total - 2) + "";
+            break;
+        case 1:
+            instruction = `comportant trois boules rouges`;
+            answer = reds * (reds - 1) * (reds - 2) + "";
+            break;
+        case 2:
+            instruction = `ne comportant pas de boule noire`;
+            answer = (reds + greens) * (reds + greens - 1) * (reds + greens - 2) + "";
+            break;
+        case 3:
+            instruction = `comportant au moins une boule noire`;
+            answer =
+                total * (total - 1) * (total - 2) -
+                    (reds + greens) * (reds + greens - 1) * (reds + greens - 2) +
+                    "";
+            break;
+        case 4:
+            instruction = `comportant trois boules de trois couleurs différentes`;
+            answer = 6 * (blacks * greens * reds) + "";
+            break;
+        case 5:
+            instruction = `comportant exactement une boule verte et deux boules noires`;
+            answer = 6 * (greens * blacks * (blacks - 1)) + "";
+            break;
+        case 6:
+            instruction = `comportant exactement une boule verte`;
+            answer = 6 * greens * (reds + blacks) * (reds + blacks - 1) + "";
+    }
+    const question = {
+        answer: answer,
         instruction: `Une urne contient ${blacks} boules noires numérotées de 1 à ${blacks}, ${reds} boules rouges numérotées de 1 à ${reds} et ${greens} boules vertes numérotées de 1 à ${greens}.
     On tire successivement et sans remise 3 boules dans l'urne. 
-    Combien de tirages ${instruction} sont possibles ?`,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { type, reds, greens, blacks },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, type, reds, greens, blacks }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const total = reds + greens + blacks;
-    switch (type) {
-        case 0:
-            (0, exercise_1.tryToAddWrongProp)(propositions, total * total * total + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
-            break;
-        case 1:
-            (0, exercise_1.tryToAddWrongProp)(propositions, reds * reds * reds + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 1 + "");
-            break;
-        case 2:
-            (0, exercise_1.tryToAddWrongProp)(propositions, (reds + greens) * (reds + greens) * (reds + greens) + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * blacks * (reds + greens) * (reds + greens - 1) + "");
-            break;
-        case 3:
-            (0, exercise_1.tryToAddWrongProp)(propositions, (reds + greens) * (reds + greens) * (reds + greens) + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 3 * (reds + greens) * (reds + greens - 1) + "");
-            break;
-        case 4:
-            (0, exercise_1.tryToAddWrongProp)(propositions, blacks * greens * reds + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
-            break;
-        case 5:
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * greens * blacks * blacks + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
-            break;
-        case 6:
-            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * (blacks * greens * reds) + "");
-            (0, exercise_1.tryToAddWrongProp)(propositions, greens * (reds + blacks) * (reds + blacks - 1) + "");
-            break;
-    }
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(1, 100) + "");
-    }
-    return (0, exercise_1.shuffleProps)(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-exports.ballsCounting = {
-    id: "ballsCounting",
-    connector: "=",
-    label: "Dénombrement avec des boules",
-    levels: ["TermSpé"],
-    isSingleStep: true,
-    sections: ["Combinatoire et dénombrement"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBallsCountingQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-};
+    Combien de tirages ${instruction} sont possibles ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, reds, greens, blacks },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, type, reds, greens, blacks }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const total = reds + greens + blacks;
+    switch (type) {
+        case 0:
+            (0, exercise_1.tryToAddWrongProp)(propositions, total * total * total + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
+            break;
+        case 1:
+            (0, exercise_1.tryToAddWrongProp)(propositions, reds * reds * reds + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 1 + "");
+            break;
+        case 2:
+            (0, exercise_1.tryToAddWrongProp)(propositions, (reds + greens) * (reds + greens) * (reds + greens) + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * blacks * (reds + greens) * (reds + greens - 1) + "");
+            break;
+        case 3:
+            (0, exercise_1.tryToAddWrongProp)(propositions, (reds + greens) * (reds + greens) * (reds + greens) + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 3 * (reds + greens) * (reds + greens - 1) + "");
+            break;
+        case 4:
+            (0, exercise_1.tryToAddWrongProp)(propositions, blacks * greens * reds + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
+            break;
+        case 5:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * greens * blacks * blacks + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
+            break;
+        case 6:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * (blacks * greens * reds) + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, greens * (reds + blacks) * (reds + blacks - 1) + "");
+            break;
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(1, 100) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.ballsCounting = {
+    id: "ballsCounting",
+    connector: "=",
+    label: "Dénombrement avec des boules",
+    levels: ["TermSpé"],
+    isSingleStep: true,
+    sections: ["Combinatoire et dénombrement"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBallsCountingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/combinatory/diceCounting.d.ts

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