math-exercises 3.0.174 → 3.0.176

package/lib/exercises/math/probaStat/trees/probaTreeSituations.js

@@ -1,108 +1,344 @@
-// import { randint } from "../../../../math/utils/random/randint.js";
-// import { AlgebraicNode } from "../../../../tree/nodes/algebraicNode.js";
-// import { PercentNode } from "../../../../tree/nodes/numbers/percentNode.js";
-// import { substract } from "../../../../tree/nodes/operators/substractNode.js";
-export {};
-// // C1 : Test de dépistage. Un virus a contaminé 10% de la population d'un pays. Un test de dépistage est développé. Le test des positif chez 95% des individus ccntaminés et il est négatif chez 92% des individus sains. On choisit un individu au hasard dans la population et on note C l'événement "l'individu est contaminé" et T l'événement "le test est positif".
-// // C2 : Dragées. Pour son mariage, Amélie a conmmandé des dragées. 30% des dragées sont à l'amande et le reste au chocolat. 60% des dragées à l'amande et 20% des dragées au chocolat sont blanches, les aurtes sont roses. On choisit une dragée au hasard et on note A l'événement "la dragée est à l'amande" et B l'événement "la dragée est blanche".
-// // C3 : Controle qualité. Une entreprise produit* des micro-processeurs. Elle dispose de deux sites de production, A et B. 2% des micro-processeurs produits sur le site A et 5% des micro-processeurs produits sur le site B sont déféctueux. On choisit au hasard un  micro-processeur sur l'ensemble de la production, et on note A l'événement "le micro-processeur a été produit sur le site A" et D l'événement "le micro-processeur est défectueux".
-// // C4 : Match à domicile. Sur l'enemble des matchs joués cette année, la célèbre équipe de l'OMG a joué 55% de ces mathcs à domicile. Elle a gagné 75% des matchs joués à domicile et 60% des matchs joués à l'extérieur. on choisit un  match au hasard parmi ceux joués cette année et on note D l'événement "le matche a été joué à domicile" et G "l'équipe a gagné le match".
-// // C5 : Accidents jeunes conduteurs. Dans une compagnie d'assurance, on constate que 5% des assurés sont des jeunes conducteurs (moins de 3 ans de permis). Au cours de l'année précédente, 20% des jeunes conducteurs ont eu un sinistre, et 8% des autres conducteurs ont eu un sinistre. on choisit un assuré au hasard de cette compagnie et on note les événements J : "L'assuré est un jeune conducteur" et S : "L'assuré a connu un sinistre au cours de l'année précédente"..
-// // C6 : Choix spécialité maths/genre. Parmi les élèves de terminale d'un lycée, 58% des sont des filles. 70% des filles et 55% des garçons suivent la spécialité maths. On choisit un élève de terminale au hasard dans ce lycée et on note F l'événement "l'élève est une fille" et M l'événement "l'élève suit la spécialité maths".
-// type VirusParams = {
-//   pContamine: AlgebraicNode;
-//   pPosContamine: AlgebraicNode;
-//   pNegSain: AlgebraicNode;
-// };
-// const buildVirusParams = (): VirusParams => {
-//   const pContamine = randint(1, 20).toTree();
-//   const pPosContamine = randint(88, 98).toTree();
-//   const pNegSain = randint(88, 98).toTree();
-//   return {
-//     pContamine,
-//     pNegSain,
-//     pPosContamine,
-//   };
-// };
-// const virusSituation = (params: VirusParams) => {
-//   const { pContamine, pNegSain, pPosContamine } = params;
-//   return {
-//     id: "virus",
-//     context: `Un virus a contaminé $${pContamine.toTex()}\\%$ de la population d'un pays. Un test de dépistage est développé. Le test est positif chez $${pPosContamine.toTex()}\\%$ des individus ccntaminés, et il est négatif chez $${pNegSain.toTex()}\\%$ des individus sains.
-// On choisit un individu au hasard dans la population et on note $C$ l'événement "l'individu est contaminé" et $T$ l'événement "le test est positif".`,
-//     keys: ["C", "T", "\\overline{C}", "\\overline{T}", "percent"],
-//     tree: [
-//       [
-//         [
-//           [`$${pContamine.toTex()}\\%$`, "$C$"],
-//           [
-//             `$${substract(1, pContamine).simplify().toTex()}\\%$`,
-//             "$\\overline{C}$",
-//           ],
-//         ],
-//       ],
-//       [
-//         [
-//           [`$${pPosContamine.toTex()}\\%$`, "$T$"],
-//           [
-//             `$${substract(1, pPosContamine).simplify().toTex()}\\%$`,
-//             "$\\overline{T}$",
-//           ],
-//         ],
-//         [
-//           [`$${substract(1, pNegSain).simplify().toTex()}\\%$`, "$T$"],
-//           [`$${pNegSain.toTex()}\\%$`, "$\\overline{T}$"],
-//         ],
-//       ],
-//     ],
-//   };
-// };
-// type DrageeParams = {
-//   pContamine: AlgebraicNode;
-//   pPosContamine: AlgebraicNode;
-//   pNegSain: AlgebraicNode;
-// };
-// const buildDrageeParams = (): VirusParams => {
-//   const pAmande = randint(1, 20).toTree();
-//   const pBlancheAmande = randint(88, 98).toTree();
-//   const pBlancheChocolat = randint(88, 98).toTree();
-//   return {
-//     pContamine,
-//     pNegSain,
-//     pPosContamine,
-//   };
-// };
-// const virusSituation = (params: VirusParams) => {
-//   const { pContamine, pNegSain, pPosContamine } = params;
-//   return {
-//     id: "virus",
-//     context: `Un virus a contaminé $${pContamine.toTex()}\\%$ de la population d'un pays. Un test de dépistage est développé. Le test est positif chez $${pPosContamine.toTex()}\\%$ des individus ccntaminés, et il est négatif chez $${pNegSain.toTex()}\\%$ des individus sains.
-// On choisit un individu au hasard dans la population et on note $C$ l'événement "l'individu est contaminé" et $T$ l'événement "le test est positif".`,
-// context: `Pour son mariage, Amélie a commandé des dragées. 30% des dragées sont à l'amande et le reste au chocolat. 60% des dragées à l'amande et 20% des dragées au chocolat sont blanches, les aurtes sont roses. On choisit une dragée au hasard et on note A l'événement "la dragée est à l'amande" et B l'événement "la dragée est blanche".`,
-//     keys: ["C", "T", "\\overline{C}", "\\overline{T}", "percent"],
-//     tree: [
-//       [
-//         [
-//           [`$${pContamine.toTex()}\\%$`, "$C$"],
-//           [
-//             `$${substract(1, pContamine).simplify().toTex()}\\%$`,
-//             "$\\overline{C}$",
-//           ],
-//         ],
-//       ],
-//       [
-//         [
-//           [`$${pPosContamine.toTex()}\\%$`, "$T$"],
-//           [
-//             `$${substract(1, pPosContamine).simplify().toTex()}\\%$`,
-//             "$\\overline{T}$",
-//           ],
-//         ],
-//         [
-//           [`$${substract(1, pNegSain).simplify().toTex()}\\%$`, "$T$"],
-//           [`$${pNegSain.toTex()}\\%$`, "$\\overline{T}$"],
-//         ],
-//       ],
-//     ],
-//   };
-// };
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const buildVirusParams = () => {
+    const pContamineIds = randint(1, 20).toTree().toIdentifiers();
+    const pPosContamine = randint(88, 98);
+    const pNegSainIds = randint(88, 98, [pPosContamine]).toTree().toIdentifiers();
+    return {
+        pContamineIds,
+        pNegSainIds,
+        pPosContamineIds: pPosContamine.toTree().toIdentifiers(),
+    };
+};
+const getVirusSituation = (params) => {
+    const { pContamineIds, pNegSainIds, pPosContamineIds } = params;
+    const pContamine = reifyAlgebraic(pContamineIds);
+    const pPosContamine = reifyAlgebraic(pPosContamineIds);
+    const pNegSain = reifyAlgebraic(pNegSainIds);
+    return {
+        id: "virus",
+        context: `Un virus a contaminé $${pContamine.toTex()}\\%$ de la population d'un pays. Un test de dépistage est développé. Le test est positif chez $${pPosContamine.toTex()}\\%$ des individus contaminés, et il est négatif chez $${pNegSain.toTex()}\\%$ des individus sains.
+
+On choisit un individu au hasard dans la population et on note $C$ l'événement "l'individu est contaminé" et $T$ l'événement "le test est positif".`,
+        mainEvent: "C",
+        secondEvent: "T",
+        mainEventProba: pContamine,
+        firstCondProba: pPosContamine,
+        secondCondProba: substract(100, pNegSain).simplify(),
+        keys: ["C", "T", "overlineC", "overlineT", "percent"],
+        tree: [
+            [
+                [
+                    [`${pContamine.toTex()}\\%`, "C"],
+                    [
+                        `${substract(100, pContamine).simplify().toTex()}\\%`,
+                        "\\overline{C}",
+                    ],
+                ],
+            ],
+            [
+                [
+                    [`${pPosContamine.toTex()}\\%`, "T"],
+                    [
+                        `${substract(100, pPosContamine).simplify().toTex()}\\%`,
+                        "\\overline{T}",
+                    ],
+                ],
+                [
+                    [`${substract(100, pNegSain).simplify().toTex()}\\%`, "T"],
+                    [`${pNegSain.toTex()}\\%`, "\\overline{T}"],
+                ],
+            ],
+        ],
+    };
+};
+const buildDrageeParams = () => {
+    const pAmande = randint(10, 60);
+    const pBlancheAmande = randint(40, 90, [pAmande]);
+    const pBlancheChocolat = randint(20, 80, [pAmande, pBlancheAmande]);
+    return {
+        pAmandeIds: pAmande.toTree().toIdentifiers(),
+        pBlancheAmandeIds: pBlancheAmande.toTree().toIdentifiers(),
+        pBlancheChocolatIds: pBlancheChocolat.toTree().toIdentifiers(),
+    };
+};
+const getDrageeSituation = (params) => {
+    const { pAmandeIds, pBlancheAmandeIds, pBlancheChocolatIds } = params;
+    const pAmande = reifyAlgebraic(pAmandeIds);
+    const pBlancheAmande = reifyAlgebraic(pBlancheAmandeIds);
+    const pBlancheChocolat = reifyAlgebraic(pBlancheChocolatIds);
+    return {
+        id: "dragee",
+        context: `Pour son mariage, Amélie a commandé des dragées. $${pAmande.toTex()}\\%$ des dragées sont à l'amande et le reste au chocolat. $${pBlancheAmande.toTex()}\\%$ des dragées à l'amande et $${pBlancheChocolat.toTex()}\\%$ des dragées au chocolat sont blanches, les autres sont roses. 
+
+On choisit une dragée au hasard et on note $A$ l'événement "la dragée est à l'amande" et $B$ l'événement "la dragée est blanche".`,
+        mainEvent: "A",
+        secondEvent: "B",
+        mainEventProba: pAmande,
+        firstCondProba: pBlancheAmande,
+        secondCondProba: pBlancheChocolat,
+        keys: ["A", "B", "overlineA", "overlineB", "percent"],
+        tree: [
+            [
+                [
+                    [`${pAmande.toTex()}\\%`, "A"],
+                    [`${substract(100, pAmande).simplify().toTex()}\\%`, "\\overline{A}"],
+                ],
+            ],
+            [
+                [
+                    [`${pBlancheAmande.toTex()}\\%`, "B"],
+                    [
+                        `${substract(100, pBlancheAmande).simplify().toTex()}\\%`,
+                        "\\overline{B}",
+                    ],
+                ],
+                [
+                    [`${pBlancheChocolat.toTex()}\\%`, "B"],
+                    [
+                        `${substract(100, pBlancheChocolat).simplify().toTex()}\\%`,
+                        "\\overline{B}",
+                    ],
+                ],
+            ],
+        ],
+    };
+};
+const buildUsineParams = () => {
+    const pA = randint(30, 80);
+    const pDefA = randint(1, 10, [pA]);
+    const pDefB = randint(1, 10, [pA, pDefA]);
+    return {
+        pAIds: pA.toTree().toIdentifiers(),
+        pDefAIds: pDefA.toTree().toIdentifiers(),
+        pDefBIds: pDefB.toTree().toIdentifiers(),
+    };
+};
+const getUsineSituation = (params) => {
+    const { pAIds, pDefAIds, pDefBIds } = params;
+    const pA = reifyAlgebraic(pAIds);
+    const pDefA = reifyAlgebraic(pDefAIds);
+    const pDefB = reifyAlgebraic(pDefBIds);
+    return {
+        id: "usine",
+        context: `Une entreprise produit des micro-processeurs. Elle dispose de deux sites de production, $A$ et $B$. $${pA.toTex()}\\%$ de la production provient du site $A$. $${pDefA.toTex()}\\%$ des micro-processeurs produits sur le site $A$ et $${pDefB.toTex()}\\%$ des micro-processeurs produits sur le site $B$ sont déféctueux.
+    
+On choisit au hasard un  micro-processeur sur l'ensemble de la production, et on note $A$ l'événement "le micro-processeur a été produit sur le site $A$" et $D$ l'événement "le micro-processeur est défectueux".
+
+`,
+        mainEvent: "A",
+        secondEvent: "D",
+        mainEventProba: pA,
+        firstCondProba: pDefA,
+        secondCondProba: pDefB,
+        keys: ["A", "D", "overlineA", "overlineD", "percent"],
+        tree: [
+            [
+                [
+                    [`${pA.toTex()}\\%`, "A"],
+                    [`${substract(100, pA).simplify().toTex()}\\%`, "\\overline{A}"],
+                ],
+            ],
+            [
+                [
+                    [`${pDefA.toTex()}\\%`, "D"],
+                    [`${substract(100, pDefA).simplify().toTex()}\\%`, "\\overline{D}"],
+                ],
+                [
+                    [`${pDefB.toTex()}\\%`, "D"],
+                    [`${substract(100, pDefB).simplify().toTex()}\\%`, "\\overline{D}"],
+                ],
+            ],
+        ],
+    };
+};
+const buildMatchParams = () => {
+    const pDomicile = randint(30, 70);
+    const pVDomicile = randint(10, 80, [pDomicile]);
+    const pVExterieur = randint(10, 80, [pDomicile, pVDomicile]);
+    return {
+        pDomicileIds: pDomicile.toTree().toIdentifiers(),
+        pVDomicileIds: pVDomicile.toTree().toIdentifiers(),
+        pVExterieurIds: pVExterieur.toTree().toIdentifiers(),
+    };
+};
+const geMatchSituation = (params) => {
+    const { pDomicileIds, pVDomicileIds, pVExterieurIds } = params;
+    const pDomicile = reifyAlgebraic(pDomicileIds);
+    const pVDomicile = reifyAlgebraic(pVDomicileIds);
+    const pVExterieur = reifyAlgebraic(pVExterieurIds);
+    return {
+        id: "match",
+        context: `Sur l'enemble des matchs joués cette année, la célèbre équipe de l'OMG a joué $${pDomicile.toTex()}\\%$ de ces matchs à domicile. Elle a gagné $${pVDomicile.toTex()}\\%$ des matchs joués à domicile et $${pVExterieur.toTex()}\\%$ des matchs joués à l'extérieur. 
+    
+On choisit un match au hasard parmi ceux joués cette année et on note $D$ l'événement "le match a été joué à domicile" et $G$ "l'équipe a gagné le match".
+`,
+        mainEvent: "D",
+        secondEvent: "G",
+        mainEventProba: pDomicile,
+        firstCondProba: pVDomicile,
+        secondCondProba: pVExterieur,
+        keys: ["D", "G", "overlineD", "overlineG", "percent"],
+        tree: [
+            [
+                [
+                    [`${pDomicile.toTex()}\\%`, "D"],
+                    [
+                        `${substract(100, pDomicile).simplify().toTex()}\\%`,
+                        "\\overline{D}",
+                    ],
+                ],
+            ],
+            [
+                [
+                    [`${pVDomicile.toTex()}\\%`, "G"],
+                    [
+                        `${substract(100, pVDomicile).simplify().toTex()}\\%`,
+                        "\\overline{G}",
+                    ],
+                ],
+                [
+                    [`${pVExterieur.toTex()}\\%`, "G"],
+                    [
+                        `${substract(100, pVExterieur).simplify().toTex()}\\%`,
+                        "\\overline{G}",
+                    ],
+                ],
+            ],
+        ],
+    };
+};
+const buildCarParams = () => {
+    const pJeune = randint(10, 40);
+    const pJeuneSinistre = randint(50, 80);
+    const pAutreSinistre = randint(30, 50, [pJeuneSinistre, pJeune]);
+    return {
+        pJeuneIds: pJeune.toTree().toIdentifiers(),
+        pJeuneSinistreIds: pJeuneSinistre.toTree().toIdentifiers(),
+        pAutreSinistreIds: pAutreSinistre.toTree().toIdentifiers(),
+    };
+};
+const getCarSituation = (params) => {
+    const { pJeuneIds, pJeuneSinistreIds, pAutreSinistreIds } = params;
+    const pJeune = reifyAlgebraic(pJeuneIds);
+    const pJeuneSinistre = reifyAlgebraic(pJeuneSinistreIds);
+    const pAutreSinistre = reifyAlgebraic(pAutreSinistreIds);
+    return {
+        id: "car",
+        context: `Dans une compagnie d'assurance, on constate que $${pJeune.toTex()}\\%$ des assurés sont des jeunes conducteurs (moins de $3$ ans de permis). Au cours de l'année précédente, $${pJeuneSinistre.toTex()}\\%$ des jeunes conducteurs ont eu un sinistre, et $${pAutreSinistre.toTex()}\\%$ des autres conducteurs ont eu un sinistre. 
+    
+On choisit un assuré au hasard de cette compagnie et on note les événements $J$ : "L'assuré est un jeune conducteur" et $S$ : "L'assuré a connu un sinistre au cours de l'année précédente".
+`,
+        mainEvent: "J",
+        secondEvent: "S",
+        mainEventProba: pJeune,
+        firstCondProba: pJeuneSinistre,
+        secondCondProba: pAutreSinistre,
+        keys: ["J", "S", "overlineJ", "overlineS", "percent"],
+        tree: [
+            [
+                [
+                    [`${pJeune.toTex()}\\%`, "J"],
+                    [`${substract(100, pJeune).simplify().toTex()}\\%`, "\\overline{J}"],
+                ],
+            ],
+            [
+                [
+                    [`${pJeuneSinistre.toTex()}\\%`, "S"],
+                    [
+                        `${substract(100, pJeuneSinistre).simplify().toTex()}\\%`,
+                        "\\overline{S}",
+                    ],
+                ],
+                [
+                    [`${pAutreSinistre.toTex()}\\%`, "S"],
+                    [
+                        `${substract(100, pAutreSinistre).simplify().toTex()}\\%`,
+                        "\\overline{S}",
+                    ],
+                ],
+            ],
+        ],
+    };
+};
+const buildLyceeParams = () => {
+    const pF = randint(40, 60);
+    const pFMaths = randint(50, 80, [pF]);
+    const pGMaths = randint(30, 70, [pF, pFMaths]);
+    return {
+        pFIds: pF.toTree().toIdentifiers(),
+        pFMathsIds: pFMaths.toTree().toIdentifiers(),
+        pGMathsIds: pGMaths.toTree().toIdentifiers(),
+    };
+};
+const getLyceeSituation = (params) => {
+    const { pFIds, pFMathsIds, pGMathsIds } = params;
+    const pF = reifyAlgebraic(pFIds);
+    const pFMaths = reifyAlgebraic(pFMathsIds);
+    const pGMaths = reifyAlgebraic(pGMathsIds);
+    return {
+        id: "lycee",
+        context: `Parmi les élèves de terminale d'un lycée, $${pF.toTex()}\\%$ sont des filles. $${pFMaths.toTex()}\\%$ des filles et $${pGMaths.toTex()}\\%$ des garçons suivent la spécialité maths. 
+    
+On choisit un élève de terminale au hasard dans ce lycée et on note $F$ l'événement "l'élève est une fille" et $M$ l'événement "l'élève suit la spécialité maths".`,
+        mainEvent: "F",
+        secondEvent: "M",
+        mainEventProba: pF,
+        firstCondProba: pFMaths,
+        secondCondProba: pGMaths,
+        keys: ["F", "M", "overlineF", "overlineM", "percent"],
+        tree: [
+            [
+                [
+                    [`${pF.toTex()}\\%`, "F"],
+                    [`${substract(100, pF).simplify().toTex()}\\%`, "\\overline{F}"],
+                ],
+            ],
+            [
+                [
+                    [`${pFMaths.toTex()}\\%`, "M"],
+                    [`${substract(100, pFMaths).simplify().toTex()}\\%`, "\\overline{M}"],
+                ],
+                [
+                    [`${pGMaths.toTex()}\\%`, "M"],
+                    [`${substract(100, pGMaths).simplify().toTex()}\\%`, "\\overline{M}"],
+                ],
+            ],
+        ],
+    };
+};
+export const getProbaTreeSituation = (params) => {
+    switch (params.id) {
+        case "virus":
+            return getVirusSituation(params);
+        case "dragee":
+            return getDrageeSituation(params);
+        case "usine":
+            return getUsineSituation(params);
+        case "match":
+            return geMatchSituation(params);
+        case "lycee":
+            return getLyceeSituation(params);
+        case "car":
+            return getCarSituation(params);
+    }
+};
+export const buildProbaTreeSituation = () => {
+    const id = random(["virus", "usine", "dragee", "match", "car", "lycee"]);
+    switch (id) {
+        case "virus":
+            return { ...buildVirusParams(), id: "virus" };
+        case "usine":
+            return { ...buildUsineParams(), id: "usine" };
+        case "dragee":
+            return { ...buildDrageeParams(), id: "dragee" };
+        case "match":
+            return { ...buildMatchParams(), id: "match" };
+        case "lycee":
+            return { ...buildLyceeParams(), id: "lycee" };
+        case "car":
+            return { ...buildCarParams(), id: "car" };
+    }
+};

package/lib/exercises/math/probaStat/trees/treeInInstruction.js

@@ -42,7 +42,7 @@ const isAnswerValid = () => {
     }
 };
 const getTreeInInstructionQuestion = () => {
-    const steps = randint(2, 4);
+    // const steps = randint(2, 4);
     const randomBlock = () => {
         const branches = randint(2, 4);
         const isDecimal = coinFlip();
@@ -65,15 +65,15 @@ const getTreeInInstructionQuestion = () => {
     for (let i = 0; i < firstBlockLength; i++) {
         tree[1].push(randomBlock());
     }
-    if (steps === 3) {
-        tree.push([]);
-        tree[1].forEach((block) => {
-            const length = block.length;
-            for (let i = 0; i < length; i++) {
-                tree[2].push(randomBlock());
-            }
-        });
-    }
+    // if (steps === 3) {
+    //   tree.push([]);
+    //   tree[1].forEach((block) => {
+    //     const length = block.length;
+    //     for (let i = 0; i < length; i++) {
+    //       tree[2].push(randomBlock());
+    //     }
+    //   });
+    // }
     const identifiers = {
         tree,
     };

package/lib/exercises/math/sequences/limits/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./sequenceLimitReading.js";
+export {};
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/limits/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/index.ts"],"names":[],"mappings":""}

package/lib/exercises/math/sequences/limits/index.js

@@ -1 +1,2 @@
-export * from "./sequenceLimitReading.js";
+export {};
+// export * from "./sequenceLimitReading.js";

package/lib/exercises/math/trigonometry/functions/cosInequationMainInterval.js

@@ -192,7 +192,7 @@ export const cosInequationMainInterval = {
     id: "cosInequationMainInterval",
     label: "Résoudre une inéquation du type $\\cos(x)\\leq k$ sur $]-\\pi; \\pi]$",
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getCosInequationMainIntervalQuestion(opts), nb, 20),
+    generator: (nb, opts) => getDistinctQuestions(() => getCosInequationMainIntervalQuestion(opts), nb, 15),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -204,5 +204,5 @@ export const cosInequationMainInterval = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    maxAllowedQuestions: 20,
+    maxAllowedQuestions: 15,
 };

package/lib/exercises/vea/percentVEA.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=percentVEA.d.ts.map

package/lib/exercises/vea/percentVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"percentVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/percentVEA.ts"],"names":[],"mappings":""}

