math-exercises 3.0.156 → 3.0.157

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.3d.js

@@ -0,0 +1,390 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.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";
+const earthGlobeGGBCommands = () => {
+    const radius = 10;
+    const radiusMore = 10.5;
+    const radiusMoreMore = 11;
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //sphere
+        `Sph = Sphere((0,0,0), 0.99 * ${radius})`,
+        `SetColor(Sph, "#d3dde6ff")`,
+        `SetFilling(Sph, 0.84)`,
+        `SetLineThickness(Sph, 1)`,
+        //circles and arcs
+        //méridien
+        `c = Circle((0, 0, ${radius}), (${radius}, 0, 0), (0, 0, -${radius}))`,
+        `SetVisibleInView(c, -1, false)`,
+        `m = Arc(c, (0, 0, ${radius}), (0, 0, -${radius}) )`,
+        `SetColor(m, "${greenMain}")`,
+        `SetLineThickness(m, 3)`,
+        // `SetCaption(m, "$\\footnotesize \\text{Méridien de Greenwich}$")`,
+        // `ShowLabel(m, true)`,
+        //équateur
+        `d = Circle((${radius}, 0, 0), (0, ${radius}, 0), (-${radius}, 0, 0))`,
+        `SetColor(d, "${red}")`,
+        `SetLineThickness(d, 3)`,
+        // `SetCaption(d, "$\\footnotesize \\text{Équateur}$")`,
+        // `ShowLabel(d, true)`,
+        //other circles
+        `A_1 = (${radius}, 0, 0)`,
+        `l1 = Sequence(Rotate(m, nn * 15°, zAxis), nn, 1, 24)`,
+        `l2 = Sequence(Rotate(A_1, nn * 15°, yAxis), nn, -5, 5)`,
+        `l3 = Sequence(z(Element(l2, nn)), nn, 1, Length(l2))`,
+        `l4 = Sequence(x(Element(l2, nn)), nn, 1, Length(l2))`,
+        `l5 = Sequence(Circle((0, 0, Element(l3, nn)), Element(l4, nn), zAxis), nn, 1, Length(l2))`,
+        `SetVisibleInView(l2, -1, false)`, //Use -1 for the 3D View
+        `SetVisibleInView(A_1, -1, false)`,
+        //cercles::parallèles
+        `SetColor(l5, "${red}")`,
+        `SetLineThickness(l5, 1)`,
+        //cercles::méridiens
+        `SetColor(l1, "${greenMain}")`,
+        `SetLineThickness(l1, 1)`,
+        //markers
+        //marqueurs::parallèles
+        `lp0 = Sequence(Rotate((${radiusMore}, 0, 0), nn * 15°, yAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp0, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = -(90 - i * 15);
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P0_{${i}} = Point({x(Element(lp0, ${i})), y(Element(lp0, ${i})), z(Element(lp0, ${i}))})`,
+                `SetPointSize(P0_{${i}}, 1)`,
+                `SetColor(P0_{${i}}, "${red}")`,
+                `SetCaption(P0_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P0_{${i}}, true)`,
+            ];
+        }),
+        `lp2 = Sequence(Rotate(((-${radiusMore}), 0, 0), nn * 15°, yAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp2, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 90 - i * 15;
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P2_{${i}} = Point({x(Element(lp2, ${i})), y(Element(lp2, ${i})), z(Element(lp2, ${i}))})`,
+                `SetPointSize(P2_{${i}}, 1)`,
+                `SetColor(P2_{${i}}, "${red}")`,
+                `SetCaption(P2_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P2_{${i}}, true)`,
+            ];
+        }),
+        `lp1 = Sequence(Rotate((0, -${radiusMore}, 0), nn * 15°, xAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp1, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = -(90 - i * 15);
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P1_{${i}} = Point({x(Element(lp1, ${i})), y(Element(lp1, ${i})), z(Element(lp1, ${i}))})`,
+                `SetPointSize(P1_{${i}}, 1)`,
+                `SetColor(P1_{${i}}, "${red}")`,
+                `SetCaption(P1_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P1_{${i}}, true)`,
+            ];
+        }),
+        `lp3 = Sequence(Rotate((0, ${radiusMore}, 0), nn * 15°, xAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp3, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 90 - i * 15;
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P3_{${i}} = Point({x(Element(lp3, ${i})), y(Element(lp3, ${i})), z(Element(lp3, ${i}))})`,
+                `SetPointSize(P3_{${i}}, 1)`,
+                `SetColor(P3_{${i}}, "${red}")`,
+                `SetCaption(P3_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P3_{${i}}, true)`,
+            ];
+        }),
+        //marqueurs::méridiens
+        `lm0 = Sequence(Rotate((${radiusMoreMore}, 0, 0), nn * 15°, zAxis), nn, -11, 12)`,
+        `SetVisibleInView(lm0, -1, false)`,
+        ...[...Array(24).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 180 - i * 15;
+            let strAngle;
+            if (angleInDegrees == -180 || angleInDegrees == 0) {
+                strAngle = `${angleInDegrees.frenchify()}°`;
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°E`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°O`;
+            }
+            return [
+                `M0_{${i}} = Point({x(Element(lm0, ${i})), y(Element(lm0, ${i})), z(Element(lm0, ${i}))})`,
+                `SetPointSize(M0_{${i}}, 1)`,
+                `SetColor(M0_{${i}}, "black")`,
+                `SetCaption(M0_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(M0_{${i}}, true)`,
+            ];
+        }),
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const spacePointForLatLonPoint = (latlonPoint, radius) => {
+    const { x: lat, y: lon } = latlonPoint;
+    const toRadians = frac(PiNode, 180);
+    const delta = multiply(lat, toRadians);
+    const theta = multiply(lon, toRadians);
+    const chunk = multiply(radius, cos(delta));
+    const x = multiply(chunk, cos(theta));
+    const y = multiply(chunk, sin(theta));
+    const z = multiply(radius, sin(delta));
+    return new SpacePoint("S", x, y, z);
+};
+// const latLonPointForSpacePoint = (
+//   spacePoint: SpacePoint,
+//   center: SpacePoint,
+// ) => {
+//   const { x, y, z } = spacePoint;
+//   const vec3d = SpaceVectorConstructor.fromPoints(
+//     new SpacePoint("O", (0).toTree(), (0).toTree(), (0).toTree()),
+//     spacePoint,
+//   );
+//   const radius = vec3d.getNorm();
+//   const delta = substract(
+//     frac(PiNode, 2),
+//     Math.atan2(y.evaluate(), x.evaluate()),
+//   );
+//   const theta = Math.acos(z.evaluate()) / radius.evaluate();
+//   const toDegrees = frac(180, PiNode).evaluate();
+//   const lat = multiply(delta, toDegrees).evaluate();
+//   const lon = multiply(theta, toDegrees).evaluate();
+//   return new Point("L", lat, lon);
+// };
+const getStrLatitude = (angleInDegrees) => {
+    if (angleInDegrees % 90 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°S`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°N`;
+    }
+};
+const getStrLongitude = (angleInDegrees) => {
+    if (angleInDegrees % 180 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°O`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°E`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { pointsDict, namePointTarget, isLatitude } = identifiers;
+    const propositions = [];
+    const latLonPoints = PointConstructor.fromIdentifiers(pointsDict[namePointTarget].latLon);
+    if (isLatitude) {
+        addValidProp(propositions, getStrLatitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.y.evaluate()));
+        //wrongSign
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.x.evaluate()));
+        //madness
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.x.evaluate()));
+    }
+    else {
+        addValidProp(propositions, getStrLongitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.x.evaluate()));
+        //wrongSign
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.y.evaluate()));
+        //madness
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.y.evaluate()));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pointsDict, namePointTarget, isLatitude } = identifiers;
+    const latLonPoints = PointConstructor.fromIdentifiers(pointsDict[namePointTarget].latLon);
+    if (isLatitude) {
+        return getStrLatitude(latLonPoints.x.evaluate());
+    }
+    else {
+        return getStrLongitude(latLonPoints.y.evaluate());
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isLatitude, namePointTarget } = identifiers;
+    return `Quelle est la ${isLatitude ? "latitude" : "longitude"} du point $${namePointTarget}$ sur la figure ci-dessous ?
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getHint = () => {
+    return `Pour déterminer la latitude, on utlise les parallèles.
+Pour déterminer la longitude, on utilise les méridiens.`;
+};
+const getCorrection = (identifiers) => {
+    const { isLatitude, namePointTarget } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La latitude donne la position Nord/Sud. 
+La longitude donne la position Est/Ouest.
+La ${isLatitude ? "latitude" : "longitude"} du point $${namePointTarget}$ est donc $${answer}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { pointsDict, namePointTarget } = identifiers;
+    const spacePoints = Object.values(pointsDict).map((miniDict) => SpacePointConstructor.fromIdentifiers(miniDict["3d"]));
+    const spacePointTarget = SpacePointConstructor.fromIdentifiers(pointsDict[namePointTarget]["3d"]);
+    const radius = 5;
+    // const zoomInCuboid = [-1, -1, -1, 1, 1, 1].map((v) => v * 0.5);
+    const commands = [
+        ...earthGlobeGGBCommands(),
+        ...spacePoints.flatMap((spacePoint) => spacePoint.toGGBCommand()),
+        // `ZoomIn(${zoomInCuboid.join(",")})`,        //does not work -_-
+        // `ZoomIn(2,${spacePointTarget.toCoords()})`, //does not work -_-
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+        viewDirectionVector: [
+            -spacePointTarget.x.evaluate(),
+            -spacePointTarget.y.evaluate(),
+            -spacePointTarget.z.evaluate(),
+        ],
+    });
+    const xMax = radius;
+    const xMin = -xMax;
+    const yMax = radius;
+    const yMin = -yMax;
+    const zMax = radius;
+    const zMin = -zMax;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getSphereLatLonReadingQuestion = () => {
+    const isLatitude = coinFlip();
+    const radius = 10;
+    const letters = ["A", "B", "C", "D"];
+    const pointsDict = letters.reduce((acc, letter) => {
+        const lat = randint(-4, 5) * 15;
+        const lon = randint(-11, 12) * 15;
+        const latLonPoint = new Point(`LatLon_{letter}`, lat, lon);
+        const spacePoint = spacePointForLatLonPoint(latLonPoint, radius.toTree());
+        spacePoint.name = letter;
+        acc[letter] = {
+            latLon: latLonPoint.toIdentifiers(),
+            "3d": spacePoint.toIdentifiers(),
+        };
+        return acc;
+    }, {});
+    const namePointTarget = random(Object.keys(pointsDict));
+    const identifiers = {
+        isLatitude,
+        pointsDict,
+        namePointTarget,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const sphereLatLonReading = {
+    id: "sphereLatLonReading",
+    label: "Donner la latitude/longitude d'un point sur une sphère",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSphereLatLonReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -14,7 +14,7 @@ const getInstruction = (identifiers) => {
     const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
     return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}\\ \\textrm{cm}$ et $${triangle.angles[givenAngle].toTex()} = ${angleValue}^\\circ$. 
     
-Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1 \\ \\textrm{cm}$.`;
+Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1 \\ \\textrm{cm}$ près.`;
 };
 const getAnswer = (identifiers) => {
     const { sideAsked, triangleIdentifiers } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"setVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/setVEA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,8BAAsB,MAAM;IAC1B,MAAM,CAAC,mBAAmB,GACxB,QAAQ,aAAa,EAAE,EACvB,WAAW,aAAa,EAAE,aA2B1B;CACH"}
+{"version":3,"file":"setVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/setVEA.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,8BAAsB,MAAM;IAC1B,MAAM,CAAC,mBAAmB,GACxB,QAAQ,aAAa,EAAE,EACvB,WAAW,aAAa,EAAE,aAiC1B;CACH"}

package/lib/exercises/vea/setVEA.js

@@ -1,6 +1,10 @@
 import { isNodesEqual } from "./isNodesEqual.js";
 export class SetVEA {
     static isArrayOfNodesValid = (arrAns, arrAnswer) => {
+        const isSameLength = arrAns.length === arrAnswer.length;
+        if (!isSameLength) {
+            return false;
+        }
         const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
         let isValid = true;
         for (let i = 0; i < arrAns.length; i++) {

package/lib/index.d.ts

@@ -464,7 +464,9 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     d: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    answerInputTypes: string[];
+}> | Exercise<{
     a: number;
     b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -499,7 +501,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     isSum: boolean;
     b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    answerInputTypes: string[];
+}> | Exercise<{
     problemSkeletonIndex: number;
     groupNameToVarNameToValue: Record<string, Record<string, import("./tree/nodes/algebraicNode.js").AlgebraicNode>>;
     mysteryVarPath: string;
@@ -2805,6 +2809,11 @@ declare const mathExercises: (Exercise<{
     xValues: number[];
     yValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     atLeastXIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    items: {
+        value: number;
+        indexColor: number;
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     eventIds: {
@@ -3102,6 +3111,19 @@ declare const mathExercises: (Exercise<{
     nbs: number[];
     radius: number;
     isSphere: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointData: {
+        latLon: import("./math/geometry/point.js").PointIdentifiers;
+        "2d": import("./math/geometry/point.js").PointIdentifiers;
+    };
+    isLatitude: boolean;
+    namePointTarget: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointsDict: Record<string, {
+        latLon: import("./math/geometry/point.js").PointIdentifiers;
+        "2d": import("./math/geometry/point.js").PointIdentifiers;
+    }>;
+    namePointTarget: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexFamily: number;
     indexPattern: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/utils/arrays/dichoFilter.d.ts

@@ -0,0 +1,2 @@
+export declare function dichoFilter<T>(arr: T[], funcFilter: (elt: T) => boolean): [T[], T[]];
+//# sourceMappingURL=dichoFilter.d.ts.map

package/lib/utils/arrays/dichoFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dichoFilter.d.ts","sourceRoot":"","sources":["../../../src/utils/arrays/dichoFilter.ts"],"names":[],"mappings":"AAKA,wBAAgB,WAAW,CAAC,CAAC,EAC3B,GAAG,EAAE,CAAC,EAAE,EACR,UAAU,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,GAC9B,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAQZ"}

package/lib/utils/arrays/dichoFilter.js

@@ -0,0 +1,11 @@
+/*
+  Returns two arrays
+  - first is the array with filtered elements
+  - second is the array with filtered-out elements
+*/
+export function dichoFilter(arr, funcFilter) {
+    return arr.reduce((acc, elt) => {
+        acc[funcFilter(elt) ? 0 : 1].push(elt);
+        return acc;
+    }, [[], []]);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.156",
+  "version": "3.0.157",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [