math-exercises 3.0.149 → 3.0.150

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

@@ -0,0 +1,194 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { xStart, yStart, rand } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à [${xStart}]
+mettre [y v] à [${yStart}]
+${(() => {
+        switch (rand) {
+            //"x+y"
+            case 0:
+                return `dire [x + y]`;
+            case 1:
+                return `dire (regrouper [x] et (regrouper [+] et [y]))`;
+            //`${x}+${y}`
+            case 2:
+                return `dire (regrouper (x) et (regrouper [+] et (y)))`;
+            //`${x+y}`
+            case 3:
+                return `dire ((x) + (y))`;
+            //`x+${y}`
+            case 4:
+                return `dire (regrouper [x] et (regrouper [+] et (y)))`;
+            //`${x}+y`
+            case 5:
+                return `dire (regrouper (x) et (regrouper [+] et [y]))`;
+        }
+    })()}
+</svg>
+
+Que va dire le lutin quand on va exécuter le programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { xStart, yStart, rand } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        const x = xStart;
+        const y = yStart;
+        //convenience: store last step in -1
+        outDict[-1] = (() => {
+            switch (rand) {
+                case 0:
+                case 1:
+                    return "x+y";
+                case 2:
+                    return `${x}+${y}`;
+                case 3:
+                    return `${x + y}`;
+                case 4:
+                    return `x+${y}`;
+                case 5:
+                    return `${x}+y`;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        })();
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return dictSteps[-1];
+};
+const getHint = () => {
+    return `Pour chaque variable, est-ce qu'on te demande d'afficher son nom, ou bien sa valeur ?`;
+};
+const getCorrection = (identifiers) => {
+    const { xStart, yStart, rand } = identifiers;
+    return `Initialement, $x$ vaut $${xStart}$ et $y$ vaut $${yStart}$.
+
+${(() => {
+        switch (rand) {
+            case 0:
+                return `Dans l'instruction dire ..., ce qui est en blanc, c'est la chaîne de caractères "x+y".
+
+Le lutin va donc dire: "x+y" (Tout simplement !).`;
+            case 1:
+                return `Dans l'instruction dire ..., ce qui est en blanc, ce sont les chaînes de caractères "x", "+" et "y".
+
+On les regroupe.
+
+Le lutin va donc dire: "x+y".`;
+            case 2:
+                return `Dans l'instruction dire ..., ce qui est en blanc, c'est uniquement la chaîne de caractères "+".
+
+On va donc construire des chaînes de caractères avec les valeurs des variables $x$ et $y$.
+
+Ensuite, on regroupe tout.
+
+Le lutin va donc dire : "$${xStart}$+$${yStart}$".`;
+            case 3:
+                return `Dans l'instruction dire ..., il n'y a rien en blanc.
+
+On va donc calculer la somme $${xStart}$ + $${yStart}$ et la transformer en chaîne de caractères.
+
+Le lutin va donc dire : "$${xStart + yStart}$".`;
+            case 4:
+                return `Dans l'instruction dire ..., ce qui est en blanc, ce sont les chaînes de caractères "x" et "+".
+
+On va donc construire une chaîne de caractères avec la valeur de la variable $y$.
+
+Ensuite, on regroupe tout.
+
+Le lutin va donc dire : "x+$${yStart}$".`;
+            case 5:
+                return `Dans l'instruction dire ..., ce qui est en blanc, ce sont les chaînes de caractères "+" et "y".
+
+On va donc construire une chaîne de caractères avec la valeur de la variable $x$.
+
+Ensuite, on regroupe tout.
+
+Le lutin va donc dire : "$${xStart}$+y".`;
+            default:
+                throw new Error("unsupported rand: " + rand);
+        }
+    })()}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //mandatory
+    [3].forEach((rand) => {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            rand,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    //filler
+    [...Array(6).keys()].forEach((rand) => {
+        if (propositions.length < n) {
+            const identifiersWrong = Object.assign({}, identifiers, {
+                rand,
+            });
+            const texWrong = getAnswer(identifiersWrong);
+            tryToAddWrongProp(propositions, texWrong);
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["x", "y"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchPrintXYQuestion = () => {
+    const xStart = randint(-10, 10);
+    const yStart = randint(-10, 10);
+    const rand = randint(0, 6);
+    const identifiers = {
+        xStart,
+        yStart,
+        rand,
+    };
+    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 scratchPrintXY = {
+    id: "scratchPrintXY",
+    connector: "=",
+    label: "Afficher des chaînes de caractères et/ou des valeurs de variables en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchPrintXYQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    strStart: string;
+    repeatCount: number;
+    strAppend1: string;
+    rand: number;
+};
+export declare const scratchStringLoop: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchStringLoop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchStringLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchStringLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

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

@@ -0,0 +1,192 @@
+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 { random } from "../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { strStart, repeatCount, strAppend1, rand } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à [${strStart}]
+répéter (${repeatCount}) fois
+${(() => {
+        switch (rand) {
+            case 0:
+                return `  mettre [x v] à (regrouper (x) et [${strAppend1}])`;
+            case 1:
+                return `  mettre [x v] à (regrouper [${strAppend1}] et (x))`;
+            case 2:
+                return `  mettre [x v] à (regrouper (x) et (x))`;
+            case 3:
+                return `  mettre [x v] à (regrouper [${strAppend1}] et [${strAppend1}])`;
+        }
+    })()}
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { strStart, repeatCount, strAppend1, rand } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x;
+        x = strStart;
+        outDict[0] = {
+            x,
+        };
+        //loop
+        let counter = 0;
+        while (counter < repeatCount) {
+            counter++;
+            //inside of loop
+            {
+                x = (() => {
+                    switch (rand) {
+                        case 0:
+                            return x + strAppend1;
+                        case 1:
+                            return strAppend1 + x;
+                        case 2:
+                            return x + x;
+                        case 3:
+                            return strAppend1 + strAppend1;
+                        default:
+                            throw new Error("unsupported rand: " + rand);
+                    }
+                })();
+            }
+            //store step dict
+            outDict[counter] = {
+                x,
+            };
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+};
+const getHint = () => {
+    return `La valeur de la variable $x$ change au cours de l'exécution du programme.
+À chaque itération, 
+détermine comment la variable évolue.`;
+};
+const getCorrection = (identifiers) => {
+    const { strAppend1, rand } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${Object.keys(dictSteps)
+        .map((k) => +k)
+        .filter((k) => k > 0)
+        .map((k) => {
+        return `Itération n°$${k}$ :
+
+Au début, $x$ vaut $${dictSteps[k - 1].x}$.
+
+On va affecter à $x$ la chaîne de caractères composée par le regroupement de ${(() => {
+            switch (rand) {
+                case 0:
+                    return `$${dictSteps[k - 1].x}$ et de $${strAppend1}$`;
+                case 1:
+                    return `$${strAppend1}$ et de $${dictSteps[k - 1].x}$`;
+                case 2:
+                    return `$${dictSteps[k - 1].x}$ et de $${dictSteps[k - 1].x}$`;
+                case 3:
+                    return `$${strAppend1}$ et de $${strAppend1}$`;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        })()}.
+
+$x$ vaut maintenant $${dictSteps[k].x}$.`;
+    }).join(`
+    
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strStart, repeatCount, rand } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [...Array(4).keys()].forEach((rand) => {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            rand,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    //strStart
+    tryToAddWrongProp(propositions, strStart);
+    //terror for rand===3
+    if (rand === 2) {
+        if (coinFlip()) {
+            const texWrong = strStart.repeat(2 ** repeatCount - 1);
+            tryToAddWrongProp(propositions, texWrong);
+        }
+        if (strStart.length === 1) {
+            if (coinFlip()) {
+                const texWrong = strStart.repeat(2 ** repeatCount + 1);
+                tryToAddWrongProp(propositions, texWrong);
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["A", "B", "C", "D"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchStringLoopQuestion = () => {
+    const rand = randint(0, 4);
+    function createRandomStr(length) {
+        return [...Array(length).keys()].reduce((acc, _) => acc + random(["A", "B", "C", "D"]), "");
+    }
+    const repeatCount = randint(1, 4);
+    const strStart = createRandomStr(rand === 2 && repeatCount === 3 ? 1 : randint(1, 3));
+    const strAppend1 = createRandomStr(randint(1, 3));
+    const identifiers = {
+        strStart,
+        repeatCount,
+        strAppend1,
+        rand,
+    };
+    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 scratchStringLoop = {
+    id: "scratchStringLoop",
+    connector: "=",
+    label: "Utiliser une boucle avec une chaîne de caractères en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchStringLoopQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    strStart: string;
+    repeatCount: number;
+    isGreaterCond1: boolean;
+    thresholdCond1: number;
+    arrStrAppend: string[];
+    arrRand: number[];
+};
+export declare const scratchStringLoopCond: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchStringLoopCond.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scratchStringLoopCond.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchStringLoopCond.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4SF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAmBvD,CAAC"}

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

@@ -0,0 +1,270 @@
+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";
+import { getCartesiansProducts } from "../../../utils/arrays/cartesianProducts.js";
+const getStrScratchForRand = (rand, strAppend) => {
+    switch (rand) {
+        case 0:
+            return `  mettre [x v] à (regrouper (x) et [${strAppend}])`;
+        case 1:
+            return `  mettre [x v] à (regrouper [${strAppend}] et (x))`;
+        case 2:
+            return `  mettre [x v] à (regrouper (x) et (x))`;
+        case 3:
+            return `  mettre [x v] à (regrouper [${strAppend}] et [${strAppend}])`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { strStart, repeatCount, isGreaterCond1, thresholdCond1, arrStrAppend, arrRand, } = identifiers;
+    return `On considère le programme Scratch ci-dessous :
+
+<svg id="scratch">
+quand @greenFlag est cliqué
+mettre [x v] à [${strStart}]
+répéter (${repeatCount}) fois
+si <(longueur de (x)) ${isGreaterCond1 ? ">" : "\\<"} (${thresholdCond1})> alors
+${arrRand.map((rand, i) => `${getStrScratchForRand(rand, arrStrAppend[i])}
+`).join(`sinon
+`)}
+</svg>
+
+Quelle est la valeur de $x$ à la fin de l'exécution du programme ?`;
+};
+const getFunctionForScratchProgram = (identifiers) => {
+    const { strStart, repeatCount, isGreaterCond1, thresholdCond1, arrStrAppend, arrRand, } = identifiers;
+    return (_) => {
+        const outDict = {};
+        //init
+        let x;
+        x = strStart;
+        outDict[0] = {
+            x,
+        };
+        function strForXAndRandAndStrAppend(x, rand, strAppend) {
+            switch (rand) {
+                case 0:
+                    return x + strAppend;
+                case 1:
+                    return strAppend + x;
+                case 2:
+                    return x + x;
+                case 3:
+                    return strAppend + strAppend;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        }
+        //loop
+        let counter = 0;
+        while (counter < repeatCount) {
+            counter++;
+            //inside of loop
+            {
+                if (isGreaterCond1 ? x.length > thresholdCond1 : x.length < thresholdCond1) {
+                    x = strForXAndRandAndStrAppend(x, arrRand[0], arrStrAppend[0]);
+                }
+                else {
+                    x = strForXAndRandAndStrAppend(x, arrRand[1], arrStrAppend[1]);
+                }
+            }
+            //store step dict
+            outDict[counter] = {
+                x,
+            };
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getAnswer = (identifiers) => {
+    return getFunctionForScratchProgram(identifiers)(identifiers)[-1].x;
+};
+const getHint = () => {
+    return `La valeur de la variable $x$ change au cours de l'exécution du programme.
+À chaque itération, 
+détermine comment la variable évolue.
+La longueur d'une chaîne de caractères est le nombre de caractères qu'elle contient (exemple : "AAC" est de longueur $3$).`;
+};
+const getCorrection = (identifiers) => {
+    const { isGreaterCond1, thresholdCond1, arrRand, arrStrAppend } = identifiers;
+    const dictSteps = getFunctionForScratchProgram(identifiers)(identifiers);
+    return `Initialement, $x$ vaut $${dictSteps[0].x}$.
+
+${Object.keys(dictSteps)
+        .map((k) => +k)
+        .filter((k) => k > 0)
+        .map((k) => {
+        const x = dictSteps[k - 1].x;
+        const isConditionVerified = isGreaterCond1
+            ? x.length > thresholdCond1
+            : x.length < thresholdCond1;
+        const indexCondition = isConditionVerified ? 0 : 1;
+        const rand = arrRand[indexCondition];
+        const strAppend1 = arrStrAppend[indexCondition];
+        return `Itération n°$${k}$ :
+
+Au début, $x$ vaut $${x}$.
+
+La longueur de $x$ est $${x.length}$.
+
+La condition ${isConditionVerified ? "est vérifiée" : "n'est pas vérifiée"}.
+
+On va affecter à $x$ la chaîne de caractères composée par le regroupement de ${(() => {
+            switch (rand) {
+                case 0:
+                    return `$${dictSteps[k - 1].x}$ et de $${strAppend1}$`;
+                case 1:
+                    return `$${strAppend1}$ et de $${dictSteps[k - 1].x}$`;
+                case 2:
+                    return `$${dictSteps[k - 1].x}$ et de $${dictSteps[k - 1].x}$`;
+                case 3:
+                    return `$${strAppend1}$ et de $${strAppend1}$`;
+                default:
+                    throw new Error("unsupported rand: " + rand);
+            }
+        })()}.
+
+$x$ vaut maintenant $${dictSteps[k].x}$.`;
+    }).join(`
+    
+`)}
+
+À la fin de l'exécution du programme, $x$ vaut donc $${dictSteps[-1].x}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { strStart, repeatCount, arrRand, arrStrAppend } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //toggle on all checks
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.toReversed(),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //ABB instead of BBA
+    if (arrRand.includes(0) || arrRand.includes(1)) {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            arrRand: arrRand.map((rand) => (rand === 0 ? 1 : rand === 1 ? 0 : rand)),
+            arrStrAppend: arrStrAppend.toReversed(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //wrong repeatCount
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            repeatCount: repeatCount - 1,
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //strStart
+    tryToAddWrongProp(propositions, strStart);
+    //filler
+    [...Array(repeatCount + 4).keys()].forEach((repeatCountW) => {
+        let strWrong = strStart;
+        [...Array(repeatCountW).keys()].forEach(() => {
+            const strAppend = random(arrStrAppend);
+            if (coinFlip()) {
+                strWrong = strWrong + strAppend;
+            }
+            else {
+                strWrong = strAppend + strWrong;
+            }
+        });
+        if (propositions.length < n) {
+            tryToAddWrongProp(propositions, strWrong);
+        }
+    });
+    ["A", "B", "C", "D"].forEach((strWrong) => {
+        if (propositions.length < n) {
+            tryToAddWrongProp(propositions, strWrong);
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["A", "B", "C", "D"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getScratchStringLoopCondQuestion = () => {
+    const arrRand = randomMany([0, 1, 2, 3], 2);
+    function createRandomStr(length) {
+        return [...Array(length).keys()].reduce((acc, _) => acc + random(["A", "B", "C", "D"]), "");
+    }
+    function createAllPossibleStrings(minLength, maxLength) {
+        return [...Array(maxLength - minLength).keys()]
+            .map((i) => i + minLength)
+            .reduce((acc, length) => {
+            const arrSrc = [...Array(length).keys()].map(() => [
+                "A",
+                "B",
+                "C",
+                "D",
+            ]);
+            const arrCartesianProduct = getCartesiansProducts(arrSrc);
+            const arrStr = arrCartesianProduct.map((arr) => arr.join(""));
+            acc.push(...arrStr);
+            return acc;
+        }, []);
+    }
+    const repeatCount = arrRand.includes(2) ? randint(2, 4) : randint(2, 5);
+    const strStart = createRandomStr(arrRand.includes(2) && repeatCount === 3 ? 1 : randint(1, 3));
+    let arrStrAppend;
+    if (probaFlip(0.41)) {
+        const strAppendSame = random(createAllPossibleStrings(1, 3).filter((str) => str !== strStart));
+        arrStrAppend = [0, 1].map(() => strAppendSame);
+    }
+    else {
+        arrStrAppend = [0, 1].map(() => createRandomStr(randint(1, 3)));
+    }
+    const isGreaterCond1 = coinFlip();
+    const thresholdCond1 = randint(3, 6);
+    const identifiers = {
+        strStart,
+        repeatCount,
+        arrStrAppend,
+        arrRand,
+        isGreaterCond1,
+        thresholdCond1,
+    };
+    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 scratchStringLoopCond = {
+    id: "scratchStringLoopCond",
+    connector: "=",
+    label: "Utiliser une condition dans une boucle avec une chaîne de caractères en Scratch",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScratchStringLoopCondQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};