package/lib/exercises/vea/percentVEA.js

@@ -0,0 +1 @@
+export {};

package/lib/exercises/vea/varLineVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAmClE,CAAC"}
+{"version":3,"file":"varLineVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/varLineVEA.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,EAAE,EAAE,EAAE,aAAa,MAAM,EAAE,EAAE,YAoClE,CAAC"}

package/lib/exercises/vea/varLineVEA.js

@@ -29,19 +29,22 @@ export const varLineVEA = (ans, answerTable) => {
         return false;
     for (let i = 0; i < flattenedAns.length; i++) {
         const value = flattenedAns[i];
-        if (value === "\\nearrow") {
-            if (flattenedAnswerTable[i] !== "\\nearrow")
+        if (flattenedAnswerTable[i] === "\\nearrow") {
+            if (value !== "\\nearrow")
                 return false;
             continue;
         }
-        else if (value === "\\searrow") {
-            if (flattenedAnswerTable[i] !== "\\searrow")
+        else if (flattenedAnswerTable[i] === "\\searrow") {
+            if (value !== "\\searrow")
                 return false;
             continue;
         }
         else {
-            return ((!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
-                rationalVEA(value, flattenedAnswerTable[i]));
+            const isValid = (!isValue(value) && !isValue(flattenedAnswerTable[i])) ||
+                rationalVEA(value, flattenedAnswerTable[i]);
+            if (!isValid)
+                return false;
+            continue;
         }
     }
     return true;