math-exercises 3.0.103 → 3.0.105

package/lib/exercises/math/probaStat/basicProbas/ballsBasicProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ballsBasicProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/ballsBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAoGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"ballsBasicProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/ballsBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAwGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/ballsBasicProbas.js

@@ -11,7 +11,7 @@ pluralize;
 const getInstruction = (identifiers) => {
     const { repartitions, colorAskedIndex } = identifiers;
     const colorAsked = colors[colorAskedIndex];
-    const counts = repartitions.map((count, index) => `$${count}$ ${pluralize("boule", count)} ${colors[index]}`);
+    const counts = repartitions.map((count, index) => `$${count}$ ${pluralize("boule", count)} ${pluralize(colors[index], count)}`);
     return `Dans un sac, il y a ${counts[0]}, ${counts[1]} et ${counts[2]}.
 
 Quelle est la probabilité de tirer une boule ${colorAsked} ?`;
@@ -31,7 +31,7 @@ const getCorrection = (identifiers) => {
     const { repartitions, colorAskedIndex } = identifiers;
     const nbColorAsked = repartitions[colorAskedIndex];
     const total = repartitions.reduce((acc, curr) => (acc += curr), 0);
-    return `Puisque toutes les boules ont la même chance d'être tirée, la probabilité d'obtenir une boule ${colors[colorAskedIndex]} est le nombre de boules ${colors[colorAskedIndex]} divisé par le nombre total de boules, c'est à dire : 
+    return `Puisque toutes les boules ont la même chance d'être tirée, la probabilité d'obtenir une boule ${colors[colorAskedIndex]} est le nombre de boules ${pluralize(colors[colorAskedIndex], repartitions[colorAskedIndex])} divisé par le nombre total de boules, c'est à dire : 
   
 $$
 ${frac(nbColorAsked, total).toSimplificationTex()}

package/lib/exercises/math/probaStat/probaFromTableNoContext.js

@@ -259,7 +259,7 @@ export const probaFromTableNoContext = {
     connector: "=",
     label: "Utiliser un tableau à double entrée pour calculer une probabilité (sans contexte)",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getProbaFromTableNoContextQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getProbaFromTableNoContextQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.d.ts

@@ -3,7 +3,7 @@ type Identifiers = {
     labels: string[];
     serie1: number[];
     serie2: number[];
-    a: number;
+    a?: number;
     b: number;
     isBetween: boolean;
 };

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getQuartileProportionQuestion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAwMF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}
+{"version":3,"file":"getQuartileProportionQuestion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAoOF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.js

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
@@ -13,30 +14,16 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswer = ({ serie1, serie2, a, b, isBetween, }) => {
-    const mainSeries = serie1.includes(b) ? serie1 : serie2;
-    const otherSeries = mainSeries === serie1 ? serie2 : serie1;
-    const indexOfB = mainSeries.indexOf(b);
-    const indexOfA = mainSeries.indexOf(a);
-    const diff = indexOfB - indexOfA + 1;
-    let count = 0;
-    for (let idx = 0; idx < otherSeries.length; idx++) {
-        const val = otherSeries[idx];
-        if (isBetween) {
-            if ((val >= a || otherSeries[idx + 1] > a) &&
-                (val <= b || otherSeries[idx - 1] < b)) {
-                count++;
-            }
-        }
-        else {
-            if (val < b) {
-                count++;
-            }
-        }
+    if (isBetween) {
+        const serie1Space = serie1.indexOf(b) - serie1.indexOf(a);
+        const serie2Space = serie2.indexOf(b) - serie2.indexOf(a);
+        return serie1Space > serie2Space ? "Série $1$" : "Série $2$";
+    }
+    else {
+        const serie1Index = serie1.indexOf(b);
+        const serie2Index = serie2.indexOf(b);
+        return serie1Index < serie2Index ? "Série $1$" : "Série $2$";
     }
-    const mainSeriesText = mainSeries === serie1 ? "Série $1$" : "Série $2$";
-    const otherSeriesText = mainSeries === serie1 ? "Série $2$" : "Série $1$";
-    const condition = isBetween ? diff >= count : indexOfB < count;
-    return condition ? mainSeriesText : otherSeriesText;
 };
 const getInstruction = ({ labels, serie1, serie2, a, b, isBetween, }) => {
     const question = isBetween
@@ -60,63 +47,29 @@ Les quartiles permettent de découper une série en quatre parties égales :
 };
 const getCorrection = (identifiers) => {
     const { labels, serie1, serie2, a, b, isBetween } = identifiers;
-    const isBInSerie1 = serie1.includes(b);
-    const mainSeries = isBInSerie1 ? serie1 : serie2;
-    const otherSeries = isBInSerie1 ? serie2 : serie1;
-    const mainSeriesLabel = isBInSerie1 ? "série $1$" : "série $2$";
-    const otherSeriesLabel = isBInSerie1 ? "série $2$" : "série $1$";
-    const indexOfA = mainSeries.indexOf(a);
-    const indexOfB = mainSeries.indexOf(b);
-    let i = 0;
-    for (let idx = 0; idx < otherSeries.length; idx++) {
-        const val = otherSeries[idx];
-        if (isBetween) {
-            if ((val >= a || otherSeries[idx + 1] > a) &&
-                (val <= b || otherSeries[idx - 1] < b)) {
-                i++;
-            }
-        }
-        else {
-            if (val < b) {
-                i++;
-            }
-        }
+    const labelDollarized = labels.map((l, i) => i === 1 || i === 3 ? dollarize(l) : l);
+    if (isBetween) {
+        const serie1BIndex = serie1.indexOf(b);
+        const serie2BIndex = serie2.indexOf(b);
+        const serie1AIndex = serie1.indexOf(a);
+        const serie2AIndex = serie2.indexOf(a);
+        const serie1Space = serie1BIndex - serie1AIndex;
+        const serie2Space = serie2BIndex - serie2AIndex;
+        return `Dans la série $1$, ${labelDollarized[serie1AIndex]} $=${a}$, et ${labelDollarized[serie1BIndex]} $=${b}$, donc $${serie1Space * 25} \\%$ des valeurs sont comprises entre $${a}$ et $${b}$.
+    
+Dans la série $2$, ${labelDollarized[serie2AIndex]} $=${a}$, et ${labelDollarized[serie2BIndex]} $=${b}$, donc $${serie2Space * 25} \\%$ des valeurs sont comprises entre $${a}$ et $${b}$.
+
+C'est donc la ${serie2Space < serie1Space ? "série $1$" : "série $2$"} qui a la plus grande proportion de valeurs supérieures à $${b}$.`;
     }
-    const quartilePercentages = [0, 25, 50, 75, 100];
-    const labelA = labels[indexOfA];
-    const labelB = labels[indexOfB];
-    const valueA = a;
-    const valueB = b;
-    const diff = indexOfB - indexOfA + 1;
-    const percentageBetween = quartilePercentages[diff - 1];
-    const percentageAbove = 100 - quartilePercentages[indexOfB];
-    const answer = getAnswer(identifiers);
-    const answerFormatted = answer === "Série $1$" ? "série $1$" : "série $2$";
-    const decideWord = answerFormatted === mainSeriesLabel ? "moins" : "plus";
-    const proportionB = isBetween
-        ? `$${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
-        : `$${percentageAbove}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
-    const proportionOther = i === 0
-        ? `Il n'y a aucune valeur dans l'intervalle $[${valueA}; ${valueB}]$.\n\n`
-        : isBetween
-            ? `${decideWord} $${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
-            : `${otherSeries[indexOfB] > valueB ? "plus" : "moins"} de $${100 - quartilePercentages[i - 1]}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
-    const comparison = isBetween
-        ? `La ${answer} a donc une proportion plus grande de valeurs dans l'intervalle.`
-        : `La ${answer} a donc une proportion plus grande de valeurs supérieures à $${valueB}$.`;
-    return isBetween
-        ? `On peut estimer cette proportion en observant la position des valeurs $${valueA}$ et $${valueB}$ dans chaque série :
+    else {
+        const serie1Index = serie1.indexOf(b);
+        const serie2Index = serie2.indexOf(b);
+        return `Dans la série $1$, ${labelDollarized[serie1Index]} $=${b}$, donc $${100 - serie1Index * 25} \\%$ des valeurs sont supérieures à $${b}$.
     
-  - Dans la ${mainSeriesLabel}, on a $${labelA} = ${valueA}$ et $${labelB} = ${valueB}$, donc ${proportionB}
-  - Dans la ${otherSeriesLabel}, on a $${labelA} = ${otherSeries[indexOfA]}$ et $${labelB} = ${otherSeries[indexOfB]}$, donc ${proportionOther}
-  
-  ${comparison}`
-        : `On peut estimer cette proportion en observant la position de la valeur $${valueB}$ dans chaque série :
-  
-  - Dans la ${mainSeriesLabel}, on a $${labelB} = ${valueB}$, donc ${proportionB}
-  - Dans la ${otherSeriesLabel}, on a $${labelB} = ${otherSeries[indexOfB]}$, ${proportionOther}
-  
-  ${comparison}`;
+Dans la série $2$, ${labelDollarized[serie2Index]} $=${b}$, donc $${100 - serie2Index * 25} \\%$ des valeurs sont supérieures à $${b}$.
+
+C'est donc la ${serie1Index < serie2Index ? "série $1$" : "série $2$"} qui a la plus grande proportion de valeurs supérieures à $${b}$.`;
+    }
 };
 const getKeys = () => [];
 const isAnswerValid = (ans, { answer }) => {
@@ -127,25 +80,93 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
-const makeQuartileSeries = (min, exclude) => {
-    const serie = [min];
-    for (let i = 0; i < 4; i++) {
-        const prev = serie[serie.length - 1];
-        serie.push(randint(prev + 1, prev + 6, exclude));
-    }
-    return serie;
-};
 const getGetQuartileProportionQuestionQuestion = () => {
     const labels = ["Min", "Q_1", "Méd", "Q_3", "Max"];
-    const min = randint(0, 10);
-    const serie1 = makeQuartileSeries(min);
-    const serie2 = makeQuartileSeries(min, serie1);
+    let a = undefined;
+    let b;
+    let serie1;
+    let serie2;
     const isBetween = coinFlip();
-    const chosenSerie = coinFlip() ? serie1 : serie2;
-    const indexOfA = randint(0, serie1.length - (isBetween ? 1 : 2));
-    const a = chosenSerie[indexOfA];
-    const indexOfB = randint(indexOfA + 1, isBetween ? chosenSerie.length : chosenSerie.length - 1);
-    const b = chosenSerie[indexOfB];
+    if (isBetween) {
+        const serie1Indexes = randTupleInt(2, {
+            from: 0,
+            to: 5,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        let serie2Indexes = [];
+        do {
+            serie2Indexes = randTupleInt(2, {
+                from: 0,
+                to: 5,
+                allDifferent: true,
+            }).sort((a, b) => a - b);
+        } while (serie2Indexes[1] - serie2Indexes[0] ===
+            serie1Indexes[1] - serie1Indexes[0] ||
+            (serie1Indexes[0] === serie2Indexes[0] &&
+                serie1Indexes[1] === serie2Indexes[1]));
+        a = randint(5, 20);
+        b = randint(a + 5, 30);
+        const serie1Prev = randTupleInt(serie1Indexes[0], {
+            from: 1,
+            to: a,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1Between = randTupleInt(serie1Indexes[1] - serie1Indexes[0] - 1, {
+            from: a + 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1End = randTupleInt(4 - serie1Indexes[1], {
+            from: b + 1,
+            to: 40,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Prev = randTupleInt(serie2Indexes[0], {
+            from: 1,
+            to: a,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Between = randTupleInt(serie2Indexes[1] - serie2Indexes[0] - 1, {
+            from: a + 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2End = randTupleInt(4 - serie2Indexes[1], {
+            from: b + 1,
+            to: 40,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        serie1 = [...serie1Prev, a, ...serie1Between, b, ...serie1End];
+        serie2 = [...serie2Prev, a, ...serie2Between, b, ...serie2End];
+    }
+    else {
+        b = randint(5, 20);
+        //build les deux series avec a ayant un index <4 et différents
+        const serie1Index = randint(0, 4);
+        const serie2Index = randint(0, 4, [serie1Index]);
+        const serie1Prev = randTupleInt(serie1Index, {
+            from: 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Prev = randTupleInt(serie2Index, {
+            from: 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1Next = randTupleInt(4 - serie1Index, {
+            from: b + 1,
+            to: 30,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Next = randTupleInt(4 - serie2Index, {
+            from: b + 1,
+            to: 30,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        serie1 = [...serie1Prev, b, ...serie1Next];
+        serie2 = [...serie2Prev, b, ...serie2Next];
+    }
     const identifiers = { labels, serie1, serie2, a, b, isBetween };
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/index.d.ts

@@ -2061,7 +2061,7 @@ declare const mathExercises: (Exercise<{
     labels: string[];
     serie1: number[];
     serie2: number[];
-    a: number;
+    a?: number;
     b: number;
     isBetween: boolean;
 }, {}> | Exercise<{

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.103",
+  "version": "3.0.105",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [