math-exercises 1.4.15 → 1.4.17

package/lib/exercises/calcul/arithmetics/paritySumsAndProducts.d.ts

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const paritySumsAndProducts: MathExercise;
+export declare function getParitySumsAndProductsQuestion(): Question;
+//# sourceMappingURL=paritySumsAndProducts.d.ts.map

package/lib/exercises/calcul/arithmetics/paritySumsAndProducts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paritySumsAndProducts.d.ts","sourceRoot":"","sources":["../../../../src/exercises/calcul/arithmetics/paritySumsAndProducts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAM7F,eAAO,MAAM,qBAAqB,EAAE,YAanC,CAAC;AAEF,wBAAgB,gCAAgC,IAAI,QAAQ,CA8F3D"}

package/lib/exercises/calcul/arithmetics/paritySumsAndProducts.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParitySumsAndProductsQuestion = exports.paritySumsAndProducts = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const uuid_1 = require("uuid");
+exports.paritySumsAndProducts = {
+    id: 'paritySumsAndProducts',
+    connector: '=',
+    instruction: '',
+    label: 'Parité de sommes et de produits',
+    levels: ['2nde'],
+    isSingleStep: true,
+    sections: ['Arithmétique'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getParitySumsAndProductsQuestion, nb, 12),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: 'QCM',
+    maxAllowedQuestions: 12,
+};
+function getParitySumsAndProductsQuestion() {
+    const type = (0, randint_1.randint)(0, 12);
+    let instruction = '';
+    let answer;
+    switch (type) {
+        case 0:
+            instruction = 'La somme de deux nombres pairs est un nombre...';
+            answer = 'Pair';
+            break;
+        case 1:
+            instruction = 'La somme de deux nombres impairs est un nombre...';
+            answer = 'Pair';
+            break;
+        case 2:
+            instruction = "La somme d'un nombre pair et d'un nombre impair un nombre...";
+            answer = 'Impair';
+            break;
+        case 3:
+            instruction = 'La somme de trois nombres impairs est un nombre...';
+            answer = 'Impair';
+            break;
+        case 4:
+            instruction = 'La somme de trois nombres consécutifs est un nombre...';
+            answer = 'Parfois pair, parfois impair';
+            break;
+        case 5:
+            instruction = 'La somme de quatre nombres consécutifs est un nombre...';
+            answer = 'Pair';
+            break;
+        case 6:
+            instruction = 'Le produit de deux nombres pairs est un nombre...';
+            answer = 'Pair';
+            break;
+        case 7:
+            instruction = 'Le produit de deux nombres impairs est un nombre...';
+            answer = 'Impair';
+            break;
+        case 8:
+            instruction = "Le produit d'un nombre pair et d'un nombre impair est un nombre...";
+            answer = 'Pair';
+            break;
+        case 9:
+            instruction = 'Le produit de trois nombres consécutifs est un nombre...';
+            answer = 'Pair';
+            break;
+        case 10:
+            instruction = 'Le produit de trois nombres impairs est un nombre...';
+            answer = 'Impair';
+            break;
+        case 11:
+            instruction = 'Le produit de trois nombres pairs est un nombre...';
+            answer = 'Pair';
+            break;
+    }
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: `Pair`,
+            isRightAnswer: answer === 'Pair',
+            format: 'raw',
+        });
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: `Impair`,
+            isRightAnswer: answer === 'Impair',
+            format: 'raw',
+        });
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: `Parfois pair, parfois impair`,
+            isRightAnswer: answer === 'Parfois pair, parfois impair',
+            format: 'raw',
+        });
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: `Premier`,
+            isRightAnswer: answer === 'Premier',
+            format: 'raw',
+        });
+        return (0, shuffle_1.shuffle)(res);
+    };
+    const question = {
+        answer: answer,
+        instruction,
+        keys: [],
+        getPropositions,
+        answerFormat: 'raw',
+    };
+    return question;
+}
+exports.getParitySumsAndProductsQuestion = getParitySumsAndProductsQuestion;

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

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../exercises/exercise';
+export declare const anagrams: MathExercise;
+export declare function getAnagramsQuestion(): Question;
+//# sourceMappingURL=anagrams.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"anagrams.d.ts","sourceRoot":"","sources":["../../../src/exercises/combinatory/anagrams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAqEhH,eAAO,MAAM,QAAQ,EAAE,YAWtB,CAAC;AAEF,wBAAgB,mBAAmB,IAAI,QAAQ,CAoD9C"}

