math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/conversion/clock/clockWritingByManipulatingNeedles.js

@@ -0,0 +1,359 @@
+// import {
+//   Exercise,
+//   Question,
+//   QuestionGenerator,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetGGBOptions,
+//   GetQuestionFromIdentifiers,
+//   GeneratorOption,
+//   GeneratorOptionTarget,
+//   GeneratorOptionType,
+//   GGBVEA,
+//   GetGGBAnswer,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+// import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+// import { Vector } from "../../../../math/geometry/vector.js";
+// import { randint } from "../../../../math/utils/random/randint.js";
+// import { round } from "../../../../math/utils/round.js";
+// import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+// import { add } from "../../../../tree/nodes/operators/addNode.js";
+// import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+// import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+// import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+// import { random } from "../../../../utils/alea/random.js";
+export {};
+// const _degreesToRadians = (angleInDegrees: number, precision: number) => {
+//   const oneOver180 = 0.00555555555555555;
+//   return round(
+//     multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(),
+//     precision,
+//   );
+// };
+// const rotateVector = (vec: Vector, angle: number, name: string) => {
+//   //x' = cos(t)*x -sin(t)*y
+//   //y' = sin(t)*x + cos(t)*y
+//   const cos = Math.cos(angle);
+//   const sin = Math.sin(angle);
+//   return new Vector(
+//     name,
+//     substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(),
+//     add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree(),
+//   );
+// };
+// const rotatePoint = (
+//   target: Point,
+//   angle: number,
+//   center: Point,
+//   name: string,
+//   precision: number | undefined = 2,
+// ) => {
+//   const vSrc = createVector(center, target, "vSrc", precision);
+//   const vRotated = rotateVector(vSrc, angle, "vRotated");
+//   return createPoint(
+//     add(center.x, vRotated.x).evaluate(),
+//     add(center.y, vRotated.y).evaluate(),
+//     name,
+//     precision,
+//   );
+// };
+// const createVector = (
+//   from: Point,
+//   to: Point,
+//   name: string,
+//   precision: number | undefined = 5,
+// ) => {
+//   return new Vector(
+//     name,
+//     round(substract(to.x, from.x).evaluate(), precision).toTree(),
+//     round(substract(to.y, from.y).evaluate(), precision).toTree(),
+//   );
+// };
+// const createPoint = (
+//   x: number,
+//   y: number,
+//   name: string,
+//   precision: number | undefined = 5,
+// ) => {
+//   return new Point(name, round(x, precision), round(y, precision));
+// };
+// /************/
+// type Identifiers = {
+//   hours: number;
+//   minutes: number;
+// };
+// const getHydrated = (identifiers: Identifiers) => {
+//   const { hours, minutes } = identifiers;
+//   const isExactlyNoon = hours === 12 && minutes === 0;
+//   const strAMPM = (() => {
+//     if (minutes !== 0) {
+//       if (hours < 12) {
+//         return "Nous sommes avant midi";
+//       } else {
+//         return "Nous sommes après midi";
+//       }
+//     } else {
+//       if (hours === 0) {
+//         return "Nous sommes avant midi (il n'est pas midi).";
+//       } else if (hours === 24) {
+//         return "Nous sommes après midi (il n'est pas midi).";
+//       } else {
+//         return "Nous sommes en pleine journée.";
+//       }
+//     }
+//   })();
+//   const duodecHours = hours > 12 ? hours - 12 : hours;
+//   const duodecMinutes = minutes / 5;
+//   const angleMinutes = (Math.PI / 6.0) * duodecMinutes;
+//   const angleHours = 2 * Math.PI * (((hours + minutes / 60) / 12.0) % 1);
+//   return {
+//     strAMPM,
+//     isExactlyNoon,
+//     duodecHours,
+//     duodecMinutes,
+//     angleHours,
+//     angleMinutes,
+//   };
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const { hours, minutes } = identifiers;
+//   const strMinutes = (() => {
+//     if (minutes < 10) {
+//       return `0${minutes}`;
+//     } else {
+//       return `${minutes}`;
+//     }
+//   })();
+//   const strTime = `${hours}h${strMinutes}`;
+//   return `Manipuler les aiguilles de l'horloge pour indiquer $${strTime}$.`;
+// };
+// const getGGBAnswer: GetGGBAnswer<Identifiers> = (identifiers) => {
+//   // const { triangle, point, segment } = getHydrated(identifiers);
+//   const ggbAnswer = [`Ptest = Point({1,4})`];
+//   return ggbAnswer;
+// };
+// const getHint: GetHint<Identifiers> = () => {
+//   return `L'aiguille des heures est l'aiguille la plus courte.
+// Avant midi, les heures vont de $0$ à $11$. Après midi, les heures vont de $12$ à $23$.
+// Les graduations des minutes vont de $0$ à $55$ (de $5$ en $5$).
+// L'aiguille des heures se déplace continument.
+// Quand il est la demi, l'aiguille des heures est entre les deux marqueurs.
+// Il faut placer l'aiguille des heures `;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const { hours, minutes } = identifiers;
+//   const { duodecHours, duodecMinutes } = getHydrated(identifiers);
+//   const strMinutes = (() => {
+//     if (minutes < 10) {
+//       return `0${minutes}`;
+//     } else {
+//       return `${minutes}`;
+//     }
+//   })();
+//   if (minutes !== 0) {
+//     if (hours < 12) {
+//       return `Nous sommes avant midi.
+// L'aiguille des heures est entre $${duodecHours}$ et $${duodecHours + 1}$.
+// Il est donc $${hours}h...$
+// L'aiguille des minutes est sur la graduation $${duodecMinutes}$.
+// $$
+// ${duodecMinutes} \\times 5 = ${minutes}
+// $$
+// Il est donc $${hours}h${strMinutes}$.
+// `;
+//     } else if (hours > 12) {
+//       return `Nous sommes après midi.
+// L'aiguille des heures est entre $${duodecHours}$ et $${duodecHours + 1}$.
+// $$
+// 12 + ${duodecHours} = ${hours}
+// $$
+// Il est donc $${hours}h...$
+// L'aiguille des minutes est sur la graduation $${duodecMinutes}$.
+// $$
+// ${duodecMinutes} \\times 5 = ${minutes}
+// $$
+// Il est donc $${hours}h${strMinutes}$.
+// `;
+//     } else {
+//       return "Il est exactement midi ($12h00$).";
+//     }
+//   } else {
+//     if (hours === 0) {
+//       return `Il est exactement minuit ($0h00$).`;
+//     } else if (hours === 24) {
+//       return `Il est exactement minuit ($0h00$) (on passe dans le jour suivant donc on n'écrit pas "$24h00$").`;
+//     } else {
+//       return `Il est exactement $${hours}h00$.`;
+//     }
+//   }
+// };
+// const getStudentGGBOptions: GetGGBOptions<Identifiers> = () => {
+//   const pointOrigin = new Point("O", 0, 0);
+//   //ticks
+//   const arrPointTickTop = [
+//     PointConstructor.fromCoords([0, 0.8], "tickTopA"),
+//     PointConstructor.fromCoords([0, 1], "tickTopB"),
+//   ];
+//   const arrArrPointTick = [...Array(12).keys()].map((i) => {
+//     const angle = (i * Math.PI) / 6;
+//     return arrPointTickTop.map((point, j) =>
+//       rotatePoint(point, angle, pointOrigin, `tick${i}${j === 0 ? "A" : "B"}`),
+//     );
+//   });
+//   const studentGGB = new GeogebraConstructor({
+//     commands: [
+//       `C = Circle((0,0), 1)`,
+//       `SetFixed(C, true, false)`,
+//       `SetLineThickness(C, 1)`,
+//       //ticks
+//       ...arrArrPointTick.flatMap(([pointA, pointB], i) => [
+//         `segTick${i} = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+//         `SetLineThickness(segTick${i}, ${i === 0 ? "6" : "2"})`,
+//         `SetFixed(segTick${i}, true, false)`,
+//       ]),
+//       //needles
+//       ...[
+//         `Chours = Circle((0,0), 0.5)`,
+//         `SetFixed(Chours, true, false)`,
+//         `SetVisibleInView(Chours, 1, false)`,
+//         `Bhours = Point(Chours)`,
+//         `SetPointStyle(Bhours, 2)`,
+//         `segNeedleHours = Segment(Center(Chours), Bhours)`,
+//         `SetLineThickness(segNeedleHours, 20)`,
+//       ],
+//       ...[
+//         `Cminutes = Circle((0,0), 0.75)`,
+//         `SetFixed(Cminutes, true, false)`,
+//         `SetVisibleInView(Cminutes, 1, false)`,
+//         `Bminutes = Point(Cminutes)`,
+//         `SetPointStyle(Bminutes, 2)`,
+//         `segNeedleMinutes = Segment(Center(Cminutes), Bminutes)`,
+//         `SetLineThickness(segNeedleMinutes, 10)`,
+//       ],
+//     ],
+//     hideAxes: true,
+//     hideGrid: true,
+//     forbidShiftDragZoom: true,
+//     interactiveObjects: ["Bhours", "Bminutes"],
+//   });
+//   return studentGGB.getOptions({
+//     coords: [-1.4, 1.4, -1.4, 1.4],
+//   });
+// };
+// const isGGBAnswerValid: GGBVEA<Identifiers> = (
+//   ggbAns,
+//   { ggbAnswer: _ggbAnswer, ...identifiers },
+// ) => {
+//   return false;
+// };
+// const createRandomIdentifiers = () => {
+//   const amPmType = probaLawFlip([
+//     ["AM", 0.4],
+//     ["midi", 0.1],
+//     ["PM", 0.4],
+//     ["minuit", 0.1],
+//   ]);
+//   const [hours, minutes] = (() => {
+//     switch (amPmType) {
+//       case "AM": {
+//         const hours = randint(0, 12);
+//         const minutes = randint(1, 12) * 5;
+//         return [hours, minutes];
+//       }
+//       case "midi": {
+//         return [12, 0];
+//       }
+//       case "PM": {
+//         const hours = randint(12, 23);
+//         const minutes = randint(1, 12) * 5;
+//         return [hours, minutes];
+//       }
+//       case "minuit": {
+//         return random([
+//           [0, 0],
+//           [24, 0],
+//         ]);
+//       }
+//       default:
+//         throw new Error("Unsupported typeAMPM: " + amPmType);
+//     }
+//   })();
+//   const identifiers: Identifiers = {
+//     hours,
+//     minutes,
+//   };
+//   return identifiers;
+// };
+// const getClockWritingByManipulatingNeedlesQuestion: QuestionGenerator<
+//   Identifiers,
+//   Options
+// > = (optsIn) => {
+//   const opts: Options = optsIn ?? arrayedOptsDefault;
+//   const identifiers = createRandomIdentifiers();
+//   return getQuestionFromIdentifiers(identifiers, opts);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<
+//   Identifiers,
+//   Options
+// > = (identifiers) => {
+//   const question: Question<Identifiers, Options> = {
+//     ggbAnswer: getGGBAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: [],
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//     studentGgbOptions: getStudentGGBOptions(identifiers),
+//   };
+//   return question;
+// };
+// type Options = {
+//   acceptedInputType: string[];
+// };
+// type ArrayedOptions = {
+//   readonly [K in keyof Options]: Options[K] extends unknown[]
+//     ? Options[K]
+//     : Options[K][];
+// };
+// const arrayedOptsDefault: ArrayedOptions = {
+//   acceptedInputType: ["réaliste"],
+// };
+// const options: GeneratorOption[] = [
+//   {
+//     id: "acceptedInputType",
+//     label: "Position acceptée pour l'aiguille des heures",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     values: ["réaliste", "simpliste"],
+//     defaultValue: arrayedOptsDefault.acceptedInputType,
+//   },
+// ];
+// export const clockWritingByManipulatingNeedles: Exercise<Identifiers, Options> =
+//   {
+//     id: "clockWritingByManipulatingNeedles",
+//     label: "Inscrire l'heure sur une horloge",
+//     isSingleStep: true,
+//     generator: (nb, opts) =>
+//       getDistinctQuestions(
+//         () => getClockWritingByManipulatingNeedlesQuestion(opts),
+//         nb,
+//       ),
+//     options,
+//     qcmTimer: 60,
+//     freeTimer: 60,
+//     getGGBAnswer,
+//     isGGBAnswerValid,
+//     subject: "Mathématiques",
+//     getHint,
+//     getCorrection,
+//     hasHintAndCorrection: true,
+//     getInstruction,
+//     getStudentGGBOptions,
+//     hasGeogebra: true,
+//     getQuestionFromIdentifiers,
+//     answerType: "GGB",
+//   };

package/lib/exercises/math/conversion/clock/dateTimeOperationAdd.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type DateTime = {
+    day: number;
+    hours: number;
+    minutes: number;
+};
+type Identifiers = {
+    dateTimeStart: DateTime;
+    dateTimeDuration: DateTime;
+};
+type Options = {
+    hoursMinutesType: string;
+};
+export declare const dateTimeOperationAdd: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=dateTimeOperationAdd.d.ts.map

package/lib/exercises/math/conversion/clock/dateTimeOperationAdd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateTimeOperationAdd.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/dateTimeOperationAdd.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,QAAQ,GAAG;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsFF,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,QAAQ,CAAC;IACxB,gBAAgB,EAAE,QAAQ,CAAC;CAC5B,CAAC;AAyQF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAgBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB/D,CAAC"}

package/lib/exercises/math/conversion/clock/dateTimeOperationAdd.js

@@ -0,0 +1,319 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } 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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const arrTexDay = [
+    "lundi",
+    "mardi",
+    "mercredi",
+    "jeudi",
+    "vendredi",
+    "samedi",
+    "dimanche",
+].map((str) => `\\text{${str}}`);
+const createStrDateTime = (dateTime) => {
+    const { day, hours, minutes } = dateTime;
+    const strDay = arrTexDay[day % 7];
+    const strHours = `${hours}`;
+    const strMinutes = (() => {
+        if (minutes < 10) {
+            return `0${minutes}`;
+        }
+        else {
+            return `${minutes}`;
+        }
+    })();
+    return `${strDay},${strHours}h${strMinutes}`;
+};
+const createStrDuration = (dateTime) => {
+    const { day, hours, minutes } = dateTime;
+    const strDay = day > 0 ? `${day}j` : ``;
+    const strHours = (() => {
+        if (hours < 10) {
+            return `0${hours}h`;
+        }
+        else {
+            return `${hours}h`;
+        }
+    })();
+    const strMinutes = (() => {
+        if (minutes < 10) {
+            return `0${minutes}min`;
+        }
+        else {
+            return `${minutes}min`;
+        }
+    })();
+    return `${strDay}${strHours}${strMinutes}`;
+};
+const carryAddMod = (v1, v2, mod) => {
+    const vRaw = v1 + v2;
+    const vRefined = vRaw % mod;
+    const carry = (vRaw - vRefined) / mod;
+    return [carry, vRefined];
+};
+const dateTimeAdd = (dateTimeStart, dateTimeDuration) => {
+    const [carryHours, minutes] = carryAddMod(dateTimeStart.minutes, dateTimeDuration.minutes, 60);
+    const [carryDays, hours] = carryAddMod(dateTimeStart.hours, dateTimeDuration.hours + carryHours, 24);
+    const [carryWeeks, day] = carryAddMod(dateTimeStart.day, dateTimeDuration.day + carryDays, 7);
+    const dateTimeResult = {
+        day,
+        hours,
+        minutes,
+    };
+    return {
+        carryHours,
+        carryDays,
+        carryWeeks,
+        dateTimeResult,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { dateTimeStart, dateTimeDuration } = identifiers;
+    const { carryHours, carryDays, carryWeeks, dateTimeResult: dateTimeEnd, } = dateTimeAdd(dateTimeStart, dateTimeDuration);
+    const [strDateTimeStart, strDateTimeEnd] = [dateTimeStart, dateTimeEnd].map(createStrDateTime);
+    const strDateTimeDuration = createStrDuration(dateTimeDuration);
+    return {
+        carryHours,
+        carryDays,
+        carryWeeks,
+        dateTimeEnd,
+        strDateTimeStart,
+        strDateTimeEnd,
+        strDateTimeDuration,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { strDateTimeStart, strDateTimeDuration } = getHydrated(identifiers);
+    return `La date de début d'un évènement est : $${strDateTimeStart}$. Sa durée est : $${strDateTimeDuration}$.
+Quelle sera la date de fin ? 
+
+*La réponse est attendue sous le format : {jour},{heures}h{minutes}.*`;
+};
+const getAnswer = (identifiers) => {
+    const { strDateTimeEnd } = getHydrated(identifiers);
+    return strDateTimeEnd;
+};
+const getHint = (identifiers) => {
+    const { dateTimeStart, dateTimeDuration } = identifiers;
+    return `Une heure est composée de $60$ minutes. Un jour est composé de $24$ heures.
+
+Si on pose $0 = lundi$, $1 = mardi$, $2 = mercredi$, $3 = jeudi$, $4 = vendredi$, $5 = samedi$, $6 = dimanche$.
+
+Tu peux poser l'addition :
+
+${mdTable([
+        ["\\text{}", "\\text{j}", "\\text{h}", "\\text{min}"],
+        [
+            "\\text{début}",
+            dateTimeStart.day,
+            dateTimeStart.hours,
+            dateTimeStart.minutes,
+        ],
+        [
+            "\\text{durée}",
+            dateTimeDuration.day,
+            dateTimeDuration.hours,
+            dateTimeDuration.minutes,
+        ],
+        ["\\text{-----}", "\\text{------}", "\\text{--}", "\\text{--}"],
+        ["\\text{fin}", "\\text{}", "\\text{}", "\\text{}"],
+    ], true)}
+
+et compter les retenues toutes les $60$ minutes excédentaires,
+puis compter les retenues toutes les $24$ heures excédentaires,
+puis compter les retenues tous les $7$ jours excédentaires.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { dateTimeStart, dateTimeDuration } = identifiers;
+    const { dateTimeEnd, carryDays, carryHours, carryWeeks } = getHydrated(identifiers);
+    return `Une heure est composée de $60$ minutes. Un jour est composé de $24$ heures.
+
+Si on pose $0 = lundi$, $1 = mardi$, $2 = mercredi$, $3 = jeudi$, $4 = vendredi$, $5 = samedi$, $6 = dimanche$.
+
+On pose l'addition :
+
+${mdTable([
+        ["\\text{}", "\\text{sem}", "\\text{j}", "\\text{h}", "\\text{min}"],
+        ["retenue", carryWeeks, carryDays, carryHours, "\\text{}"],
+        [
+            "\\text{début}",
+            "\\text{}",
+            dateTimeStart.day,
+            dateTimeStart.hours,
+            dateTimeStart.minutes,
+        ],
+        [
+            "\\text{durée}",
+            "\\text{}",
+            dateTimeDuration.day,
+            dateTimeDuration.hours,
+            dateTimeDuration.minutes,
+        ],
+        [
+            "\\text{-----}",
+            "\\text{--}",
+            "\\text{------}",
+            "\\text{--}",
+            "\\text{--}",
+        ],
+        [
+            "\\text{fin}",
+            carryWeeks,
+            dateTimeEnd.day,
+            dateTimeEnd.hours,
+            dateTimeEnd.minutes,
+        ],
+    ], true)}
+
+L'évènement s'arrête donc le $${getAnswer(identifiers)}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //hour: around, minutes: around
+    propWhile(propositions, n, () => {
+        const [hoursWrong, minutesWrong] = (() => {
+            const isWrongifyH = coinFlip();
+            const isWrongifyM = !isWrongifyH || coinFlip();
+            const hoursWrong = (() => {
+                if (isWrongifyH) {
+                    return (identifiers.dateTimeDuration.hours +
+                        randint(-identifiers.dateTimeDuration.hours + 1, 10));
+                }
+                else {
+                    return identifiers.dateTimeDuration.hours;
+                }
+            })();
+            const minutesWrong = (() => {
+                if (isWrongifyM) {
+                    const uM = identifiers.dateTimeDuration.minutes % 10;
+                    return uM + randint(0, 6) * 10;
+                }
+                else {
+                    return identifiers.dateTimeDuration.minutes;
+                }
+            })();
+            return [hoursWrong, minutesWrong];
+        })();
+        const identifiersWrong = {
+            dateTimeStart: identifiers.dateTimeStart,
+            dateTimeDuration: {
+                day: identifiers.dateTimeDuration.day,
+                hours: hoursWrong,
+                minutes: minutesWrong,
+            },
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [
+        "h",
+        "comma",
+        ...arrTexDay.map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        if (!ans.includes(",")) {
+            return false;
+        }
+        if (!ans.includes("h")) {
+            return false;
+        }
+        const [strDayAns, strTimeAns] = ans.split(",");
+        const [hoursAns, minutesAns] = strTimeAns
+            .split("h")
+            .map((str) => parseInt(str));
+        const { dateTimeEnd } = getHydrated(identifiers);
+        const { day: dayAnswer, hours: hoursAnswer, minutes: minutesAnswer, } = dateTimeEnd;
+        const strDayAnswer = arrTexDay[dayAnswer % 7];
+        return zip([strDayAns, hoursAns, minutesAns], [strDayAnswer, hoursAnswer, minutesAnswer]).every(([ans, answer]) => ans === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const { hoursMinutesType } = opts;
+    const isZeroMinutes = hoursMinutesType === "heures uniquement";
+    const dateTimeStart = {
+        day: randint(0, 7),
+        hours: randint(0, 7),
+        minutes: isZeroMinutes ? 0 : randint(0, 7),
+    };
+    const dateTimeDuration = {
+        day: randint(0, 4),
+        hours: randint(0, 24),
+        minutes: isZeroMinutes ? 0 : randint(0, 12) * 5,
+    };
+    const identifiers = {
+        dateTimeStart,
+        dateTimeDuration,
+    };
+    return identifiers;
+};
+const getDateTimeOperationAddQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    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),
+    };
+    return question;
+};
+const optsDefault = {
+    hoursMinutesType: "heures et minutes",
+};
+const options = [
+    {
+        id: "hoursMinutesType",
+        label: "Méthode de résolution",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["heures et minutes", "heures uniquement"],
+        defaultValue: optsDefault.hoursMinutesType,
+    },
+];
+export const dateTimeOperationAdd = {
+    id: "dateTimeOperationAdd",
+    label: "Opérations sur les heures : addition (sur plusieurs jours)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDateTimeOperationAddQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};