math-exercises 3.0.150 → 3.0.151

package/lib/exercises/math/geometry/triangles/similar/isSimilarTrianglesWrtSideLengths.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    namePoints1: string[];
+    namePoints2: string[];
+    nodeIdsLengths1: NodeIdentifiers[];
+    nodeIdsLengths2: NodeIdentifiers[];
+};
+type Options = {
+    numberTypesForLengths: ("Entier" | "Décimal")[];
+    numberTypesForCoeffs: ("Entier" | "Décimal" | "Fraction")[];
+};
+export declare const isSimilarTrianglesWrtSideLengths: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=isSimilarTrianglesWrtSideLengths.d.ts.map

package/lib/exercises/math/geometry/triangles/similar/isSimilarTrianglesWrtSideLengths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSimilarTrianglesWrtSideLengths.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/triangles/similar/isSimilarTrianglesWrtSideLengths.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiC7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,eAAe,EAAE,eAAe,EAAE,CAAC;CACpC,CAAC;AA6XF,KAAK,OAAO,GAAG;IACb,qBAAqB,EAAE,CAAC,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAC;IAChD,oBAAoB,EAAE,CAAC,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC,EAAE,CAAC;CAC7D,CAAC;AAwBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBzE,CAAC"}

package/lib/exercises/math/geometry/triangles/similar/isSimilarTrianglesWrtSideLengths.js

@@ -0,0 +1,351 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../../math/numbers/integer/primes.js";
+import { gcd } from "../../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { NodeConstructor, } 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 { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { joinanded } from "../../../../../utils/strings/joinanded.js";
+const getNAllDigits = (n) => {
+    const strN = n.frenchify();
+    if (strN.includes(",")) {
+        const [leftOfSep, rightOfSep] = strN.split(",");
+        const roundTo = 1;
+        const nAllDigits = parseInt(leftOfSep + rightOfSep.slice(0, roundTo));
+        return nAllDigits;
+    }
+    else {
+        return n;
+    }
+};
+const extendedGcd = (n1, n2) => {
+    try {
+        const [n1AllDigits, n2AllDigits] = [n1, n2].map(getNAllDigits);
+        const commonDivisor = gcd(n1AllDigits, n2AllDigits);
+        return commonDivisor;
+    }
+    catch (_) {
+        return 1;
+    }
+};
+const getHydratedObjs = (identifiers) => {
+    const { nodeIdsLengths1, nodeIdsLengths2, namePoints1, namePoints2 } = identifiers;
+    const [nodeLengths1, nodeLengths2] = [nodeIdsLengths1, nodeIdsLengths2].map((arrNodeIds) => arrNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).simplify({
+        fractionsToDecimal: true,
+    })));
+    const [nameTriangle1, nameTriangle2] = [namePoints1, namePoints2].map((pointNames) => pointNames.join(""));
+    const [nameSegments1, nameSegments2] = [namePoints1, namePoints2].map((pointNames) => [
+        [0, 1],
+        [1, 2],
+        [2, 0],
+    ].map(([i1, i2]) => `${pointNames[i1]}${pointNames[i2]}`));
+    return {
+        nodeLengths1,
+        nodeLengths2,
+        nameTriangle1,
+        nameTriangle2,
+        nameSegments1,
+        nameSegments2,
+    };
+};
+const isSimilar = (identifiers) => {
+    const { nodeLengths1, nodeLengths2 } = getHydratedObjs(identifiers);
+    const [nodeLengths1SortedAsc, nodeLengths2SortedAsc] = [
+        nodeLengths1,
+        nodeLengths2,
+    ].map((nodeLengths) => nodeLengths.toSorted((node1, node2) => node1.evaluate() - node2.evaluate()));
+    const nodeCoeffs = nodeLengths2SortedAsc.map((nodeLength2, i) => frac(nodeLength2, nodeLengths1SortedAsc[i]));
+    const nodeCoeff0 = nodeCoeffs[0].simplify();
+    return nodeCoeffs.slice(1).every((nodeCoeff) => {
+        return (substract(nodeCoeff.simplify(), nodeCoeff0).simplify().evaluate() === 0);
+    });
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["Oui", "Non"].forEach((strProp) => {
+        if (strProp === answerFromIdentifiers) {
+            addValidProp(propositions, strProp, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strProp, "raw");
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    return isSimilar(identifiers) ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { nodeLengths1, nodeLengths2, nameTriangle1, nameTriangle2, nameSegments1, nameSegments2, } = getHydratedObjs(identifiers);
+    return `Soit $${nameTriangle1}$ un triangle tel que ${joinanded(nameSegments1.map((nameSegment, i) => `$${nameSegment} = ${nodeLengths1[i].toTex()} \\ \\textrm{cm}$`), ", ", " et ")}.
+Soit $${nameTriangle2}$ un triangle tel que ${joinanded(nameSegments2.map((nameSegment, i) => `$${nameSegment} = ${nodeLengths2[i].toTex()} \\ \\textrm{cm}$`), ", ", " et ")}.
+
+Les triangles $${nameTriangle1}$ et $${nameTriangle2}$ sont-ils semblables ?`;
+};
+const getHint = (identifiers) => {
+    const { namePoints1, namePoints2 } = identifiers;
+    const [nameTriangle1, nameTriangle2] = [namePoints1, namePoints2].map((pointNames) => pointNames.join(""));
+    return `Regarde si tu peux trouver un coefficient de proportionnalité entre les longueurs de $${nameTriangle1}$ et celles de $${nameTriangle2}$ (même prises dans un autre ordre).`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeLengths1, nodeLengths2, nameTriangle1, nameTriangle2 } = getHydratedObjs(identifiers);
+    const [nodeLengths1SortedAsc, nodeLengths2SortedAsc] = [
+        nodeLengths1,
+        nodeLengths2,
+    ].map((nodeLengths) => nodeLengths.toSorted((node1, node2) => node1.evaluate() - node2.evaluate()));
+    const nodeCoeffs = nodeLengths2SortedAsc.map((nodeLength2, i) => frac(nodeLength2, nodeLengths1SortedAsc[i]));
+    const isSim = isSimilar(identifiers);
+    return `Pour ne pas avoir à tester tous les cas possibles, pour chaque triangle, on range les longueurs par ordre croissant.
+
+Pour $${nameTriangle1}$ : 
+
+$$
+${nodeLengths1SortedAsc.map((node) => node.toTex()).join(" < ")}
+$$
+
+Pour $${nameTriangle2}$ :
+
+$$
+${nodeLengths2SortedAsc.map((node) => node.toTex()).join(" < ")}
+$$
+
+On regarde ensuite si les rapports $\\frac{\\text{longueur dans ${nameTriangle2}}}{\\text{longueur dans ${nameTriangle1}}}$ sont tous égaux.
+
+On a :
+
+${alignTex([0, 1, 2].map((i) => [
+        `${nodeCoeffs[i].toTex()}`,
+        "=",
+        `${nodeCoeffs[i].simplify({ fractionsToDecimal: true }).toTex()}`,
+    ]))}
+
+Les triangles $${nameTriangle1}$ et $${nameTriangle2}$ ${isSim ? "sont donc semblables" : "ne sont donc pas semblables"}.`;
+};
+const getIsSimilarTrianglesWrtSideLengthsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    function createRandomNodeCoeff(numberTypeForCoeff) {
+        switch (numberTypeForCoeff) {
+            // case "Fraction":
+            //   {
+            //     return RationalConstructor.randomIrreductible().toTree();
+            //   }
+            //   break;
+            case "Décimal":
+                {
+                    return round(randint(1, 20) + 0.1 * randint(1, 10), 1)
+                        .toTree()
+                        .simplify({ fractionsToDecimal: true });
+                }
+                break;
+            default:
+            case "Entier":
+                {
+                    return randint(2, 10).toTree();
+                }
+                break;
+        }
+    }
+    function createRandomNodeLength(numberTypeForLength) {
+        switch (numberTypeForLength) {
+            case "Décimal":
+                {
+                    return round(randint(2, 15) + 0.1 * randint(1, 10), 1)
+                        .toTree()
+                        .simplify({ fractionsToDecimal: true });
+                }
+                break;
+            default:
+            case "Entier":
+                {
+                    return randint(2, 16).toTree();
+                }
+                break;
+        }
+    }
+    function isTriangleWrtSideLenghts(nodeLengths) {
+        return nodeLengths.every((nodeLength, i) => {
+            const nodeSumOfOther = nodeLengths
+                .filter((_, j) => j !== i)
+                .reduce((acc, x) => add(acc, x));
+            return nodeLength.evaluate() <= nodeSumOfOther.evaluate();
+        });
+    }
+    function createRandomTriangleNodes(numberTypesForLengths) {
+        let nodeLengths;
+        let isValidTriangle = false;
+        let counter = -1;
+        while (!isValidTriangle && counter < 100) {
+            counter++;
+            nodeLengths = [0, 1, 2].map(() => {
+                const numberTypeForLength = random(numberTypesForLengths);
+                return createRandomNodeLength(numberTypeForLength);
+            });
+            isValidTriangle = isTriangleWrtSideLenghts(nodeLengths);
+        }
+        if (!isValidTriangle) {
+            if (numberTypesForLengths.includes("Entier") &&
+                !numberTypesForLengths.includes("Décimal")) {
+                return [3, 4, 5].map((n) => n.toTree());
+            }
+            else if (!numberTypesForLengths.includes("Entier") &&
+                numberTypesForLengths.includes("Décimal")) {
+                return [3.3, 4.4, 5.5].map((n) => n.toTree());
+            }
+            else {
+                return [3.3, 4, 5.5].map((n) => n.toTree());
+            }
+        }
+        return nodeLengths;
+    }
+    function createRandomHighGcdTriangleNodes(numberTypesForLengths) {
+        let nodeLengths;
+        let isValidTriangle = false;
+        let counter = -1;
+        while (!isValidTriangle && counter < 100) {
+            counter++;
+            const commonDivisor = random(primes.filter((n) => 7 <= n && n <= 23));
+            const numberTypeForLength = random(numberTypesForLengths);
+            if (numberTypeForLength === "Entier") {
+                nodeLengths = randomMany([2, 3, 4, 5, 6, 7, 8], 3)
+                    .map((n) => n * commonDivisor)
+                    .map((n) => n.toTree())
+                    .map((node) => round(node.evaluate(), 1).toTree());
+            }
+            else {
+                nodeLengths = randomMany([2, 3, 4, 5, 6, 7, 8], 3)
+                    .map((n) => n * commonDivisor)
+                    .map((n) => (n * 0.1).toTree())
+                    .map((node) => round(node.evaluate(), 1).toTree());
+            }
+            isValidTriangle = isTriangleWrtSideLenghts(nodeLengths);
+        }
+        if (!isValidTriangle) {
+            if (numberTypesForLengths.includes("Entier") &&
+                !numberTypesForLengths.includes("Décimal")) {
+                return [3, 4, 5].map((n) => n.toTree());
+            }
+            else if (!numberTypesForLengths.includes("Entier") &&
+                numberTypesForLengths.includes("Décimal")) {
+                return [3.3, 4.4, 5.5].map((n) => n.toTree());
+            }
+            else {
+                return [3.3, 4, 5.5].map((n) => n.toTree());
+            }
+        }
+        return nodeLengths;
+    }
+    let isSimilar = coinFlip();
+    const numberTypeForCoeffCandidate = random(opts.numberTypesForCoeffs);
+    const nodeLengths1 = (() => {
+        if (numberTypeForCoeffCandidate === "Fraction") {
+            return createRandomHighGcdTriangleNodes(opts.numberTypesForLengths);
+        }
+        else {
+            return createRandomTriangleNodes(opts.numberTypesForLengths);
+        }
+    })();
+    const nodeLengths1SortedAsc = nodeLengths1.toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    const createNodeCoeff = () => {
+        const numberTypeForCoeff = numberTypeForCoeffCandidate === "Fraction"
+            ? numberTypeForCoeffCandidate
+            : random(opts.numberTypesForCoeffs.filter((numberTypeForCoeff) => numberTypeForCoeff !== "Fraction"));
+        if (numberTypeForCoeff === "Fraction") {
+            const den = nodeLengths1
+                .reduce((acc, x) => extendedGcd(acc.evaluate(), x.evaluate()).toTree())
+                .evaluate();
+            const num = random(primes.filter((n) => n < 5 * den));
+            return frac(num, den);
+        }
+        else {
+            const nodeCoeff = createRandomNodeCoeff(numberTypeForCoeff);
+            return nodeCoeff;
+        }
+    };
+    const nodeCoeffs = isSimilar
+        ? (() => {
+            const nodeCoeff = createNodeCoeff();
+            return nodeLengths1.map(() => nodeCoeff);
+        })()
+        : nodeLengths1.map(() => createNodeCoeff());
+    const nodeCoeffsSortedAsc = nodeCoeffs.toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    isSimilar = (() => {
+        const nodeCoeff0 = nodeCoeffsSortedAsc[0].simplify();
+        return nodeCoeffsSortedAsc.slice(1).every((nodeCoeff) => {
+            return (substract(nodeCoeff.simplify(), nodeCoeff0).simplify().evaluate() === 0);
+        });
+    })();
+    const nodeLengths2SortedAsc = nodeLengths1SortedAsc.map((nodeLength, i) => multiply(nodeCoeffsSortedAsc[i], nodeLength).simplify());
+    const nodeLengths1Shuffled = shuffle(nodeLengths1SortedAsc);
+    const nodeLengths2Shuffled = shuffle(nodeLengths2SortedAsc);
+    const [A, B, C, D, E, F] = randomMany("ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""), 6);
+    const namePoints1 = [A, B, C];
+    const namePoints2 = [D, E, F];
+    const identifiers = {
+        nodeIdsLengths1: nodeLengths1Shuffled.map((node) => node.toIdentifiers()),
+        nodeIdsLengths2: nodeLengths2Shuffled.map((node) => node.toIdentifiers()),
+        namePoints1,
+        namePoints2,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+};
+const optsDefault = {
+    numberTypesForLengths: ["Décimal"],
+    numberTypesForCoeffs: ["Entier"],
+};
+const options = [
+    {
+        id: "numberTypesForLengths",
+        label: "Types de nombres pour les longueurs",
+        defaultValue: optsDefault.numberTypesForLengths,
+        values: ["Entier", "Décimal"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+    {
+        id: "numberTypesForCoeffs",
+        label: "Types de nombres pour les rapports",
+        defaultValue: optsDefault.numberTypesForCoeffs,
+        values: ["Entier", "Décimal", "Fraction"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+];
+export const isSimilarTrianglesWrtSideLengths = {
+    id: "isSimilarTrianglesWrtSideLengths",
+    label: "Justifier que deux triangles sont semblables par le rapport de leurs côtés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsSimilarTrianglesWrtSideLengthsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../../math/geometry/triangles/triangle.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    triangleIds1: TriangleIdentifiers;
+    triangleIds2: TriangleIdentifiers;
+    factor: NodeIdentifiers;
+};
+export declare const placeSegmentsOfSimilarTriangle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placeSegmentsOfSimilarTriangle.d.ts.map

package/lib/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeSegmentsOfSimilarTriangle.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAQnD,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwC7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,mBAAmB,CAAC;IAClC,YAAY,EAAE,mBAAmB,CAAC;IAClC,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAkXF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAgBhE,CAAC"}