package/lib/exercises/combinatory/anagrams.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnagramsQuestion = 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 uuid_1 = require("uuid");
+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',
+];
+exports.anagrams = {
+    id: 'anagrams',
+    connector: '=',
+    instruction: '',
+    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,
+};
+function getAnagramsQuestion() {
+    const word = (0, random_1.random)(words);
+    const answer = word
+        .split('')
+        .map((el, index) => index + 1)
+        .reduce((acc, curr) => acc * curr, 1);
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: answer + ``,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        (0, exercise_1.tryToAddWrongProp)(res, Math.pow(word.length, word.length) + '');
+        (0, exercise_1.tryToAddWrongProp)(res, (word.length * (word.length + 1)) / 2 + '');
+        (0, exercise_1.tryToAddWrongProp)(res, word.length * word.length + '');
+        const missing = n - res.length;
+        for (let i = 0; i < missing; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = (0, randint_1.randint)(1000, 10000);
+                proposition = {
+                    id: (0, uuid_1.v4)() + ``,
+                    statement: wrongAnswer + '',
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, exercise_1.shuffleProps)(res, n);
+    };
+    const question = {
+        answer: answer + '',
+        instruction: `Combien d'anagrammes mathématiques du mot ${word} sont possibles ? `,
+        keys: [],
+        getPropositions,
+        answerFormat: 'tex',
+    };
+    return question;
+}
+exports.getAnagramsQuestion = getAnagramsQuestion;

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

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../exercises/exercise';
+export declare const ballsCounting: MathExercise;
+export declare function getBallsCountingQuestion(): Question;
+//# sourceMappingURL=ballsCounting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ballsCounting.d.ts","sourceRoot":"","sources":["../../../src/exercises/combinatory/ballsCounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAKhH,eAAO,MAAM,aAAa,EAAE,YAW3B,CAAC;AAEF,wBAAgB,wBAAwB,IAAI,QAAQ,CA8GnD"}

package/lib/exercises/combinatory/ballsCounting.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBallsCountingQuestion = 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 uuid_1 = require("uuid");
+exports.ballsCounting = {
+    id: 'ballsCounting',
+    connector: '=',
+    instruction: '',
+    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,
+};
+function 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 getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: answer,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        switch (type) {
+            case 0:
+                (0, exercise_1.tryToAddWrongProp)(res, total * total * total + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 + '');
+                break;
+            case 1:
+                (0, exercise_1.tryToAddWrongProp)(res, reds * reds * reds + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 1 + '');
+                break;
+            case 2:
+                (0, exercise_1.tryToAddWrongProp)(res, (reds + greens) * (reds + greens) * (reds + greens) + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * blacks * (reds + greens) * (reds + greens - 1) + '');
+                break;
+            case 3:
+                (0, exercise_1.tryToAddWrongProp)(res, (reds + greens) * (reds + greens) * (reds + greens) + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 3 * (reds + greens) * (reds + greens - 1) + '');
+                break;
+            case 4:
+                (0, exercise_1.tryToAddWrongProp)(res, blacks * greens * reds + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 + '');
+                break;
+            case 5:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * greens * blacks * blacks + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 + '');
+                break;
+            case 6:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * (blacks * greens * reds) + '');
+                (0, exercise_1.tryToAddWrongProp)(res, greens * (reds + blacks) * (reds + blacks - 1) + '');
+                break;
+        }
+        const missing = n - res.length;
+        for (let i = 0; i < missing; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = (0, randint_1.randint)(1, 100) + '';
+                proposition = {
+                    id: (0, uuid_1.v4)() + ``,
+                    statement: wrongAnswer,
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, exercise_1.shuffleProps)(res, n);
+    };
+    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: [],
+        getPropositions,
+        answerFormat: 'tex',
+    };
+    return question;
+}
+exports.getBallsCountingQuestion = getBallsCountingQuestion;

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

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../exercises/exercise';
+export declare const diceCounting: MathExercise;
+export declare function getDiceCountingQuestion(): Question;
+//# sourceMappingURL=diceCounting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diceCounting.d.ts","sourceRoot":"","sources":["../../../src/exercises/combinatory/diceCounting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAKhH,eAAO,MAAM,YAAY,EAAE,YAW1B,CAAC;AAEF,wBAAgB,uBAAuB,IAAI,QAAQ,CAwHlD"}

