math-exercises 2.0.44 → 2.1.1

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicNiceValuesSystemResolution = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const system_1 = require("../../../../math/systems/system");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+//{ a1x + b1y = c1 , a2x + b2y = c2}
+const getBasicNiceValuesSystemResolutionQuestion = () => {
+    //need a1/b1 != a2/b2
+    const sys = system_1.SystemConstructor.niceValues();
+    const { x, y } = sys.solve();
+    const isXAsked = (0, coinFlip_1.coinFlip)();
+    const variable = isXAsked ? "x" : "y";
+    const answer = isXAsked ? x.toTex() : y.toTex();
+    const question = {
+        answer,
+        instruction: `Soit le système d'équations suivant :
+  
+  $${sys.toTex()}$
+  
+  Que vaut $${variable}$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { coeffs: sys.coeffs, isXAsked },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs, isXAsked }) => {
+    const propositions = [];
+    const sys = new system_1.System(coeffs);
+    const { x, y } = sys.solve();
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, isXAsked ? y.toTex() : x.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 11) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, coeffs, isXAsked }) => {
+    return ans === answer;
+};
+exports.basicNiceValuesSystemResolution = {
+    id: "basicNiceValuesSystemResolution",
+    connector: "=",
+    label: "Résoudre un système d'équations (solutions entières)",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Systèmes"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBasicNiceValuesSystemResolutionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.d.ts

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

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA0DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicSystemResolution = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const system_1 = require("../../../../math/systems/system");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+//{ a1x + b1y = c1 , a2x + b2y = c2}
+const getBasicSystemResolutionQuestion = () => {
+    //need a1/b1 != a2/b2
+    const sys = system_1.SystemConstructor.random();
+    const { x, y } = sys.solve();
+    const isXAsked = (0, coinFlip_1.coinFlip)();
+    const variable = isXAsked ? "x" : "y";
+    const answer = isXAsked ? x.toTex() : y.toTex();
+    const question = {
+        answer,
+        instruction: `Soit le système d'équations suivant :
+
+$${sys.toTex()}$
+
+Que vaut $${variable}$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { coeffs: sys.coeffs, isXAsked },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs, isXAsked }) => {
+    const propositions = [];
+    const sys = new system_1.System(coeffs);
+    const { x, y } = sys.solve();
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, isXAsked ? y.toTex() : x.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, rational_1.RationalConstructor.randomIrreductible().toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, coeffs, isXAsked }) => {
+    const sys = new system_1.System(coeffs);
+    const { x, y } = sys.solve();
+    const texs = isXAsked
+        ? x.toAllValidTexs({
+            allowFractionToDecimal: true,
+            allowMinusAnywhereInFraction: true,
+        })
+        : y.toAllValidTexs({
+            allowFractionToDecimal: true,
+            allowMinusAnywhereInFraction: true,
+        });
+    return texs.includes(ans);
+};
+exports.basicSystemResolution = {
+    id: "basicSystemResolution",
+    connector: "=",
+    label: "Résoudre un système d'équations",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Systèmes"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBasicSystemResolutionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,3 @@
+export * from "./basicSystemResolution";
+export * from "./basicNiceValuesSystemResolution";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC"}

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./basicSystemResolution"), exports);
+__exportStar(require("./basicNiceValuesSystemResolution"), exports);

package/lib/exercises/math/combinatory/anagrams.d.ts

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

package/lib/exercises/math/combinatory/anagrams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anagrams.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/anagrams.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAsGlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAsDF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

package/lib/exercises/math/combinatory/anagrams.js

@@ -0,0 +1,162 @@
+"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,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ballsCounting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/ballsCounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsHF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}

package/lib/exercises/math/combinatory/ballsCounting.js

@@ -0,0 +1,113 @@
+"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,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    type: number;
+    face1?: number;
+    face2?: number;
+    face3?: number;
+};
+export declare const diceCounting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=diceCounting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diceCounting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/diceCounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAkHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/combinatory/diceCounting.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diceCounting = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const getDiceCountingQuestion = () => {
+    const type = (0, randint_1.randint)(0, 8);
+    let instruction = "";
+    let answer = "";
+    let face1;
+    let face2;
+    let face3;
+    switch (type) {
+        case 0:
+            instruction = `avec exactement deux chiffres identiques`;
+            answer = 6 * 3 * 5 + "";
+            break;
+        case 1:
+            instruction = `avec trois chiffres identiques`;
+            answer = 6 + "";
+            break;
+        case 2:
+            face1 = (0, randint_1.randint)(1, 7);
+            instruction = `avec exactement une fois la face ${face1}`;
+            answer = 3 * 5 * 5 + "";
+            break;
+        case 3:
+            face1 = (0, randint_1.randint)(1, 7);
+            instruction = `avec exactement deux fois la face ${face1}`;
+            answer = 3 * 5 + "";
+            break;
+        case 4:
+            face1 = (0, randint_1.randint)(1, 7);
+            face2 = (0, randint_1.randint)(1, 7, [face1]);
+            face3 = (0, randint_1.randint)(1, 7, [face1, face2]);
+            instruction = `avec exactement les faces ${face1}, ${face2} et ${face3}`;
+            answer = 6 + "";
+            break;
+        case 5:
+            face1 = (0, randint_1.randint)(1, 7);
+            face2 = (0, randint_1.randint)(1, 7, [face1]);
+            face3 = (0, randint_1.randint)(1, 7, [face1, face2]);
+            instruction = `avec exactement une fois la face ${face1} et une fois la face ${face2}`;
+            answer = 3 * 5 + "";
+            break;
+        case 6:
+            instruction = `dans lesquels toutes les faces sont différentes`;
+            answer = 6 * 5 * 4 + "";
+            break;
+        case 7:
+            instruction = "";
+            answer = 6 * 6 * 6 + "";
+            break;
+    }
+    const question = {
+        answer: answer,
+        instruction: `On tire 3 fois consécutivement un dé à six faces numérotées de 1 à 6. Combien de tirages ${instruction} sont possibles ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { type, face1, face2, face3 },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, type }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    switch (type) {
+        case 0:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 3 * 5 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 6 * 3 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 3 + "");
+            break;
+        case 1:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 3 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 1 + "");
+            break;
+        case 2:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 3 * 6 * 6 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 5 * 5 + "");
+            break;
+        case 3:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 3 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 5 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 5 + "");
+            break;
+        case 4:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 3 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 1 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 6 * 6 + "");
+            break;
+        case 5:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 3 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 5 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 5 + "");
+            break;
+        case 6:
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 6 * 6 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 * 5 + "");
+            (0, exercise_1.tryToAddWrongProp)(propositions, 6 + "");
+            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.diceCounting = {
+    id: "diceCounting",
+    connector: "=",
+    label: "Dénombrement avec des dés",
+    levels: ["TermSpé"],
+    isSingleStep: true,
+    sections: ["Combinatoire et dénombrement"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDiceCountingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,4 @@
+export * from "./anagrams";
+export * from "./ballsCounting";
+export * from "./diceCounting";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/combinatory/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./anagrams"), exports);
+__exportStar(require("./ballsCounting"), exports);
+__exportStar(require("./diceCounting"), exports);

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    z1Re: number;
+    z1Im: number;
+    z2Re: number;
+    z2Im: number;
+};
+export declare const addComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=addComplex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addComplex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/complex/addComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAuDF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAa5C,CAAC"}