math-exercises 3.0.144 → 3.0.146

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.js

@@ -0,0 +1,452 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+function highlighted(str) {
+    return `{ \\color{green} ${str} }`;
+}
+const situations = [
+    //1<->100
+    //   (() => {
+    //     const isRealizingEvent = (v0: number, v1: number) => {
+    //       return v0 * 100 === v1;
+    //     };
+    //     return {
+    //       instruction: (values: number[][]) => {
+    //         return `Dans un porte-monnaie, il y a $${
+    //           values[0].length
+    //         }$ pièces différentes et $${values[1].length}$ billets différents.
+    // Les valeurs des pièces sont ${joinanded(
+    //           values[0].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`),
+    //           ", ",
+    //           " et ",
+    //         )}.
+    // Les valeurs des billets sont ${joinanded(
+    //           values[1].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`),
+    //           ", ",
+    //           " et ",
+    //         )}.
+    // Lisa prend au hasard une pièce et un billet dans ce porte-monnaie.
+    // Quelle est la probabilité de l'évènement "La pièce a la même valeur en centimes que le billet en euros" ?
+    // `;
+    //       },
+    //       correction: (values: number[][]) => {
+    //         const cartesianProduct = getCartesiansProducts(values);
+    //         const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) =>
+    //           isRealizingEvent(v0, v1),
+    //         );
+    //         const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+    //         const nbIssuesTotal = values[0].length * values[1].length;
+    //         const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+    //         return `On peut construire le tableau ci-dessous :
+    // ${mdTable([
+    //   ["Lisa", ...values[0].map(() => ``)],
+    //   [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+    //   ...values[1].map((v1) => [
+    //     `$${v1.frenchify()}\\ \\textrm{€}$`,
+    //     ...values[0].map((v0) => {
+    //       const strStd = `(${v1.frenchify()};${v0.frenchify()})`;
+    //       if (isRealizingEvent(v0, v1)) {
+    //         return `$${highlighted(strStd)}$`;
+    //       } else {
+    //         return `$${strStd}$`;
+    //       }
+    //     }),
+    //   ]),
+    // ])}
+    // Il y a $${nbIssuesSatisfyingE}$ issue${
+    //           nbIssuesSatisfyingE !== 1 ? "s" : ""
+    //         } qui réalise${
+    //           nbIssuesSatisfyingE !== 1 ? "nt" : ""
+    //         } l'évènement "La pièce a la même valeur en centimes que le billet en euros".
+    // Il y a $${nbIssuesTotal}$ issues au total.
+    // La probabilité recherchée est donc $${nodeP.toTex()}$`;
+    //       },
+    //       randValues: () => {
+    //         const [l1, l2] = randomMany([2, 3, 4], 2);
+    //         return [
+    //           randomMany([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2], l1).toSorted(
+    //             (n1, n2) => n1 - n2,
+    //           ),
+    //           randomMany([5, 10, 20, 50, 100, 200], l2).toSorted(
+    //             (n1, n2) => n1 - n2,
+    //           ),
+    //         ];
+    //       },
+    //       answerNode: (values: number[][]) => {
+    //         const cartesianProduct = getCartesiansProducts(values);
+    //         const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) =>
+    //           isRealizingEvent(v0, v1),
+    //         );
+    //         const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+    //         const nbIssuesTotal = values[0].length * values[1].length;
+    //         const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+    //         return nodeP;
+    //       },
+    //     };
+    //   })(),
+    //even digits
+    (() => {
+        const isRealizingEvent = (v0, v1) => {
+            const vSum = v0 + v1;
+            const strSum = vSum.toString().replace(".", "");
+            return strSum.split("").every((s) => Number(s) % 2 === 0);
+        };
+        return {
+            instruction: (values) => {
+                return `Dans un porte-monnaie, il y a $${values[0].length}$ pièces différentes et $${values[1].length}$ billets différents.
+Les valeurs des pièces sont ${joinanded(values[0].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Les valeurs des billets sont ${joinanded(values[1].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Salomé prend au hasard une pièce et un billet dans ce porte-monnaie.
+
+Quelle est la probabilité de l'évènement "La valeur de la somme en euros contient uniquement des chiffres pairs" ?
+`;
+            },
+            correction: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+                return `On peut construire le tableau ci-dessous :
+${mdTable([
+                    ["Somme en euros", ...values[0].map(() => ``)],
+                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    ...values[1].map((v1) => [
+                        `$${v1.frenchify()}\\ \\textrm{€}$`,
+                        ...values[0].map((v0) => {
+                            const strStd = `${(v0 + v1).frenchify()}`;
+                            if (isRealizingEvent(v0, v1)) {
+                                return `$${highlighted(strStd)}$`;
+                            }
+                            else {
+                                return `$${strStd}$`;
+                            }
+                        }),
+                    ]),
+                ])}
+
+Il y a $${nbIssuesSatisfyingE}$ issue${nbIssuesSatisfyingE !== 1 ? "s" : ""} qui réalise${nbIssuesSatisfyingE !== 1 ? "nt" : ""} l'évènement "La valeur de la somme en euros contient uniquement des chiffres pairs".
+Il y a $${nbIssuesTotal}$ issues au total.
+La probabilité recherchée est donc :
+
+$$
+${nodeP.toSimplificationTex()}
+$$`;
+            },
+            randValues: () => {
+                const [l1, l2] = randomMany([2, 3, 4], 2);
+                return [
+                    randomMany([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2], l1).toSorted((n1, n2) => n1 - n2),
+                    randomMany([5, 10, 20, 50, 100, 200], l2).toSorted((n1, n2) => n1 - n2),
+                ];
+            },
+            answerNode: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal).simplify();
+                return nodeP;
+            },
+        };
+    })(),
+    //2 fois le même chiffre(!==0)
+    (() => {
+        const isRealizingEvent = (v0, v1) => {
+            const vSum = v0 + v1;
+            const strSum = vSum.frenchify();
+            const arrOccurences = [...Array(9).keys()]
+                .map((i) => i + 1)
+                .map((i) => strSum.split("").filter((c) => c === `${i}`).length);
+            return arrOccurences.includes(2);
+        };
+        return {
+            instruction: (values) => {
+                return `Dans un porte-monnaie, il y a $${values[0].length}$ pièces différentes et $${values[1].length}$ billets différents.
+Les valeurs des pièces sont ${joinanded(values[0].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Les valeurs des billets sont ${joinanded(values[1].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Léo prend au hasard une pièce et un billet dans ce porte-monnaie.
+
+Quelle est la probabilité de l'évènement "La valeur de la somme en euros contient deux fois le même chiffre (différent de $0$)" ?
+`;
+            },
+            correction: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+                return `On peut construire le tableau ci-dessous :
+${mdTable([
+                    ["Somme", ...values[0].map(() => ``)],
+                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    ...values[1].map((v1) => [
+                        `$${v1.frenchify()}\\ \\textrm{€}$`,
+                        ...values[0].map((v0) => {
+                            const strStd = `${(v0 + v1).frenchify()}`;
+                            if (isRealizingEvent(v0, v1)) {
+                                return `$${highlighted(strStd)}$`;
+                            }
+                            else {
+                                return `$${strStd}$`;
+                            }
+                        }),
+                    ]),
+                ])}
+
+Il y a $${nbIssuesSatisfyingE}$ issue${nbIssuesSatisfyingE !== 1 ? "s" : ""} qui réalise${nbIssuesSatisfyingE !== 1 ? "nt" : ""} l'évènement "La valeur de la somme en euros contient deux fois le même chiffre (différent de $0$)".
+Il y a $${nbIssuesTotal}$ issues au total.
+La probabilité recherchée est donc :
+
+$$
+${nodeP.toSimplificationTex()}
+$$`;
+            },
+            randValues: () => {
+                const [l1, l2] = randomMany([2, 3, 4], 2);
+                return [
+                    randomMany([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2], l1).toSorted((n1, n2) => n1 - n2),
+                    randomMany([5, 10, 20, 50, 100, 200], l2).toSorted((n1, n2) => n1 - n2),
+                ];
+            },
+            answerNode: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal).simplify();
+                return nodeP;
+            },
+        };
+    })(),
+    //xGame: geq 10
+    (() => {
+        const isRealizingEvent = (v0, v1) => {
+            return v0 * v1 >= 10;
+        };
+        return {
+            instruction: (values) => {
+                return `Dans un jeu, on tire au hasard une somme de base et un multiplicateur.
+Les sommes de base sont ${joinanded(values[0].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Les multiplicateurs sont ${joinanded(values[1].map((v) => `$\\times ${v.frenchify()}$`), ", ", " et ")}.
+Jean tente sa chance.
+Quelle est la probabilité de l'évènement "La somme gagnée est supérieure ou égale à $10 \\ \\textrm{€}$" ?
+`;
+            },
+            correction: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+                return `On peut construire le tableau ci-dessous :
+${mdTable([
+                    ["Somme en euros", ...values[0].map(() => ``)],
+                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    ...values[1].map((v1) => [
+                        `$\\times ${v1.frenchify()}$`,
+                        ...values[0].map((v0) => {
+                            const strStd = `${round(v0 * v1, 4).frenchify()}`;
+                            if (isRealizingEvent(v0, v1)) {
+                                return `$${highlighted(strStd)}$`;
+                            }
+                            else {
+                                return `$${strStd}$`;
+                            }
+                        }),
+                    ]),
+                ])}
+
+Il y a $${nbIssuesSatisfyingE}$ issue${nbIssuesSatisfyingE !== 1 ? "s" : ""} qui réalise${nbIssuesSatisfyingE !== 1 ? "nt" : ""} l'évènement "La somme gagnée est supérieure ou égale à $10 \\ \\textrm{€}$".
+Il y a $${nbIssuesTotal}$ issues au total.
+La probabilité recherchée est donc :
+
+$$
+${nodeP.toSimplificationTex()}
+$$`;
+            },
+            randValues: () => {
+                const [l1, l2] = randomMany([2, 3, 4], 2);
+                return [
+                    randomMany([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2], l1).toSorted((n1, n2) => n1 - n2),
+                    randomMany([1, 2, 5, 10, 20, 50, 100], l2).toSorted((n1, n2) => n1 - n2),
+                ];
+            },
+            answerNode: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal).simplify();
+                return nodeP;
+            },
+        };
+    })(),
+    //xGame: contains 1
+    (() => {
+        const isRealizingEvent = (v0, v1) => {
+            const vProduct = v0 * v1;
+            return vProduct.frenchify().includes("1");
+        };
+        return {
+            instruction: (values) => {
+                return `Dans un jeu, on tire au hasard une somme de base et un multiplicateur.
+Les sommes de base sont ${joinanded(values[0].map((v) => `$${v.frenchify()}\\ \\textrm{€}$`), ", ", " et ")}.
+Les multiplicateurs sont ${joinanded(values[1].map((v) => `$\\times ${v.frenchify()}$`), ", ", " et ")}.
+Karima tente sa chance.
+Quelle est la probabilité de l'évènement "La somme gagnée contient le chiffre $1$" ?
+`;
+            },
+            correction: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal);
+                return `On peut construire le tableau ci-dessous :
+${mdTable([
+                    ["Somme gagnée", ...values[0].map(() => ``)],
+                    [``, ...values[0].map((v0) => `$${v0.frenchify()}\\ \\textrm{€}$`)],
+                    ...values[1].map((v1) => [
+                        `$\\times ${v1.frenchify()}$`,
+                        ...values[0].map((v0) => {
+                            const strStd = `${round(v0 * v1, 4).frenchify()}`;
+                            if (isRealizingEvent(v0, v1)) {
+                                return `$${highlighted(strStd)}$`;
+                            }
+                            else {
+                                return `$${strStd}$`;
+                            }
+                        }),
+                    ]),
+                ])}
+
+Il y a $${nbIssuesSatisfyingE}$ issue${nbIssuesSatisfyingE !== 1 ? "s" : ""} qui réalise${nbIssuesSatisfyingE !== 1 ? "nt" : ""} l'évènement "La somme gagnée contient le chiffre $1$".
+Il y a $${nbIssuesTotal}$ issues au total.
+La probabilité recherchée est donc :
+
+$$
+${nodeP.toSimplificationTex()}
+$$`;
+            },
+            randValues: () => {
+                const [l1, l2] = randomMany([2, 3, 4], 2);
+                return [
+                    randomMany([0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2], l1).toSorted((n1, n2) => n1 - n2),
+                    randomMany([1, 2, 5, 10, 20, 50, 100], l2).toSorted((n1, n2) => n1 - n2),
+                ];
+            },
+            answerNode: (values) => {
+                const cartesianProduct = getCartesiansProducts(values);
+                const issuesSatisfyingE = cartesianProduct.filter(([v0, v1]) => isRealizingEvent(v0, v1));
+                const nbIssuesSatisfyingE = issuesSatisfyingE.length;
+                const nbIssuesTotal = values[0].length * values[1].length;
+                const nodeP = frac(nbIssuesSatisfyingE, nbIssuesTotal).simplify();
+                return nodeP;
+            },
+        };
+    })(),
+];
+const getInstruction = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(values);
+};
+const getAnswerNode = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.answerNode(values);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Tu peux dresser un tableau avec les différentes issues et compter combien réalisent l'évènement demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(values);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { values } = identifiers;
+    const answerNode = getAnswerNode(identifiers);
+    const nbTotal = values[0].length * values[1].length;
+    const nbIssuesSatisfyingE = multiply(answerNode, nbTotal)
+        .simplify()
+        .evaluate();
+    const propositions = [];
+    const isSimplify = coinFlip();
+    addValidProp(propositions, (isSimplify ? answerNode.simplify() : answerNode).toTex());
+    //nbIssuesSatisfyingE
+    if (nbIssuesSatisfyingE !== 0) {
+        tryToAddWrongProp(propositions, nbIssuesSatisfyingE.frenchify());
+    }
+    //frac{1}{nbIssuesSatisfyingE}
+    if (nbIssuesSatisfyingE !== 0) {
+        tryToAddWrongProp(propositions, frac(1, nbIssuesSatisfyingE).simplify().toTex());
+    }
+    //random around
+    [-2, -1, +1, +2, +3, +4].forEach((offset) => {
+        const nbIssuesSatisfyingEWrong = nbIssuesSatisfyingE + offset;
+        if (nbIssuesSatisfyingEWrong >= 0) {
+            tryToAddWrongProp(propositions, frac(nbIssuesSatisfyingEWrong, nbTotal).toTex());
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTwoStepExperimentProbasQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const values = situation.randValues();
+    const identifiers = { situationIndex, values };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const twoStepExperimentProbas = {
+    id: "twoStepExperimentProbas",
+    label: "Calculer la probabilité d'un évènement dans une expérience à deux épreuves avec équiprobabilité",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getTwoStepExperimentProbasQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/python/pythonWhileStatementOperationCompletion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythonWhileStatementOperationCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonWhileStatementOperationCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IAEjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuGF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAqBzE,CAAC"}
+{"version":3,"file":"pythonWhileStatementOperationCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonWhileStatementOperationCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IAEjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0GF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAqBzE,CAAC"}

package/lib/exercises/math/python/pythonWhileStatementOperationCompletion.js

@@ -97,6 +97,9 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        keyboardOptions: {
+            timesShouldProduceStar: true,
+        },
     };
 };
 export const pythonWhileStatementOperationCompletion = {

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./scratchLoopStepsCount.js";

package/lib/exercises/math/scratch/scratchLoopStepsCount.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    repeatCount: number;
+    stepsCount: number;
+};
+export declare const scratchLoopStepsCount: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchLoopStepsCount.d.ts.map

package/lib/exercises/math/scratch/scratchLoopStepsCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchLoopStepsCount.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchLoopStepsCount.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA2EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/scratch/scratchLoopStepsCount.js

@@ -0,0 +1,85 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(1, 10).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (identifiers.repeatCount * identifiers.stepsCount).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">quand @greenFlag est cliqué
+répéter (${identifiers.repeatCount}) fois
+    avancer de (${identifiers.stepsCount}) pas
+fin</svg>
+
+Au total, de combien de pas a-t-on avancé ?`;
+};
+const getHint = (identifiers) => {
+    const { repeatCount, stepsCount } = identifiers;
+    return `À chaque fois qu'on passe dans la boucle, on avance de $${stepsCount}$ pas. On répète cette boucle $${repeatCount}$ fois. Au total, de combien de pas avance-t-on ?`;
+};
+const getCorrection = (identifiers) => {
+    const { repeatCount, stepsCount } = identifiers;
+    return `À chaque fois qu'on passe dans la boucle, on avance de $${stepsCount}$ pas. 
+  
+On répète la boucle $${repeatCount}$ fois. 
+
+Au total, on avance donc de $${repeatCount} \\times ${stepsCount} = ${repeatCount * stepsCount}$ pas.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTestScratchQuestion = () => {
+    const identifiers = {
+        repeatCount: randint(2, 11),
+        stepsCount: randint(2, 11),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const scratchLoopStepsCount = {
+    id: "scratchLoopStepsCount",
+    connector: "=",
+    label: "Compter le nombre de pas dans une boucle en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestScratchQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/testScratch.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    repeatCount: number;
+    stepsCount: number;
+};
+export declare const testScratch: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=testScratch.d.ts.map

package/lib/exercises/math/scratch/testScratch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testScratch.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/testScratch.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

package/lib/exercises/math/scratch/testScratch.js

@@ -0,0 +1,79 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(1, 10).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return (identifiers.repeatCount * identifiers.stepsCount).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `On donne le programme Scratch ci-dessous :
+
+<svg id="scratch">quand @greenFlag est cliqué
+répéter (${identifiers.repeatCount}) fois
+    avancer de (${identifiers.stepsCount}) pas
+fin</svg>
+
+Au total, de combien de pas a-t-on avancé ?`;
+};
+const getHint = () => {
+    return `indice`;
+};
+const getCorrection = () => {
+    return `correction`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTestScratchQuestion = () => {
+    const identifiers = {
+        repeatCount: randint(2, 11),
+        stepsCount: randint(2, 11),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const testScratch = {
+    id: "testScratch",
+    connector: "=",
+    label: "Test Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestScratchQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};