math-exercises 3.0.144 → 3.0.146

package/lib/exercises/math/calcul/mentalCaluls/mentalFractionageOfQuantity.js

@@ -0,0 +1,412 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { isDecimalFraction } from "../../../../math/numbers/fractions/isDecimalFraction.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getFractionNode = (fractionNodeFunc, defaultNode) => {
+    let fractionNode;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const fractionNodeCandidate = fractionNodeFunc().simplify();
+        isValid = isFractionNode(fractionNodeCandidate);
+        // &&(fractionNodeCandidate as FractionNode).leftChild.evaluate() !== 1;
+        if (isValid) {
+            fractionNode = fractionNodeCandidate;
+        }
+    }
+    return fractionNode ?? defaultNode;
+};
+const createRandomSituation = (funcStrFrenchUnitFrom, funcStrFrenchUnitFromOf, strFrenchUnitTo, strUnitTo, coeff, maxDivider, funcA, funcFractionNode) => {
+    return {
+        instruction: (nodeIdsFrac, a) => {
+            const fractionNode = NodeConstructor.fromIdentifiers(nodeIdsFrac);
+            return `Combien vaut $${fractionNode.toTex()}$ ${funcStrFrenchUnitFromOf(a)}, en ${strFrenchUnitTo}s ?`;
+        },
+        hint: (nodeIdsFrac, a) => {
+            const fractionNode = NodeConstructor.fromIdentifiers(nodeIdsFrac);
+            const nodeDen = fractionNode.rightChild;
+            if (coeff !== 1) {
+                return `Cherche d'abord combien de fois $${nodeDen.toTex()}$ il y a dans $${coeff.frenchify()}$.`;
+            }
+            else {
+                return `Cherche d'abord combien fait $${a.frenchify()}$ divisé par $${nodeDen.toTex()}$.`;
+            }
+        },
+        correction: (nodeIdsFrac, a, coeff) => {
+            const fractionNode = NodeConstructor.fromIdentifiers(nodeIdsFrac);
+            const b = a * coeff;
+            const nodeNum = fractionNode.leftChild;
+            const nodeDen = fractionNode.rightChild;
+            const node1OverDen = frac(1, nodeDen);
+            const nodeCoeffOverDen = frac(coeff, nodeDen);
+            const nodeAOverDen = frac(a, nodeDen);
+            const answerNode = multiply(fractionNode, b).simplify();
+            const num = nodeNum.evaluate();
+            return `${(() => {
+                if (coeff !== 1) {
+                    return `Dans ${funcStrFrenchUnitFrom(a)}, il y a $${a.frenchify()} \\times ${coeff.frenchify()}$ ${strFrenchUnitTo}s.`;
+                }
+                else {
+                    return ``;
+                }
+            })()}
+ 
+Prendre la fraction d'un nombre, c'est le multiplier par cette fraction.
+
+${(() => {
+                if (num === 1) {
+                    if (coeff !== 1) {
+                        return `
+          
+${alignTex([
+                            [
+                                `${fractionNode.toTex()} \\times (${a.frenchify()} \\times ${coeff.frenchify()})`,
+                                "=",
+                                `${a.frenchify()} \\times ${nodeCoeffOverDen.toTex()}`,
+                            ],
+                            [``, "=", `${a.frenchify()} \\times ${nodeCoeffOverDen.simplify().toTex()}`],
+                            [``, "=", `${answerNode.toTex()}`],
+                        ])}
+
+`;
+                    }
+                    else {
+                        return `
+          
+${alignTex([
+                            [
+                                `${fractionNode.toTex()} \\times ${a.frenchify()}`,
+                                "=",
+                                `${nodeAOverDen.toTex()}`,
+                            ],
+                            [``, "=", `${answerNode.toTex()}`],
+                        ])}
+
+`;
+                    }
+                }
+                else {
+                    if (coeff !== 1) {
+                        return `
+          
+${alignTex([
+                            [
+                                `${fractionNode.toTex()} \\times (${a.frenchify()} \\times ${coeff.frenchify()})`,
+                                "=",
+                                `${nodeNum.toTex()} \\times ${node1OverDen.toTex()} \\times ${a.frenchify()} \\times ${coeff.frenchify()}`,
+                            ],
+                            [
+                                ``,
+                                "=",
+                                `${nodeNum.toTex()} \\times ${a.frenchify()} \\times ${nodeCoeffOverDen.toTex()}`,
+                            ],
+                            [
+                                ``,
+                                "=",
+                                `${(num * a).frenchify()} \\times ${nodeCoeffOverDen.simplify().toTex()}`,
+                            ],
+                            [``, "=", `${answerNode.toTex()}`],
+                        ])}
+
+`;
+                    }
+                    else {
+                        return `
+          
+${alignTex([
+                            [
+                                `${fractionNode.toTex()} \\times ${a.frenchify()}`,
+                                "=",
+                                `${nodeNum.toTex()} \\times ${node1OverDen.toTex()} \\times ${a.frenchify()}`,
+                            ],
+                            [``, "=", `${nodeNum.toTex()} \\times ${nodeAOverDen.toTex()}`],
+                            [``, "=", `${num.frenchify()} \\times ${nodeAOverDen.simplify().toTex()}`],
+                            [``, "=", `${answerNode.toTex()}`],
+                        ])}
+
+`;
+                    }
+                }
+            })()}
+
+La quantité recherchée est $${answerNode.toTex()} \\ \\textrm{${strUnitTo}}$.
+`;
+        },
+        propositions: (nodeIdsFrac, a, coeff, n) => {
+            const propositions = [];
+            const fractionNode = NodeConstructor.fromIdentifiers(nodeIdsFrac);
+            const b = a * coeff;
+            const nodeNum = fractionNode.leftChild;
+            const nodeDen = fractionNode.rightChild;
+            const nodeBOverDen = frac(b, nodeDen);
+            const answerNode = multiply(fractionNode, b).simplify();
+            addValidProp(propositions, answerNode.toTex());
+            //num * b
+            tryToAddWrongProp(propositions, multiply(nodeNum, b).simplify().toTex());
+            //b / den
+            tryToAddWrongProp(propositions, frac(b, nodeDen).simplify().toTex());
+            //frac times a
+            const nodeFracTimesA = multiply(fractionNode, a).simplify();
+            if (isDecimalFraction(nodeFracTimesA)) {
+                tryToAddWrongProp(propositions, nodeFracTimesA.simplify({ fractionsToDecimal: true }).toTex());
+            }
+            //around answer
+            const valueAnswer = answerNode.evaluate();
+            //in tables
+            const numbersOneToTen = [...Array(10).keys()].map((i) => i + 1);
+            const tableNumbersSortedAsc = [
+                ...new Set(numbersOneToTen.flatMap((n1) => numbersOneToTen.map((n2) => n1 * n2))),
+            ].toSorted((n1, n2) => n1 - n2);
+            const tableNumbersCloseToAnswer = tableNumbersSortedAsc.filter((n) => Math.abs(valueAnswer - n) <= 10);
+            randomMany(tableNumbersCloseToAnswer, Math.min(5, tableNumbersCloseToAnswer.length)).forEach((n) => {
+                tryToAddWrongProp(propositions, n.frenchify());
+            });
+            //fuzzy
+            const node60OverDen = frac(60, nodeDen).simplify();
+            const offsetFuzzy = !isFractionNode(node60OverDen)
+                ? node60OverDen.evaluate()
+                : nodeBOverDen.evaluate();
+            propWhile(propositions, n, () => {
+                tryToAddWrongProp(propositions, Math.max(1, valueAnswer + randint(-5, 5, [0]) * offsetFuzzy).frenchify());
+            });
+            return shuffleProps(propositions, n);
+        },
+        randValues: () => {
+            const a = funcA();
+            const fractionNode = getFractionNode(() => funcFractionNode(a, coeff, maxDivider), frac(5, 12));
+            return {
+                nodeIdsFrac: fractionNode.toIdentifiers(),
+                a,
+                coeff,
+            };
+        },
+    };
+};
+const situationsDict = {
+    durée: [
+        createRandomSituation((a) => (a === 1 ? `un jour` : `$${a}$ jours`), (a) => (a === 1 ? `de jour` : `de $${a}$ jours`), "heure", "h", 24, 12, () => randint(2, 11), (_, coeff, maxDivider) => {
+            const denPool = dividersOf(coeff).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => (a === 1 ? `une heure` : `$${a}$ heures`), (a) => (a === 1 ? `d'heure` : `de $${a}$ heures`), "minute", "min", 60, 15, () => randint(2, 11), (_, coeff, maxDivider) => {
+            const denPool = dividersOf(coeff).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => (a === 1 ? `une minute` : `$${a}$ minutes`), (a) => (a === 1 ? `de minute` : `de $${a}$ minutes`), "seconde", "s", 60, 15, () => randint(2, 11), (_, coeff, maxDivider) => {
+            const denPool = dividersOf(coeff).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+    ],
+    masse: [
+        createRandomSituation((a) => `une tablette de chocolat de $${a.frenchify()}$ grammes`, (a) => `d'une tablette de chocolat de $${a.frenchify()}$ grammes`, "gramme", "g", 1, 20, () => {
+            return random([
+                90, 100, 120, 140, 150, 160, 180, 200, 210, 220, 240, 260,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => `une motte de beurre de $${a.frenchify()}$ grammes`, (a) => `d'une motte de beurre de $${a.frenchify()}$ grammes`, "gramme", "g", 1, 20, () => {
+            return random([
+                260, 270, 280, 300, 320, 330, 340, 350, 360, 380, 390, 400, 420, 440,
+                450, 460, 480, 490, 500, 510, 520, 540, 550, 560, 570, 580, 600, 620,
+                630, 640, 650, 660, 680, 690, 700, 720, 740, 750, 760, 770, 780, 800,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => `une botte de foin de de $${a.frenchify()} \\ \\textrm{kg}`, (a) => `d'une botte de foin de de $${a.frenchify()} \\ \\textrm{kg}$`, "kilogramme", "kg", 1, 20, () => {
+            return random([
+                60, 80, 90, 100, 120, 140, 150, 160, 180, 200, 210, 220, 240, 260,
+                270, 280, 300, 320, 330, 340, 350, 360, 380, 390, 400, 420, 440, 450,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+    ],
+    longueur: [
+        createRandomSituation((a) => `une planche de $${a.frenchify()}$ centimètres`, (a) => `d'une planche de $${a.frenchify()}$ centimètres`, "centimètre", "cm", 1, 20, () => {
+            return random([
+                90, 100, 120, 140, 150, 160, 180, 200, 210, 220, 240, 260, 270, 280,
+                300, 320, 330, 340, 350, 360, 380, 390, 400,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => `une piste de $${a.frenchify()}$ mètres`, (a) => `d'une piste de $${a.frenchify()}$ mètres`, "mètre", "m", 1, 20, () => {
+            return random([
+                1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100, 2200,
+                2300, 2400, 2500, 2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+                3400, 3500, 3600,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+    ],
+    valeur: [
+        createRandomSituation((a) => `un crédit de $${a.frenchify()} \\ \\textrm{€}$`, (a) => `d'un crédit de $${a.frenchify()} \\ \\textrm{€}$`, "euro", "€", 1, 20, () => {
+            return random([
+                90000, 100000, 120000, 140000, 150000, 160000, 180000, 200000, 210000,
+                220000, 240000, 260000, 270000, 280000, 300000, 320000, 330000,
+                340000, 350000, 360000, 380000, 390000, 400000, 420000, 440000,
+                450000, 460000, 480000, 490000, 500000, 510000, 520000, 540000,
+                550000, 560000, 570000, 580000, 600000,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+        createRandomSituation((a) => `une facture de $${a.frenchify()} \\ \\textrm{€}$`, (a) => `d'une facture de $${a.frenchify()} \\ \\textrm{€}$`, "euro", "€", 1, 20, () => {
+            return random([
+                100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 1100, 1200, 1300,
+                1400, 1500, 1600, 1700, 1800, 1900,
+            ]);
+        }, (a, _, maxDivider) => {
+            const denPool = dividersOf(a).filter((v) => 
+            // v !== 1 &&
+            v <= maxDivider);
+            const den = random(denPool);
+            const num = randint(1, den);
+            return frac(num, den);
+        }),
+    ],
+};
+const getInstruction = (identifiers) => {
+    const { quantityType, situationIndex, nodeIdsFrac, a } = identifiers;
+    const situations = situationsDict[quantityType];
+    const situation = situations[situationIndex];
+    return situation.instruction(nodeIdsFrac, a);
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsFrac, coeff, a } = identifiers;
+    const fractionNode = NodeConstructor.fromIdentifiers(nodeIdsFrac);
+    const b = a * coeff;
+    const answerNode = multiply(fractionNode, b).simplify();
+    return answerNode;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { quantityType, situationIndex, nodeIdsFrac, a } = identifiers;
+    const situations = situationsDict[quantityType];
+    const situation = situations[situationIndex];
+    return situation.hint(nodeIdsFrac, a);
+};
+const getCorrection = (identifiers) => {
+    const { quantityType, situationIndex, nodeIdsFrac, a, coeff } = identifiers;
+    const situations = situationsDict[quantityType];
+    const situation = situations[situationIndex];
+    return situation.correction(nodeIdsFrac, a, coeff);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { quantityType, situationIndex, nodeIdsFrac, a, coeff } = identifiers;
+    const situations = situationsDict[quantityType];
+    const situation = situations[situationIndex];
+    return situation.propositions(nodeIdsFrac, a, coeff, n);
+};
+const isAnswerValid = (studentAns, { answer }) => {
+    return rationalVEA(studentAns, answer, {
+        allowNonIrreductible: true,
+        allowDecimal: true,
+    });
+};
+const getMentalFractionageOfQuantity = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const quantityType = random(opts.quantityTypes);
+    const situations = situationsDict[quantityType];
+    const situationIndex = randint(0, situationsDict[quantityType].length);
+    const situation = situations[situationIndex];
+    const { a, coeff, nodeIdsFrac } = situation.randValues();
+    const identifiers = { quantityType, situationIndex, a, coeff, nodeIdsFrac };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+    return question;
+};
+const options = [
+    {
+        id: "quantityTypes",
+        label: "Types de quantités",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["durée", "masse", "longueur", "valeur"],
+        defaultValue: ["durée", "masse", "longueur", "valeur"],
+    },
+];
+const optsDefault = {
+    quantityTypes: ["durée", "masse", "longueur", "valeur"],
+};
+export const mentalFractionageOfQuantity = {
+    id: "mentalFractionageOfQuantity",
+    connector: "=",
+    label: "Prendre la fraction d'une quantité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMentalFractionageOfQuantity(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalProgramSolve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalProgramSolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AA4BzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAqOF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB7D,CAAC"}
+{"version":3,"file":"mentalProgramSolve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalProgramSolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AA4BzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAiOF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB7D,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.js

@@ -81,12 +81,10 @@ const getInstruction = (identifiers, opts) => {
     const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
     const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
     const strOpening = `Voici un programme de calcul :`;
-    const strChooseANumber = `Choisir un nombre
-    
-`;
-    const arrStrProgCalc = progCalc.getArrOfFrenchStrings().map((str) => `
-  
-${str}`);
+    const strChooseANumber = `Choisir un nombre`;
+    const arrStrProgCalc = progCalc
+        .getArrOfFrenchStrings()
+        .map((str) => `> ${str}\n> \n`);
     const strProgCalc = arrStrProgCalc.reduce((acc, str) => acc + str);
     const strFinalNumber = opts?.numberType == "Entier"
         ? nodeFinalNumber.evaluate().frenchify()
@@ -98,8 +96,8 @@ ${str}`);
     return `
 ${strOpening}
 
-${strChooseANumber}
-
+> ${strChooseANumber}
+> 
 ${strProgCalc}
 
 ${strQuestion}

package/lib/exercises/math/calcul/proportionality/isTableProportionalNonInteger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isTableProportionalNonInteger.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/isTableProportionalNonInteger.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkCF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAqGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBxE,CAAC"}
+{"version":3,"file":"isTableProportionalNonInteger.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/isTableProportionalNonInteger.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAmEF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAqGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBxE,CAAC"}

package/lib/exercises/math/calcul/proportionality/isTableProportionalNonInteger.js

@@ -3,8 +3,9 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { NodeConstructor, reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
@@ -32,8 +33,38 @@ ${mdTable([xTexs.map((v) => dollarize(v)), yTexs.map((v) => dollarize(v))])}
 
   `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = () => {
+    return `Pour passer de la ligne du haut à la ligne du bas, multiplie-t-on toujours par le même nombre ? Si oui, alors c'est un tableau de proportionnalité.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues, isProportionnal } = identifiers;
+    const xs = xValues.map((n) => reifyAlgebraic(n));
+    const ys = yValues.map((n) => reifyAlgebraic(n));
+    return `On divise les nombres de la deuxième ligne par les nombres de la première ligne. Si on obtient toujours le même résultat, alors c'est un tableau de proportionnalité. 
+
+- $${ys[0].toTex()}\\div ${xs[0].toTex()} = ${frac(ys[0], xs[0])
+        .simplify({
+        fractionsToDecimal: true,
+    })
+        .toTex()}$
+
+- $${ys[1].toTex()}\\div ${xs[1].toTex()} = ${frac(ys[1], xs[1])
+        .simplify({
+        fractionsToDecimal: true,
+    })
+        .toTex()}$
+
+- $${ys[2].toTex()}\\div ${xs[2].toTex()} = ${frac(ys[2], xs[2])
+        .simplify({
+        fractionsToDecimal: true,
+    })
+        .toTex()}$
+
+${isProportionnal
+        ? "Puisque tous les résultats sont égaux, c'est bien un tableau de proportionnalité."
+        : "Puisque les résultats ne sont pas tous égaux, ce n'est pas un tableau de proportionnalité."}
+    `;
+};
 const getKeys = () => {
     return [];
 };
@@ -85,8 +116,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers),
         answerFormat: "raw",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         style: {
             tableHasNoHeader: true,
         },
@@ -128,8 +159,7 @@ export const isTableProportionalNonInteger = {
     freeTimer: 60,
     getPropositions,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    hasHintAndCorrection: true,
     getAnswer,
     answerType: "QCU",
     options,

package/lib/exercises/math/calcul/ratio/index.d.ts

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

package/lib/exercises/math/calcul/ratio/index.d.ts.map

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

package/lib/exercises/math/calcul/ratio/index.js

@@ -0,0 +1,2 @@
+export * from "./partUsingRatio.js";
+// export * from "./ratioFromParts.js"; //erreur à fix

package/lib/exercises/math/calcul/ratio/partUsingRatio.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    ratioType: string;
+    situationIndex: number;
+    total: number;
+    ratio: number[];
+    indexPart: number;
+};
+type Options = {
+    ratioTypes: string[];
+};
+export declare const partUsingRatio: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=partUsingRatio.d.ts.map

package/lib/exercises/math/calcul/ratio/partUsingRatio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partUsingRatio.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ratio/partUsingRatio.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AA0BrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2aF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC"}