math-exercises 3.0.149 → 3.0.151

package/lib/exercises/math/spaceGeometry/sections/recognizeSectionsOfSphereOrBall.js

@@ -0,0 +1,236 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { strOfX, radius, isDiameterGiven } = identifiers;
+    return `Parmi les propositions suivantes, lesquelles peuvent être des sections planes ${strOfX} de ${isDiameterGiven ? "diamètre" : "rayon"} $${(isDiameterGiven ? 2 * radius : radius).frenchify()}\\ \\textrm{cm}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { strOfX } = identifiers;
+    if (strOfX === "d'une sphère") {
+        return "Est-ce qu'une sphère est pleine ?";
+    }
+    else {
+        return "Est-ce qu'une boule est creuse ?";
+    }
+};
+const getCorrection = (identifiers) => {
+    const { strOfX, radius } = identifiers;
+    if (strOfX === "d'une sphère") {
+        return `On s'intéresse aux sections planes ${strOfX} de rayon $${radius} \\ \\textrm{cm}$.
+Les sections planes possibles sont : 
+- un point (quand le plan est tangent à la sphère)
+- tous les cercles de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$.
+
+La sphère est "creuse", les sections planes sont "creuses" elles aussi.`;
+    }
+    else {
+        return `On s'intéresse aux sections planes ${strOfX} de rayon $${radius} \\ \\textrm{cm}$.
+Les sections planes possibles sont : 
+- un point (quand le plan est tangent à la boule)
+- tous les disques de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$.
+
+La boule est "pleine", les sections planes sont "pleines" elles aussi.`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strOfX, radius } = identifiers;
+    const propositions = [];
+    if (strOfX === "d'une sphère") {
+        const validPool = [
+            "un point",
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un cercle de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidPool = [
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un disque de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un disque de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "une ellipse", "un cône"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    else {
+        const validPool = [
+            "un point",
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un disque de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un disque de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidPool = [
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un cercle de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $1,5 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "une ellipse", "un cône"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSectionsOfSphereOrBallQuestion = () => {
+    const strOfX = random(["d'une sphère", "d'une boule"]);
+    const radius = randint(5, 21);
+    const isDiameterGiven = coinFlip();
+    const identifiers = { strOfX, radius, isDiameterGiven };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSectionsOfSphereOrBall = {
+    id: "recognizeSectionsOfSphereOrBall",
+    connector: "=",
+    label: "Reconnaître la nature d'une section de sphère ou de boule",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRecognizeSectionsOfSphereOrBallQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/pc/mathExosInPC.d.ts

@@ -7,10 +7,10 @@ export * from "../math/calcul/mentalCaluls/mentalAddAndSub.js";
 export { log10PowerSimplifying } from "../math/functions/logarithm/log10PowerSimplifying.js";
 export { log10SumSimplifying } from "../math/functions/logarithm/log10Simplifying.js";
 export { log10PowerEquation } from "../math/functions/logarithm/logPowerEquation.js";
-export * from "../math/calculLitteral/equation/equa1.js";
-export * from "../math/calculLitteral/equation/equa2.js";
-export * from "../math/calculLitteral/equation/equa3.js";
-export * from "../math/calculLitteral/equation/equa4.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa1.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa2.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa3.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa4.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos.js";
 export * from "../math/geometry/vectors/coordinatesReading.js";

package/lib/exercises/pc/mathExosInPC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}
+{"version":3,"file":"mathExosInPC.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/mathExosInPC.ts"],"names":[],"mappings":"AAAA,yBAAyB;AACzB,cAAc,mCAAmC,CAAC;AAClD,cAAc,wDAAwD,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,uCAAuC,CAAC;AACtD,cAAc,gDAAgD,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,sDAAsD,CAAC;AAC7F,OAAO,EAAE,mBAAmB,EAAE,MAAM,iDAAiD,CAAC;AACtF,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC;AACjF,cAAc,+DAA+D,CAAC;AAC9E,cAAc,gDAAgD,CAAC;AAC/D,cAAc,sDAAsD,CAAC;AACrE,cAAc,mCAAmC,CAAC;AAClD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qDAAqD,CAAC;AACpE,cAAc,0CAA0C,CAAC;AACzD,cAAc,2DAA2D,CAAC;AAC1E,cAAc,uDAAuD,CAAC;AACtE,cAAc,6DAA6D,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,mEAAmE,CAAC;AAC1G,OAAO,EAAE,sBAAsB,EAAE,MAAM,oEAAoE,CAAC;AAC5G,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}

package/lib/exercises/pc/mathExosInPC.js

@@ -7,10 +7,10 @@ export * from "../math/calcul/mentalCaluls/mentalAddAndSub.js";
 export { log10PowerSimplifying } from "../math/functions/logarithm/log10PowerSimplifying.js";
 export { log10SumSimplifying } from "../math/functions/logarithm/log10Simplifying.js";
 export { log10PowerEquation } from "../math/functions/logarithm/logPowerEquation.js";
-export * from "../math/calculLitteral/equation/equa1.js";
-export * from "../math/calculLitteral/equation/equa2.js";
-export * from "../math/calculLitteral/equation/equa3.js";
-export * from "../math/calculLitteral/equation/equa4.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa1.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa2.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa3.js";
+export * from "../math/calculLitteral/equation/firstDegree/equa4.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCoords.js";
 export * from "../math/geometry/vectors/scalarProduct/scalarProductViaCos.js";
 export * from "../math/geometry/vectors/coordinatesReading.js";

package/lib/index.d.ts

@@ -459,20 +459,6 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     a: number;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    isXRight: boolean;
-    aNumberType: string;
-}, {
-    aNumberType: string[];
-}> | Exercise<{
-    a: number;
-    b: number;
-    c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    b: number;
     c: number;
     d: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -483,26 +469,6 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
-    c: number;
-    d: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    b: number;
-    x: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    x: number;
-    b: number;
-    c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    x: number;
-    b: number;
-    c: number;
-    d: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     type: number;
     vars: {
@@ -566,6 +532,47 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}, {
+    solutionFormat: string;
+}> | Exercise<{
+    a: number;
+    b: number;
+    x: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    x: number;
+    b: number;
+    c: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    x: number;
+    b: number;
+    c: number;
+    d: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -1034,6 +1041,7 @@ declare const mathExercises: (Exercise<{
     yB: number;
 }, {
     functionType?: string;
+    coefType?: string;
 }> | Exercise<{
     xA: number;
     xB: number;
@@ -1065,7 +1073,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     isAskingA: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    parameter: string;
+}> | Exercise<{
     xValues: number[];
     yValues: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1119,7 +1129,9 @@ declare const mathExercises: (Exercise<{
         isAnswer: boolean;
     }[];
     isLinear: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    functionType: string;
+}> | Exercise<{
     coeffs: number[];
     yValue: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2049,7 +2061,9 @@ declare const mathExercises: (Exercise<{
     isSegmentHeight: boolean;
     pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
     lengths: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    theorem: string;
+}> | Exercise<{
     point: string;
     line: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2174,6 +2188,23 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    namePoints1: string[];
+    namePoints2: string[];
+    nodeIdsLengths1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    nodeIdsLengths2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {
+    numberTypesForLengths: ("Entier" | "D\u00E9cimal")[];
+    numberTypesForCoeffs: ("Entier" | "D\u00E9cimal" | "Fraction")[];
+}> | Exercise<{
+    triangleNames: string[];
+    sameAngleValue: number;
+    firstAngleValue: number;
+    secondAngleValue: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds1: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    triangleIds2: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     perimeter: number;
     askingX: boolean;
@@ -2657,6 +2688,13 @@ declare const mathExercises: (Exercise<{
     max: number;
     target: number;
     isIncluded: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    proba: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    knownEffectif: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    atLeastXIndex: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     eventIds: {
@@ -2892,6 +2930,50 @@ declare const mathExercises: (Exercise<{
     h: number;
     askedPoint: string;
     givenPoints: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strOfX: string;
+    radius: number;
+    isDiameterGiven: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nothing: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+}, {
+    planeTypes: string[];
+}> | Exercise<{
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+}, {
+    planeTypes: string[];
+}> | Exercise<{
+    AB: number;
+    AD: number;
+    AE: number;
+    offset: number;
+    planeType: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sqrtOperand: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3126,10 +3208,6 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     points: number[][];
     labels: string[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    bounds: number[];
-    data: number[];
-    itemAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     quartiles: number[];
     arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
@@ -3220,6 +3298,30 @@ declare const mathExercises: (Exercise<{
         }[];
         p: number;
     }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
+    itemAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isMax: boolean;
+    bounds: number[];
+    data: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    histogram: {
+        bounds: number[];
+        data: number[];
+    };
+    table: {
+        bounds: number[];
+        data: number[];
+    } | undefined;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
+    initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    bounds: number[];
+    data: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     epsilon: number;
     l: number;
@@ -3564,7 +3666,92 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     repeatCount: number;
     stepsCount: number;
-}, Record<string, string | boolean | string[]>>)[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    repeatCount: number;
+    isGreaterCond1: boolean;
+    thresholdCond1: number;
+    offsetCond1True: number;
+    offsetCond1False: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    yStart: number;
+    tStart: number;
+    steps: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    loops: {
+        repeatCount: number;
+        isGreaterCond1: boolean;
+        thresholdCond1: number;
+        offsetCond1True: number;
+    }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    yStart: number;
+    rand: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    dictVars: Record<string, number>;
+    varNameDst: string;
+    nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    repeatCount: number;
+    offset1: number;
+    isFoolish: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    dictVars: Record<string, number>;
+    arrMutationIds: [string, import("./tree/nodes/nodeConstructor.js").NodeIdentifiers][];
+    varNameAsked: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strStart: string;
+    repeatCount: number;
+    strAppend1: string;
+    rand: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strStart: string;
+    repeatCount: number;
+    isGreaterCond1: boolean;
+    thresholdCond1: number;
+    arrStrAppend: string[];
+    arrRand: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strStart: string;
+    repeatCount: number;
+    strBoundLow: string;
+    strBoundHigh: string;
+    arrStrAppend: string[];
+    arrRand: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    strStart: string;
+    repeatCount: number;
+    strIncludes1: string;
+    strIncludes2: string;
+    arrStrAppend: string[];
+    arrRand: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xStart: number;
+    factorStart: number;
+    condition: {
+        isNOT: boolean;
+        isGreaterCond1: boolean;
+        thresholdCond1: number;
+    } | {
+        isAND: boolean;
+        conditions: {
+            isNOT: boolean;
+            isGreaterCond1: boolean;
+            thresholdCond1: number;
+        }[];
+    };
+    offsetCondTrue: number;
+}, {
+    isAllowAND: boolean;
+    isAllowOR: boolean;
+    isAllowNOT: boolean;
+}>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3576,23 +3763,30 @@ declare const pcExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     b: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isXRight: boolean;
     aNumberType: string;
 }, {
     aNumberType: string[];
+    solutionFormat: string;
 }> | Exercise<{
     a: number;
     b: number;
     c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
     d: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    solutionFormat: string;
+}> | Exercise<{
     coefficients: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coefficients: number[];