math-exercises 2.2.77 → 2.2.79

package/lib/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPointFromAxialSymetry = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const circle_1 = require("../../../../math/geometry/circle");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const getInstruction = (identifiers) => {
+    return `Placer le point $A'$, symétrique du point $A$ par rapport à la droite $d$.`;
+};
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+const getSolutionPoint = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const line = line_1.LineConstructor.fromIdentifiers(identifiers.line);
+    return point.axialSymetric(line, "A'");
+};
+const getGGBAnswer = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const sol = getSolutionPoint(identifiers);
+    const perp = new line_1.Line(point, sol);
+    const center = point.midpoint(sol);
+    const circle = new circle_1.Circle(center, point, "C");
+    return [
+        ...sol.toGGBCommand(),
+        ...perp.toGGBCommands(false),
+        ...circle.toGGBCommands(false),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const line = line_1.LineConstructor.fromIdentifiers(identifiers.line);
+    const commands = [
+        ...point.toGGBCommand(),
+        ...line.toGGBCommands(false, {
+            showLabel: true,
+        }),
+    ];
+    const sol = getSolutionPoint(identifiers);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            orthogonal: true,
+            circleTwoPoints: true,
+            point: true,
+            intersect: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([point, sol]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A"].includes(c[0]));
+    const points = (0, parseGGBPoints_1.parseGGBPoints)(studentAns)
+        .map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p))
+        .map((coords) => new point_1.Point("K", coords.x, coords.y));
+    if (!points.length)
+        return false;
+    const solution = getSolutionPoint(identifiers);
+    if (points.some((p) => p.distanceTo(solution) < 0.001))
+        return true;
+    return false;
+};
+const getBuildPointFromAxialSymetryQuestion = () => {
+    const linePoints = point_1.PointConstructor.randomDifferent(2, {
+        names: ["B", "C"],
+    });
+    const line = new line_1.Line(linePoints[0], linePoints[1], "d");
+    const point = point_1.PointConstructor.random("A");
+    const identifiers = {
+        point: point.toIdentifiers(),
+        line: line.toIdentifiers(),
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers)
+    };
+    return question;
+};
+exports.buildPointFromAxialSymetry = {
+    id: "buildPointFromAxialSymetry",
+    label: "Construire le symétrique d'un point par rapport à une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getBuildPointFromAxialSymetryQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./buildMediatriceWithCompass";
 export * from "./buildTriangleWithSizes";
 export * from "./pointImageFromTranslation";
+export * from "./buildPointFromAxialSymetry";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./buildMediatriceWithCompass"), exports);
 __exportStar(require("./buildTriangleWithSizes"), exports);
 __exportStar(require("./pointImageFromTranslation"), exports);
+__exportStar(require("./buildPointFromAxialSymetry"), exports);

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

@@ -19,4 +19,5 @@ export * from "./spaceGeometry";
 export * from "./squareRoots";
 export * from "./trigonometry";
 export * from "./python";
+export * from "./sampling";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/lib/exercises/math/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./spaceGeometry"), exports);
 __exportStar(require("./squareRoots"), exports);
 __exportStar(require("./trigonometry"), exports);
 __exportStar(require("./python"), exports);
+__exportStar(require("./sampling"), exports);

package/lib/exercises/math/percent/applyPercent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applyPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/applyPercent.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAmFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAwB9C,CAAC"}
+{"version":3,"file":"applyPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/applyPercent.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAoFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAwB9C,CAAC"}

package/lib/exercises/math/percent/applyPercent.js

@@ -65,6 +65,8 @@ const getPropositions = (n, { answer }) => {
     (0, exercise_1.addValidProp)(propositions, answer);
     while (propositions.length < n) {
         const ansNb = Number(answer.replace(",", "."));
+        if (ansNb === 0)
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
         const deviation = Math.random() < 0.5 ? -1 : 1;
         const percentDeviation = Math.random() * 20 + 1;
         let wrongAnswer = ansNb + deviation * (percentDeviation / 100) * ansNb;

package/lib/exercises/math/percent/findEndValueAfterEvolution.d.ts

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

package/lib/exercises/math/percent/findEndValueAfterEvolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findEndValueAfterEvolution.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findEndValueAfterEvolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/percent/findEndValueAfterEvolution.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEndValueAfterEvolution = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const round_1 = require("../../../math/utils/round");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const euroParser_1 = require("../../../tree/parsers/euroParser");
+const alignTex_1 = require("../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../utils/latex/approxOrEqual");
+const getPropositions = (n, { answer, percentRate, vd }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const cm = 1 + percentRate / 100;
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(vd * percentRate, 2).frenchify());
+    const invCm = 1 - percentRate / 100;
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(vd * invCm, 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, randfloat_1.randfloat)(1, 100, 2), 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const cm = 1 + identifiers.percentRate / 100;
+    const vf = (0, round_1.round)(identifiers.vd * cm, 2);
+    return vf.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    return `Le prix initial d'un objet est $${identifiers.vd.frenchify()}€$. Quel sera son prix après une ${evolution} de $${identifiers.percentRate.frenchify()}\\%$ ? Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Transforme le taux d'évolution en coefficient multiplicateur. Puis, multiplie le prix initial par ce coefficient multiplicateur.`;
+};
+const getCorrection = (identifiers) => {
+    const evolution = identifiers.percentRate < 0 ? "baisse" : "hausse";
+    const answer = getAnswer(identifiers);
+    const cm = (0, round_1.round)(1 + identifiers.percentRate / 100, 4);
+    const vd = identifiers.vd;
+    const percentRate = identifiers.percentRate;
+    return `Le coefficient multiplicateur associé à une ${evolution} de $${percentRate.frenchify()}\\%$ est : 
+      
+${(0, alignTex_1.alignTex)([
+        ["CM", "=", "1+\\frac{t}{100}"],
+        ["", "=", `1+\\frac{${percentRate.frenchify()}}{100}`],
+        ["", "=", cm.frenchify()],
+    ])}
+
+Si on note $V_d$ la valeur de départ et $V_a$ la valeur d'arrivée, alors on sait que :
+
+$$
+V_d\\times CM = V_a
+$$
+
+Le prix final arrondi au centième est donc : 
+
+${(0, alignTex_1.alignTex)([
+        ["V_a", "=", (0, multiplyNode_1.multiply)(vd.frenchify(), cm.frenchify()).toTex()],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(cm * vd, 2)],
+    ])}
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, euroParser_1.euroParser)(ans) === answer + "€";
+};
+const getFindEndValueAfterEvolutionQuestion = () => {
+    const vd = (0, randfloat_1.randfloat)(1, 100, 2);
+    const percentRate = (0, randfloat_1.randfloat)(-100, 100, 2, [0]);
+    const identifiers = {
+        vd,
+        percentRate,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.findEndValueAfterEvolution = {
+    id: "findEndValueAfterEvolution",
+    connector: "=",
+    label: "Retrouver un prix final à partir du prix initial et du taux d'évolution",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFindEndValueAfterEvolutionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getCorrection,
+    getHint,
+    hasHintAndCorrection: true,
+};

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

@@ -14,4 +14,5 @@ export * from "./evolutionRateFromValues";
 export * from "./findStartValueAfterEvolution";
 export * from "./subPopulationEffectifFromPercent";
 export * from "./populationEffectifFromSubPopulation";
+export * from "./findEndValueAfterEvolution";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC"}

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

@@ -30,3 +30,4 @@ __exportStar(require("./evolutionRateFromValues"), exports);
 __exportStar(require("./findStartValueAfterEvolution"), exports);
 __exportStar(require("./subPopulationEffectifFromPercent"), exports);
 __exportStar(require("./populationEffectifFromSubPopulation"), exports);
+__exportStar(require("./findEndValueAfterEvolution"), exports);

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

@@ -7,4 +7,5 @@ export * from "./powersOfTenToDecimal";
 export * from "./powersPower";
 export * from "./powersProduct";
 export * from "./scientificToDecimal";
+export * from "./powersMixOperations";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

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

@@ -23,3 +23,4 @@ __exportStar(require("./powersOfTenToDecimal"), exports);
 __exportStar(require("./powersPower"), exports);
 __exportStar(require("./powersProduct"), exports);
 __exportStar(require("./scientificToDecimal"), exports);
+__exportStar(require("./powersMixOperations"), exports);

package/lib/exercises/math/powers/powersMixOperations.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    k: number;
+    l: number;
+    m: number;
+};
+export declare const powersMixOperations: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersMixOperations.d.ts.map

package/lib/exercises/math/powers/powersMixOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwFF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

package/lib/exercises/math/powers/powersMixOperations.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersMixOperations = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const powerParser_1 = require("../../../tree/parsers/powerParser");
+const doWhile_1 = require("../../../utils/doWhile");
+const getStatementNode = (identifiers) => {
+    const { a, b, k, l, m } = identifiers;
+    const n = k + l * m;
+    return (0, fractionNode_1.frac)((0, multiplyNode_1.multiply)((0, powerNode_1.power)(a, k), (0, powerNode_1.power)((0, powerNode_1.power)(a, l), m)), (0, powerNode_1.power)(b, n));
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { a, b, k, l, m } = identifiers;
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const ratio = (0, fractionNode_1.frac)(a, b).simplify();
+    while (propositions.length < n) {
+        const rand = (0, randint_1.randint)(2, 10);
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, powerNode_1.power)(ratio, rand).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const statement = getStatementNode(identifiers);
+    return statement.simplify({ keepPowers: true }).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Écrire sous la forme d'une seule puissance : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = (0, powerParser_1.powerParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ keepPowers: true }).toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getPowersMixOperationsQuestion = (ops) => {
+    const finalPower = (0, randint_1.randint)(2, 10);
+    const a = (0, randint_1.randint)(2, 10);
+    const b = (0, randint_1.randint)(2, 10, [a]);
+    const l = (0, randint_1.randint)(-5, 6, [0, 1]);
+    const m = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(2, 6), (x) => x * l === finalPower);
+    const k = finalPower - l * m;
+    const identifiers = {
+        a,
+        b,
+        k,
+        l,
+        m,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.powersMixOperations = {
+    id: "powersMixOperations",
+    connector: "=",
+    label: "Calculs avec des puissances : mélange d'opérations",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersMixOperationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/sampling/confidenceInterval.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    k: number;
+    n: number;
+    wordingType: number;
+};
+export declare const confidenceInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=confidenceInterval.d.ts.map

package/lib/exercises/math/sampling/confidenceInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"confidenceInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/confidenceInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAyHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}

package/lib/exercises/math/sampling/confidenceInterval.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confidenceInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const intervalParser_1 = require("../../../tree/parsers/intervalParser");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const alignTex_1 = require("../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../utils/latex/approxOrEqual");
+const getPropositions = (nb, { answer, n, k, wordingType }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < nb) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({
+            n: (0, coinFlip_1.coinFlip)() ? n : 50 * (0, randint_1.randint)(1, 20),
+            k: (0, coinFlip_1.coinFlip)() ? k : (0, randfloat_1.randfloat)(0.2, 0.8, 2),
+            wordingType,
+        }));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, nb);
+};
+const getAnswer = (identifiers) => {
+    const { k, n } = identifiers;
+    const freq = k / n;
+    const oneOverSqrt = 1 / Math.sqrt(n);
+    const a = (0, round_1.round)(freq - oneOverSqrt, 2);
+    const b = (0, round_1.round)(freq + oneOverSqrt, 2);
+    return new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure_1.ClosureType.FF).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { k, n, wordingType } = identifiers;
+    switch (wordingType) {
+        case 1:
+            return `Un sondage effectué au sein d'un lycée montre que $${k}$ des $${n}$ élèves ont subi du harcèlement scolaire au lycée. À partir de ce sondage, à quel intervalle devrait appartenir la proportion nationale $p$ du harcèlement scolaire au lycée, au seuil de $95\\%$ ?`;
+        case 2:
+            return `Une étude sur la consommation de boissons énergétiques révèle que, sur un échantillon de $${n}$ personnes, $${k}$ déclarent en consommer régulièrement. À partir de cette étude, à quel intervalle devrait appartenir la proportion nationale $p$ de consomateurs de boissons énergétiques, au seuil de $95\\%$ ?`;
+        case 3:
+        default:
+            return `Une enquête relève que sur un échantillon de $${n}$ collégiens, $${k}$ utilisent les réseaux sociaux quotidiennement. À partir de cette enquête, à quel intervalle devrait appartenir la proportion nationale $p$ de collégiens qui utilisent les réseaux sociaux quotidiennement, au seuil de $95\\%$ ?`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Si $f$ est la fréquence observée et $n$ est la taille de l'échantillon, alors l'intervalle de confiance au seuil de $95\\%$ est : 
+  
+$$
+\\left[f-\\frac{1}{\\sqrt{n}}; f+\\frac{1}{\\sqrt{n}}\\right]
+$$
+
+Cela signifie qu'on peut affirmer avec un taux de certitude de $95\\%$ que la proportion théorique est comprise entre $f-\\frac{1}{\\sqrt{n}}$ et $f+\\frac{1}{\\sqrt{n}}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { k, n } = identifiers;
+    const freq = (0, round_1.round)(k / n, 2);
+    const oneOverSqrt = 1 / Math.sqrt(n);
+    const answer = getAnswer(identifiers);
+    const a = (0, substractNode_1.substract)(freq, (0, fractionNode_1.frac)(1, (0, sqrtNode_1.sqrt)(n))).toTex();
+    const b = (0, addNode_1.add)(freq, (0, fractionNode_1.frac)(1, (0, sqrtNode_1.sqrt)(n))).toTex();
+    return `La fréquence observée $f$ est $f = ${(0, fractionNode_1.frac)(k, n).toTex()} ${(0, approxOrEqual_1.approxOrEqual)(k / n, 2).join("")}$. 
+  
+La taille de l'échantillon $n$ est $n = ${n.frenchify()}$.
+
+On sait que l'intervalle de confiance au seuil de $95\\%$ est : 
+  
+$$
+\\left[f-\\frac{1}{\\sqrt{n}}; f+\\frac{1}{\\sqrt{n}}\\right]
+$$
+
+On peut donc affirmer avec un taux de certitude de $95\\%$ que la probabilité théorique $p$  devrait appartenir à l'intervalle : 
+
+${(0, alignTex_1.alignTex)([
+        ["", `\\left[ ${a} ; ${b} \\right]`],
+        ["=", answer],
+    ])}  
+  `;
+};
+const getKeys = (identifiers) => {
+    return ["lbracket", "semicolon", "rbracket"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = (0, intervalParser_1.intervalParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getConfidenceIntervalQuestion = (ops) => {
+    const n = 50 * (0, randint_1.randint)(1, 20);
+    const k = (0, randint_1.randint)(10, n - 10);
+    const identifiers = {
+        k,
+        n,
+        wordingType: (0, randint_1.randint)(1, 4),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.confidenceInterval = {
+    id: "confidenceInterval",
+    connector: "=",
+    label: "Déterminer l'intervalle de confiance au seuil de $95\\%$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getConfidenceIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sampling/fluctuationInterval.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    p: number;
+    n: number;
+    wordingType: number;
+};
+export declare const fluctuationInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=fluctuationInterval.d.ts.map

package/lib/exercises/math/sampling/fluctuationInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluctuationInterval.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/fluctuationInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAiHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}