math-exercises 3.0.151 → 3.0.153

package/lib/exercises/math/scratch/scratchListFilter.js

@@ -0,0 +1,397 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } 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 { random } from "../../../utils/alea/random.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    const { l1Start, randCounter, randX, randCondition, isGreaterCond, k, randListAdd, } = identifiers;
+    const cStart = (() => {
+        switch (randCounter) {
+            case 0:
+            case 3:
+                return 0;
+            case 1:
+            case 2:
+                return 1;
+            case 4:
+            case 5:
+                return l1Start.length;
+        }
+    })();
+    //special care with newline is needed
+    const strScratchProgram = `quand @greenFlag est cliqué
+mettre [c v] à [${cStart}]
+répéter (longueur de [l1 v]) fois ${(() => {
+        switch (randCounter) {
+            case 0:
+            case 2:
+                return `
+mettre [c v] à ((c) + [1])`;
+            default:
+                return "";
+        }
+    })()}
+${(() => {
+        switch (randX) {
+            case 0:
+                return "mettre [x v] à (élément (c) de [l1 v])";
+            case 1:
+                return "mettre [x v] à (c)";
+            case 2:
+                return "mettre [x v] à (longueur de [l1 v])";
+            case 3:
+                return "mettre [x v] à (élément [1] de [l1 v])";
+            default:
+                throw new Error("unsupported randX: " + randX);
+        }
+    })()}
+${(() => {
+        switch (randCondition) {
+            case 0:
+                return `si <(x) ${isGreaterCond ? ">" : "\\<"} [${k}]> alors`;
+            case 1:
+                return `si <(c) ${isGreaterCond ? ">" : "\\<"} [${k}]> alors`;
+            case 2:
+                return `si <(x) ${isGreaterCond ? ">" : "\\<"} (c)> alors`;
+            default:
+                throw new Error("unsupported randCondition: " + randCondition);
+        }
+    })()}
+${(() => {
+        switch (randListAdd) {
+            case 0:
+                return `ajouter (x) à [l2 v]`;
+            case 1:
+                return `ajouter (c) à [l2 v]`;
+            default:
+                throw new Error("unsupported randListAdd: " + randListAdd);
+        }
+    })()}
+fin ${(() => {
+        switch (randCounter) {
+            case 1:
+                return `
+mettre [c v] à ((c) + [1])`;
+            case 4:
+                return `
+mettre [c v] à ((c) - [1])`;
+            default:
+                return "";
+        }
+    })()}
+fin
+dire (l2)`;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+${strScratchProgram}
+</svg>
+
+Si, initialement, la liste $l1$ vaut $[${l1Start.join(";")}]$ et que la liste $l2$ est vide, que va dire le lutin suite à l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { l1Start, randCounter, randX, randCondition, isGreaterCond, k, randListAdd, } = identifiers;
+    const cStart = (() => {
+        switch (randCounter) {
+            case 0:
+            case 3:
+                return 0;
+            case 1:
+            case 2:
+                return 1;
+            case 4:
+            case 5:
+                return l1Start.length;
+        }
+    })();
+    return (_) => {
+        const outDict = {};
+        //init
+        const l1 = [...l1Start];
+        let c = cStart;
+        let x;
+        const l2 = [];
+        outDict[0] = {
+            c,
+            l2: [...l2],
+        };
+        function listAdd(x, c, l2) {
+            switch (randListAdd) {
+                case 0:
+                    {
+                        l2.push(x);
+                    }
+                    break;
+                case 1:
+                    {
+                        l2.push(c);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        //loop
+        let counter = 0;
+        l1.forEach(() => {
+            counter++;
+            switch (randCounter) {
+                case 0:
+                case 2:
+                    {
+                        c = c + 1;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            switch (randX) {
+                case 0:
+                    {
+                        x = l1[c - 1];
+                    }
+                    break;
+                case 1:
+                    {
+                        x = c;
+                    }
+                    break;
+                case 2:
+                    {
+                        x = l1.length;
+                    }
+                    break;
+                case 3:
+                    {
+                        x = l1[0];
+                    }
+                    break;
+                default:
+                    break;
+            }
+            switch (randCondition) {
+                case 0:
+                    {
+                        if (isGreaterCond ? x > k : x < k) {
+                            listAdd(x, c, l2);
+                        }
+                    }
+                    break;
+                case 1:
+                    {
+                        if (isGreaterCond ? c > k : c < k) {
+                            listAdd(x, c, l2);
+                        }
+                    }
+                    break;
+                case 2:
+                    {
+                        if (isGreaterCond ? x > c : x < c) {
+                            listAdd(x, c, l2);
+                        }
+                    }
+                    break;
+                default:
+                    return "";
+            }
+            switch (randCounter) {
+                case 1:
+                    {
+                        c = c + 1;
+                    }
+                    break;
+                case 4:
+                    {
+                        c = c - 1;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            //store step dict
+            outDict[counter] = {
+                c,
+                x,
+                l2: [...l2],
+            };
+        });
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const l2 = getFunctionForScratchProgram(identifiers)(identifiers)[-1].l2;
+    return l2.map((v) => `${v.frenchify()}`).join(" \\ ");
+};
+const getHint = () => {
+    return `La liste $l2$ change au cours de l'exécution du programme.
+
+À chaque itération, détermine comment la liste évolue.`;
+};
+const getCorrection = (identifiers) => {
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    const maxLength = dictSteps[-1].l2.length;
+    return `Voici l'évolution de la liste $l2$ au fil des instructions.  
+  
+${mdTable([
+        (() => {
+            const l2 = dictSteps[0].l2;
+            return [
+                "\\text{Initialement: vide}",
+                ...[...Array(maxLength).keys()].map((i) => l2.length > i ? `${l2[i]}` : "\\text{}"),
+            ];
+        })(),
+        ...Object.entries(dictSteps)
+            .filter(([k, _]) => +k > 0)
+            .map(([i, stepDict]) => {
+            const l2 = stepDict.l2;
+            return [
+                `\\text{Après l'itération ${i}}`,
+                ...[...Array(maxLength).keys()].map((i) => l2.length > i ? `${l2[i]}` : "\\text{}"),
+            ];
+        }),
+    ], true)}
+
+À la fin de l'exécution du programme, $l2$ vaut donc $[${dictSteps[-1].l2.join(";")}]$.
+
+Le lutin dira : "${dictSteps[-1].l2.map((v) => `$${v}$`).join(" ")}".`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { l1Start } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    let arrList = [];
+    let arrListFoundation = [];
+    {
+        //variations on randListAdd
+        [0, 1, 2].forEach((randListAdd) => {
+            const identifiersVariation = Object.assign({}, identifiers, {
+                randListAdd,
+            });
+            const l2 = getFunctionForScratchProgram(identifiersVariation)(identifiersVariation)[-1].l2;
+            arrListFoundation.push(l2);
+        });
+        //l1
+        {
+            arrListFoundation.push(l1Start);
+        }
+        //variations on randX
+        {
+            [0, 1, 2, 3].forEach((randX) => {
+                const identifiersVariation = Object.assign({}, identifiers, {
+                    randX,
+                });
+                const l2 = getFunctionForScratchProgram(identifiersVariation)(identifiersVariation)[-1].l2;
+                arrListFoundation.push(l2);
+            });
+        }
+        arrListFoundation = arrListFoundation.filter((list) => !list.includes(undefined));
+    }
+    arrList = arrListFoundation.filter((list) => list.length > 0);
+    //more if needed
+    const nbInvalidRound1 = arrList.filter((list) => {
+        const tex = list.map((v) => `${v.frenchify()}`).join(" \\ ");
+        return tex !== answer;
+    }).length;
+    if (nbInvalidRound1 < n - 1) {
+        arrList.push(...arrListFoundation.map((list) => list.slice(0, -1)));
+        arrList.push(...arrListFoundation.map((list) => list.slice(1)));
+    }
+    arrList = arrList.filter((list) => list.length > 0);
+    //even more if needed
+    const nbInvalidRound2 = arrList.filter((list) => {
+        const tex = list.map((v) => `${v.frenchify()}`).join(" \\ ");
+        return tex !== answer;
+    }).length;
+    if (nbInvalidRound2 < n - 1) {
+        arrList.push(...arrListFoundation.map((list) => list.slice(0, -2)));
+        arrList.push(...arrListFoundation.map((list) => list.slice(2)));
+    }
+    arrList = arrList.filter((list) => list.length > 0);
+    arrList.forEach((list) => {
+        const tex = list.map((v) => `${v.frenchify()}`).join(" \\ ");
+        if (tex !== answer) {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getScratchListFilterQuestion = () => {
+    const lengthL1 = 5;
+    const poolSmall = [...Array(lengthL1).keys()].map((i) => i + 1);
+    const poolStd = [...Array(20).keys()].map((i) => i + 1);
+    const isL1Small = coinFlip();
+    const l1Start = [...Array(5).keys()].map(() => random(isL1Small ? poolSmall : poolStd));
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const randCounter = randint(0, 6);
+        const randX = randint(0, 4);
+        const randCondition = randint(0, 3);
+        const randListAdd = randint(0, 2);
+        const isGreaterCond = coinFlip();
+        const k = isL1Small
+            ? random(coinFlip() ? l1Start : poolSmall)
+            : random(coinFlip() ? l1Start : poolStd);
+        const identifiersCandidate = {
+            l1Start,
+            randCounter,
+            randX,
+            randCondition,
+            isGreaterCond,
+            k,
+            randListAdd,
+        };
+        const l2 = getFunctionForScratchProgram(identifiersCandidate)(identifiersCandidate)[-1].l2;
+        isValid =
+            l2.length > 0 && !l2.includes(undefined);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            l1Start: [1, 2, 3, 4, 5],
+            randCounter: 0,
+            randX: 0,
+            randCondition: 0,
+            randListAdd: randint(0, 2),
+            isGreaterCond: false,
+            k: 3,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const scratchListFilter = {
+    id: "scratchListFilter",
+    connector: "=",
+    label: "Filtrer une liste en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchListFilterQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    rectangularPrismOrigin: SpacePointIdentifiers;
+    L: number;
+    l: number;
+    h: number;
+    arrGivenSpacePointIds: SpacePointIdentifiers[];
+    arrPoolSpacePointIds: SpacePointIdentifiers[];
+    indexAsked: number;
+};
+export declare const findSpacePointOnRectangularPrism: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findSpacePointOnRectangularPrism.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findSpacePointOnRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkB3C,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;IAE/C,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqgBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}