math-exercises 3.0.151 → 3.0.153

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

@@ -0,0 +1,189 @@
+import { addValidProp, 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 { random, randomMany } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    const { arrInsertion, indexAsked } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+supprimer tous les éléments de la liste [l v]
+${arrInsertion.map(({ index, value }) => {
+        if (index === -1) {
+            return `ajouter [${value}] à [l v]`;
+        }
+        else {
+            return `insérer [${value}] en position [${index + 1}] de [l v]`;
+        }
+    }).join(`
+`)}
+dire (élément [${indexAsked + 1}] de [l v])
+</svg>
+
+Que va dire le lutin suite à l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { arrInsertion, indexAsked } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        const l = [];
+        outDict[0] = {
+            l: [...l],
+        };
+        //loop
+        let counter = 0;
+        arrInsertion.forEach(({ index, value }) => {
+            counter++;
+            if (index === -1 || index === l.length) {
+                l.push(value);
+            }
+            else {
+                l.splice(index, 0, value);
+            }
+            //store step dict
+            outDict[counter] = {
+                l: [...l],
+            };
+        });
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        outDict[-1].x = outDict[-1].l[indexAsked];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const { isUsingLetters } = identifiers;
+    const xRaw = getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+    if (isUsingLetters) {
+        return xRaw;
+    }
+    else {
+        return xRaw.frenchify();
+    }
+};
+const getHint = () => {
+    return `La liste $l$ change au cours de l'exécution du programme.
+
+À chaque instruction, détermine comment la liste évolue.
+
+Insérer un élement à une position décale l'élément existant à cette position et tous les suivants, pour laisser la place au nouvel arrivant.
+
+L'état final de $l$ te permettra de répondre à la question posée.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrInsertion, indexAsked } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Voici l'évolution de la liste $l$ au fil des instructions.  
+  
+${mdTable([
+        ["\\text{Initialement: vide}", "\\text{}", "\\text{}", "\\text{}"],
+        ...arrInsertion.map(({ index, value }, i) => {
+            const l = dictSteps[i + 1].l;
+            return [
+                index === -1
+                    ? `\\text{Après "ajouter ${value} à l"}`
+                    : `\\text{Après "insérer ${value} en pos. ${index + 1}"}`,
+                l.length > 0 ? `${l[0]}` : "\\text{}",
+                l.length > 1 ? `${l[1]}` : "\\text{}",
+                l.length > 2 ? `${l[2]}` : "\\text{}",
+            ];
+        }),
+    ], true)}
+
+À la fin de l'exécution du programme, $l$ vaut donc $[${dictSteps[-1].l.join(";")}]$.
+
+L'élément à la position $${indexAsked + 1}$ de $l$ est $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { isUsingLetters } = identifiers;
+    const propositions = [];
+    if (isUsingLetters) {
+        const valuesPool = ["A", "B", "C"];
+        valuesPool.forEach((str) => {
+            (str === answer ? addValidProp : tryToAddWrongProp)(propositions, str);
+        });
+    }
+    else {
+        const valuesPool = [1, 2, 3];
+        valuesPool.forEach((v) => {
+            const tex = v.frenchify();
+            (tex === answer ? addValidProp : tryToAddWrongProp)(propositions, tex);
+        });
+    }
+    return propositions;
+};
+const getKeys = ({ isUsingLetters }) => {
+    return isUsingLetters ? ["A", "B", "C"] : [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchListElemAtIndexQuestion = () => {
+    const shuffleArray = coinFlip()
+        ? shuffle([0, 1, 2])
+        : shuffle([...randomMany([0, 1, 2], 2), random([0, 1, 2])]);
+    const isUsingLetters = coinFlip();
+    let arrInsertion = [];
+    if (isUsingLetters) {
+        const valuesPool = ["A", "B", "C"];
+        const values = shuffleArray.map((i) => valuesPool[i]);
+        arrInsertion = values.map((v, i) => {
+            return {
+                index: coinFlip() ? -1 : randint(0, i + 1),
+                value: v,
+            };
+        });
+    }
+    else {
+        const valuesPool = [1, 2, 3];
+        const values = shuffleArray.map((i) => valuesPool[i]);
+        arrInsertion = values.map((v, i) => {
+            return {
+                index: coinFlip() ? -1 : randint(0, i + 1),
+                value: v,
+            };
+        });
+    }
+    const indexRawLast = arrInsertion[arrInsertion.length - 1].index;
+    const indexAsked = randint(0, arrInsertion.length, indexRawLast !== -1 ? [indexRawLast] : []);
+    const identifiers = {
+        isUsingLetters,
+        arrInsertion,
+        indexAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const scratchListElemAtIndex = {
+    id: "scratchListElemAtIndex",
+    connector: "=",
+    label: "Donner un élément d'une liste en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchListElemAtIndexQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/scratch/scratchListElemAtIndex2.d.ts

@@ -0,0 +1,23 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Insertion<T> = {
+    index: number;
+    value: T;
+};
+type Injection<T> = {
+    index: number;
+    value: T;
+};
+type Instruction<T> = ({
+    type: "insertion";
+} & Insertion<T>) | ({
+    type: "injection";
+} & Injection<T>);
+type Identifiers = {
+    lStart: number[] | string[];
+    isUsingLetters: boolean;
+    arrInstruction: Instruction<number>[] | Instruction<string>[];
+    indexAsked: number;
+};
+export declare const scratchListElemAtIndex2: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchListElemAtIndex2.d.ts.map

package/lib/exercises/math/scratch/scratchListElemAtIndex2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchListElemAtIndex2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchListElemAtIndex2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,SAAS,CAAC,CAAC,IAAI;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,SAAS,CAAC,CAAC,IAAI;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,GACtC,CAAC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAC5B,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,GAAG,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;IAC9D,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4OF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

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

@@ -0,0 +1,207 @@
+import { addValidProp, 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 { random, randomMany } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    const { lStart, arrInstruction, indexAsked } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+${arrInstruction.map(({ type, index, value }) => {
+        if (type === "insertion") {
+            if (index === -1) {
+                return `ajouter [${value}] à [l v]`;
+            }
+            else {
+                return `insérer [${value}] en position [${index + 1}] de [l v]`;
+            }
+        }
+        else {
+            return `remplacer l'élément [${index + 1}] de la liste [l v] par [${value}]`;
+        }
+    }).join(`
+`)}
+dire (élément [${indexAsked + 1}] de [l v])
+</svg>
+
+Si la liste $l$ vaut initialement $[${lStart.join(";")}]$, que va dire le lutin suite à l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { lStart, arrInstruction, indexAsked } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        const l = [...lStart];
+        outDict[0] = {
+            l: [...l],
+        };
+        //loop
+        let counter = 0;
+        arrInstruction.forEach(({ type, index, value }) => {
+            counter++;
+            if (type === "insertion") {
+                if (index === -1 || index === l.length) {
+                    l.push(value);
+                }
+                else {
+                    l.splice(index, 0, value);
+                }
+            }
+            else {
+                l[index] = value;
+            }
+            //store step dict
+            outDict[counter] = {
+                l: [...l],
+            };
+        });
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        outDict[-1].x = outDict[-1].l[indexAsked];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const { isUsingLetters } = identifiers;
+    const xRaw = getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+    if (isUsingLetters) {
+        return xRaw;
+    }
+    else {
+        return xRaw.frenchify();
+    }
+};
+const getHint = () => {
+    return `La liste $l$ change au cours de l'exécution du programme.
+
+À chaque instruction, détermine comment la liste évolue.
+
+Insérer un élement à une position décale l'élément existant à cette position et tous les suivants, pour laisser la place au nouvel arrivant.
+
+Remplacer un élément de la liste écrase l'ancien élément avec le nouveau.
+
+L'état final de $l$ te permettra de répondre à la question posée.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrInstruction, indexAsked } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    const maxLength = dictSteps[-1].l.length;
+    return `Voici l'évolution de la liste $l$ au fil des instructions.  
+  
+${mdTable([
+        (() => {
+            const l = dictSteps[0].l;
+            return [
+                "\\text{Initialement}",
+                ...[...Array(maxLength).keys()].map((i) => l.length > i ? `${l[i]}` : "\\text{}"),
+            ];
+        })(),
+        ...arrInstruction.map(({ type, index, value }, i) => {
+            const l = dictSteps[i + 1].l;
+            return [
+                type === "insertion"
+                    ? index === -1
+                        ? `\\text{Après "ajouter ${value} à l"}`
+                        : `\\text{Après "insérer ${value} en pos. ${index + 1}"}`
+                    : `\\text{Après "rempl. l'élém. ${index + 1} par ${value}"}`,
+                ...[...Array(maxLength).keys()].map((i) => l.length > i ? `${l[i]}` : "\\text{}"),
+            ];
+        }),
+    ], true)}
+
+À la fin de l'exécution du programme, $l$ vaut donc $[${dictSteps[-1].l.join(";")}]$.
+
+L'élément à la position $${indexAsked + 1}$ de $l$ est $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { isUsingLetters } = identifiers;
+    const propositions = [];
+    if (isUsingLetters) {
+        const valuesPool = ["A", "B", "C"];
+        valuesPool.forEach((str) => {
+            (str === answer ? addValidProp : tryToAddWrongProp)(propositions, str);
+        });
+    }
+    else {
+        const valuesPool = [1, 2, 3];
+        valuesPool.forEach((v) => {
+            const tex = v.frenchify();
+            (tex === answer ? addValidProp : tryToAddWrongProp)(propositions, tex);
+        });
+    }
+    return propositions;
+};
+const getScratchListElemAtIndex2Question = () => {
+    const shuffleArray = coinFlip()
+        ? shuffle([0, 1, 2])
+        : shuffle([...randomMany([0, 1, 2], 2), random([0, 1, 2])]);
+    const isUsingLetters = coinFlip();
+    const letterPool = ["A", "B", "C"];
+    const numberPool = [1, 2, 3];
+    const lengthLStart = randint(1, 4);
+    const lStart = [...Array(lengthLStart).keys()].map(() => isUsingLetters ? random(letterPool) : random(numberPool));
+    const values = shuffleArray.map((i) => (isUsingLetters ? letterPool : numberPool)[i]);
+    const arrInstruction = values.map((v, i) => {
+        const type = coinFlip() ? "insertion" : "injection";
+        return {
+            type,
+            index: type === "insertion"
+                ? coinFlip()
+                    ? -1
+                    : randint(0, i + 1)
+                : randint(0, i),
+            value: v,
+        };
+    });
+    const indexRawLast = arrInstruction[arrInstruction.length - 1].index;
+    const indexMax = (() => {
+        const identifiersProbe = {
+            lStart,
+            isUsingLetters,
+            arrInstruction,
+            indexAsked: 0,
+        };
+        const dictSteps = getFunctionForScratchProgram(identifiersProbe)(identifiersProbe);
+        return dictSteps[-1].l.length;
+    })();
+    const indexAsked = randint(0, indexMax, indexMax !== 1 && indexRawLast !== -1 ? [indexRawLast] : []);
+    const identifiers = {
+        lStart,
+        isUsingLetters,
+        arrInstruction,
+        indexAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const scratchListElemAtIndex2 = {
+    id: "scratchListElemAtIndex2",
+    connector: "=",
+    label: "Donner un élément d'une liste en Scratch ($2$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchListElemAtIndex2Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/scratch/scratchListFilter.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    l1Start: number[];
+    randCounter: number;
+    randX: number;
+    randCondition: number;
+    isGreaterCond: boolean;
+    k?: number;
+    randListAdd: number;
+};
+export declare const scratchListFilter: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchListFilter.d.ts.map

package/lib/exercises/math/scratch/scratchListFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchListFilter.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchListFilter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,OAAO,CAAC;IACvB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAmdF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}