package/lib/exercises/combinatory/diceCounting.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDiceCountingQuestion = 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 uuid_1 = require("uuid");
+exports.diceCounting = {
+    id: 'diceCounting',
+    connector: '=',
+    instruction: '',
+    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,
+};
+function getDiceCountingQuestion() {
+    const type = (0, randint_1.randint)(0, 8);
+    let instruction = '';
+    let answer = '';
+    let face1, face2, 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;
+    }
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: answer,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        switch (type) {
+            case 0:
+                (0, exercise_1.tryToAddWrongProp)(res, 3 * 5 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 6 * 3 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 3 + '');
+                break;
+            case 1:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 3 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 1 + '');
+                break;
+            case 2:
+                (0, exercise_1.tryToAddWrongProp)(res, 3 * 6 * 6 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 5 * 5 + '');
+                break;
+            case 3:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 3 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 5 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 5 + '');
+                break;
+            case 4:
+                (0, exercise_1.tryToAddWrongProp)(res, 3 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 1 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 6 * 6 + '');
+                break;
+            case 5:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 3 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 5 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 5 + '');
+                break;
+            case 6:
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 6 * 6 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 * 5 + '');
+                (0, exercise_1.tryToAddWrongProp)(res, 6 + '');
+                break;
+        }
+        const missing = n - res.length;
+        for (let i = 0; i < missing; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = (0, randint_1.randint)(1, 100) + '';
+                proposition = {
+                    id: (0, uuid_1.v4)() + ``,
+                    statement: wrongAnswer,
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, exercise_1.shuffleProps)(res, n);
+    };
+    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: [],
+        getPropositions,
+        answerFormat: 'tex',
+    };
+    return question;
+}
+exports.getDiceCountingQuestion = getDiceCountingQuestion;

package/lib/exercises/derivation/derivative/productDerivative.d.ts

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const productDerivative: MathExercise;
+export declare function getProductDerivativeQuestion(): Question;
+//# sourceMappingURL=productDerivative.d.ts.map

package/lib/exercises/derivation/derivative/productDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"productDerivative.d.ts","sourceRoot":"","sources":["../../../../src/exercises/derivation/derivative/productDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAOhH,eAAO,MAAM,iBAAiB,EAAE,YAW/B,CAAC;AAEF,wBAAgB,4BAA4B,IAAI,QAAQ,CAkDvD"}

package/lib/exercises/derivation/derivative/productDerivative.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProductDerivativeQuestion = exports.productDerivative = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../../math/polynomials/polynomial");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const uuid_1 = require("uuid");
+exports.productDerivative = {
+    id: 'productDerivative',
+    connector: '=',
+    instruction: '',
+    label: "Dérivée d'un produit de polynômes",
+    levels: ['1reSpé', 'MathComp'],
+    isSingleStep: true,
+    sections: ['Dérivation'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProductDerivativeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};
+function getProductDerivativeQuestion() {
+    const poly1 = polynomial_1.PolynomialConstructor.randomWithLength(3, 2);
+    const poly2 = polynomial_1.PolynomialConstructor.randomWithLength(3, 2);
+    const answer = poly1.multiply(poly2).derivate().toTree().toTex();
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)(),
+            statement: answer,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        (0, exercise_1.tryToAddWrongProp)(res, poly1.derivate().multiply(poly2.derivate()).toTree().toTex());
+        (0, exercise_1.tryToAddWrongProp)(res, poly1.derivate().add(poly2.derivate()).toTree().toTex());
+        const missing = n - res.length;
+        for (let i = 0; i < missing; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                const wrongAnswer = polynomial_1.PolynomialConstructor.random(3).toTree().toTex();
+                proposition = {
+                    id: (0, uuid_1.v4)() + ``,
+                    statement: wrongAnswer,
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, exercise_1.shuffleProps)(res, n);
+    };
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la dérivée de la fonction $f$ définie par $f(x) = ${new multiplyNode_1.MultiplyNode(poly1.toTree(), poly2.toTree()).toTex()}$`,
+        keys: ['x', 'xsquare', 'xcube'],
+        getPropositions,
+        answerFormat: 'tex',
+    };
+    return question;
+}
+exports.getProductDerivativeQuestion = getProductDerivativeQuestion;

package/lib/exercises/derivation/derivative/quotientDerivative.d.ts

@@ -0,0 +1,4 @@
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const quotientDerivative: MathExercise;
+export declare function getProductDerivativeQuestion(): Question;
+//# sourceMappingURL=quotientDerivative.d.ts.map

package/lib/exercises/derivation/derivative/quotientDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quotientDerivative.d.ts","sourceRoot":"","sources":["../../../../src/exercises/derivation/derivative/quotientDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,YAAY,EAAe,QAAQ,EAAqB,MAAM,0BAA0B,CAAC;AAUhH,eAAO,MAAM,kBAAkB,EAAE,YAWhC,CAAC;AAEF,wBAAgB,4BAA4B,IAAI,QAAQ,CAoDvD"}