exercices/6e/6P11.js

  1. import Exercice from '../Exercice.js'
  2. import { context } from '../../modules/context.js'
  3. import { listeQuestionsToContenu, randint, combinaisonListes, calcul, prenomF, prenomM, texteEnCouleur, texPrix, texteEnCouleurEtGras, numAlpha, texteExposant, arrondi, nombreDeChiffresDe, nombreDeChiffresDansLaPartieDecimale, nombreDeChiffresDansLaPartieEntiere, contraindreValeur, rangeMinMax, stringNombre, sp, compteOccurences } from '../../modules/outils.js'
  4. import { setReponse } from '../../modules/gestionInteractif.js'
  5. import { ajouteChampTexteMathLive } from '../../modules/interactif/questionMathLive.js'
  6. import { getVueFromUrl } from '../../modules/gestionUrl.js'
  7. export const titre = 'Résoudre des problèmes de proportionnalité en utilisant la linéarité simple'
  8. export const interactifReady = true
  9. export const interactifType = 'mathLive'
  10. export const amcReady = true
  11. export const amcType = 'AMCHybride'
  12. /**
  13. * On donne une relation de proportionnalité du type n objets coûtent x€ et on demande le prix de y objets
  14. * et le nombre d'objets qu'on peut acheter avec z€.
  15. * @author Jean-Claude Lhote
  16. * référence 6P11
  17. * 03/2021 : ajout de situations de proportionnalité : CGrolleau
  18. * 08/2021 : Ajout de la version simplifiée et de la possibilité de choisir le type de question : Guillaume Valmont
  19. * Relecture : Décembre 2021 par EE
  20. */
  21. // _____ Les fonctions suivantes renvoient un objet : {texte = ; texteCorr = ;} ______
  22. // elles correspondent aux différentes situations problèmes
  23. let versionSimplifiee = false
  24. let indexN
  25. const couplePremiersEntreEux = [
  26. [3, 4],
  27. [3, 5],
  28. [3, 7],
  29. [6, 7],
  30. [3, 8],
  31. [7, 8],
  32. [7, 9],
  33. [3, 10],
  34. [7, 10],
  35. [9, 10],
  36. [3, 11],
  37. [6, 11],
  38. [7, 11],
  39. [9, 11],
  40. [7, 12],
  41. [9, 12],
  42. [11, 12],
  43. [3, 13],
  44. [6, 13],
  45. [7, 13],
  46. [9, 13],
  47. [11, 13],
  48. [12, 13]
  49. ] // Couples de nombres premiers entre eux
  50. function questionAchat (exo, i) { // questions d'origine du 6P11 : achat.
  51. const listeDeLieux = [
  52. 'dans un magasin de bricolage',
  53. 'dans une animalerie',
  54. 'au supermarché local',
  55. "à l'épicerie",
  56. 'dans la boutique du musée'
  57. ]
  58. const listeDeChoses = [[]]
  59. const listeDePrixUnit = [[]]
  60. listeDeChoses[0] = [
  61. 'articles',
  62. 'outils',
  63. 'accessoires',
  64. "pièces d'outillage",
  65. 'pinceaux',
  66. 'ampoules',
  67. 'tournevis',
  68. 'spatules',
  69. 'raccords de tuyaux'
  70. ]
  71. listeDeChoses[1] = [
  72. 'poissons rouges',
  73. 'cannetons',
  74. 'perruches',
  75. 'phasmes',
  76. 'colliers anti-puces',
  77. 'souris',
  78. 'lapereaux',
  79. 'paquets de graines'
  80. ]
  81. listeDeChoses[2] = [
  82. 'sets de tables',
  83. 'verres',
  84. 'assiettes',
  85. 'os à macher',
  86. 'dosettes de café',
  87. 'packs de lait',
  88. 'paquets de pâtes'
  89. ]
  90. listeDeChoses[3] = [
  91. 'mangues',
  92. 'ananas',
  93. 'fruits de la passion',
  94. 'melons',
  95. 'paquets de madeleines de Commercy',
  96. 'bergamottes',
  97. 'bredeles',
  98. 'pots de cancoillotte'
  99. ]
  100. listeDeChoses[4] = [
  101. 'cartes',
  102. 'livres',
  103. 'gravures',
  104. 'puzzles',
  105. 'maquettes',
  106. 'roches',
  107. 'jeux de société'
  108. ]
  109. listeDePrixUnit[0] = [5, 4, 1.25, 3, 0.5, 1.5, 2, 6, 4.5]
  110. listeDePrixUnit[1] = [1.5, 7, 20, 2.5, 25, 2, 15, 8]
  111. listeDePrixUnit[2] = [1.25, 1.5, 2, 0.5, 5, 4.5, 3]
  112. listeDePrixUnit[3] = [2, 2.5, 1.25, 1.5, 4, 7, 12, 3]
  113. listeDePrixUnit[4] = [0.5, 5, 7, 13.5, 10, 15, 20]
  114. const index1 = randint(0, 4)
  115. const prenoms = [prenomF(), prenomM()]
  116. const index2 = randint(0, listeDeChoses[index1].length - 1)
  117. const objet = listeDeChoses[index1][index2]
  118. const pu = listeDePrixUnit[index1][index2] * (1 + randint(1, 2) * 0.2 * randint(-1, 1))
  119. let n, x, y
  120. if (versionSimplifiee) {
  121. n = couplePremiersEntreEux[indexN][0]
  122. x = couplePremiersEntreEux[indexN][1]
  123. y = n * randint(2, 5)
  124. } else {
  125. n = randint(3, 6)
  126. x = calcul(n * pu, 2)
  127. y = n * randint(2, 5)
  128. }
  129. let met = false
  130. let p, z
  131. while (met === false) {
  132. p = n * randint(2, 5)
  133. if (p !== y) {
  134. met = true
  135. }
  136. }
  137. if (versionSimplifiee) {
  138. z = x * randint(2, 5)
  139. } else {
  140. z = calcul(p * pu, 2)
  141. }
  142. let enonceAMC1 = `${numAlpha(0)} ${prenoms[0]} a repéré, ${listeDeLieux[index1]}, des ${objet} qui l'intéressent. ` +
  143. `Elle lit que ${n} ${objet} coûtent $${texPrix(x)}$${sp()}€. `
  144. let texte = enonceAMC1
  145. enonceAMC1 += `Elle veut en acheter ${y}.<br> Combien d'euros va-t-elle dépenser${sp()}? `
  146. texte += `Elle veut en acheter ${y}.<br> Combien va-t-elle dépenser${sp()}? `
  147. texte += ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: `${sp()}€` })
  148. let texteCorr = `${numAlpha(0)} ${y} ${objet}, c'est ${texteEnCouleur(
  149. stringNombre(y / n)
  150. )} fois ${texteEnCouleur(
  151. n,
  152. 'blue'
  153. )} ${objet}.<br> Si ${texteEnCouleur(
  154. n,
  155. 'blue'
  156. )} ${objet} coûtent $${texPrix(x)}$${sp()}€, alors ${texteEnCouleur(
  157. stringNombre(y / n)
  158. )} fois ${texteEnCouleur(
  159. n,
  160. 'blue'
  161. )} ${objet} coûtent ${texteEnCouleur(
  162. stringNombre(y / n)
  163. )} fois $${texPrix(x)}$${sp()}€.<br>` +
  164. `${texteEnCouleur(
  165. stringNombre(y / n)
  166. )} $\\times$ ${texteEnCouleur(`$${texPrix(x)}$`, 'blue')}${sp()}€ = ${stringNombre(y * x / n)}${sp()}€<br>` +
  167. texteEnCouleurEtGras(`Conclusion : ${prenoms[0]} dépensera $${texPrix(y * x / n)}$${sp()}€.`, 'black') + '<br>'
  168. const enonceAMC2 = `${numAlpha(1)} ${prenoms[1]
  169. } veut lui aussi acheter ces ${objet}. Il dispose de $${texPrix(z)}$${sp()}€.<br> Combien peut-il en acheter${sp()}?<br>`
  170. texte += '<br>' + enonceAMC2 + ajouteChampTexteMathLive(exo, i + 1, 'largeur25 inline', { texteApres: ' ' + objet })
  171. texteCorr += `${numAlpha(1)} $${texPrix(z)}$${sp()}€, c'est ${texteEnCouleur(
  172. stringNombre(z / x)
  173. )} fois $${texPrix(x)}$${sp()}€.<br> Si avec $${texPrix(x)}$${sp()}€ on peut acheter ${texteEnCouleur(
  174. n,
  175. 'blue'
  176. )} ${objet}, alors avec ${texteEnCouleur(
  177. stringNombre(z / x)
  178. )} fois $${texPrix(x)}$${sp()}€, on peut acheter ${texteEnCouleur(
  179. stringNombre(z / x)
  180. )} fois ${texteEnCouleur(n, 'blue')} ${objet}.<br>`
  181. texteCorr += `${texteEnCouleur(
  182. stringNombre(z / x)
  183. )} $\\times$ ${texteEnCouleur(n, 'blue')} = ${stringNombre(z * n / x)}<br>`
  184. texteCorr += texteEnCouleurEtGras(`Conclusion : ${prenoms[1]} pourra acheter ${stringNombre(z * n / x)} ${objet}.`, 'black') + '<br>'
  185. if (!context.isAmc) {
  186. setReponse(exo, i, calcul(y * x / n, 2))
  187. setReponse(exo, i + 1, calcul(z * n / x, 2))
  188. } else {
  189. exo.autoCorrection[i] = {
  190. enonce: '',
  191. enonceAvant: false,
  192. options: { multicols: true, barreseparation: true },
  193. propositions: [
  194. {
  195. type: 'AMCNum',
  196. propositions: [{
  197. texte: texteCorr,
  198. statut: '',
  199. reponse: {
  200. texte: enonceAMC1,
  201. valeur: [arrondi(y * x / n, 2)],
  202. param: {
  203. digits: nombreDeChiffresDe(arrondi(y * x / n, 2)),
  204. decimals: nombreDeChiffresDansLaPartieDecimale(arrondi(y * x / n, 2)),
  205. signe: false,
  206. approx: 0
  207. }
  208. }
  209. }]
  210. },
  211. {
  212. type: 'AMCNum',
  213. propositions: [{
  214. texte: '',
  215. statut: '',
  216. reponse: {
  217. texte: enonceAMC2,
  218. valeur: [arrondi(z * n / x, 0)],
  219. param: {
  220. digits: nombreDeChiffresDansLaPartieEntiere(z * n / x, 0),
  221. decimals: 0,
  222. signe: false,
  223. approx: 0
  224. }
  225. }
  226. }]
  227. }
  228. ]
  229. }
  230. }
  231. return {
  232. qtexte: texte,
  233. qtexteCorr: texteCorr
  234. }
  235. }
  236. function questionRecette (exo, i) { // questions avec des masses pour un nombre de personne dans des recettes correction : passage à l'unité
  237. let texte, texteCorr
  238. const liste = [ // liste des ingrédients avec différentes recettes associées et masses
  239. {
  240. ingredient: 'farine',
  241. recettes: ['gâteau au citron', 'gaufres', 'crêpes', 'cake'],
  242. quantites_par_pers: [20, 25, 30, 35, 40, 50] // A voir pour l'instant quantités "simples".
  243. },
  244. {
  245. ingredient: 'sucre',
  246. recettes: ['gâteau', 'mousse au chocolat', 'pain perdu', 'riz au lait'],
  247. quantites_par_pers: [15, 20, 25, 30, 35]
  248. },
  249. {
  250. ingredient: 'chocolat',
  251. recettes: ['gâteau', 'mousse au chocolat', 'flan', 'riz au lait'],
  252. quantites_par_pers: [10, 15, 20, 25, 30, 35]
  253. },
  254. {
  255. ingredient: 'beurre',
  256. recettes: ['gâteau', 'mousse au chocolat'],
  257. quantites_par_pers: [10, 12, 15, 18]
  258. }
  259. ]
  260. const nbPersonneInit = randint(2, 6) // nombre de personnes indiqué dans la recette.
  261. const alea4 = randint(2, 5)
  262. const nbPersonneFinal = nbPersonneInit * alea4 // nombre de personnes pour lequel on veut cuisiner
  263. const alea1 = randint(0, 3) // pour le choix de l'ingredient
  264. const alea2 = randint(0, liste[alea1].recettes.length - 1) // pour le choix de la recette
  265. const alea3 = randint(0, liste[alea1].quantites_par_pers.length - 1) // pour le choix de la quantité par personne.
  266. const quantite = calcul(liste[alea1].quantites_par_pers[alea3] * nbPersonneInit, 3) // Calcul de la quantité dans la recette à partir de la qtt/personne et du nb de personnes
  267. const quantite2 = quantite * randint(2, 5, [alea4])
  268. const quantiteReponse = calcul(liste[alea1].quantites_par_pers[alea3] * nbPersonneFinal, 3) // Pour la correction
  269. const prenoms = [prenomF(), prenomM()] // Choix de prénoms pour l'énoncé
  270. let enonceAMC1 = `${numAlpha(0)} ${prenoms[0]} lit sur sa recette de ${liste[alea1].recettes[alea2]} pour ${nbPersonneInit} personnes qu'il faut ${quantite}${sp()}g de ${liste[alea1].ingredient}. ` +
  271. `Elle veut adapter sa recette pour ${nbPersonneFinal} personnes.`
  272. texte = enonceAMC1
  273. enonceAMC1 += `<br> Quelle masse, en${sp()}g, de ${liste[alea1].ingredient} doit-elle prévoir${sp()}? `
  274. texte += `<br> Quelle masse de ${liste[alea1].ingredient} doit-elle prévoir${sp()}? `
  275. texte += ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' g' })
  276. texteCorr = `${numAlpha(0)} ${nbPersonneFinal} personnes, c'est ${texteEnCouleur(nbPersonneFinal / nbPersonneInit)} fois ${nbPersonneInit} personnes. ` +
  277. `Il faut donc ${texteEnCouleur(nbPersonneFinal / nbPersonneInit)} fois plus de ${liste[alea1].ingredient}.<br>` +
  278. `${quantite}${sp()}g $\\times $ ${texteEnCouleur(nbPersonneFinal / nbPersonneInit)} = ${quantiteReponse}${sp()}g. <br>` +
  279. texteEnCouleurEtGras(`Conclusion : ${prenoms[0]} doit utiliser ${quantiteReponse}${sp()}g de ${liste[alea1].ingredient} pour ${nbPersonneFinal} personnes.<br>`, 'black')
  280. const enonceAMC2 = `${numAlpha(1)} ${prenoms[1]} utilise la même recette de ${liste[alea1].recettes[alea2]}. Il dispose de ${quantite2}${sp()}g de ${liste[alea1].ingredient}.
  281. Pour combien de personnes au maximum peut-il cuisiner${sp()}?`
  282. texte += '<br> ' + enonceAMC2 + ajouteChampTexteMathLive(exo, i + 1, 'largeur25 inline', { texteApres: ' personnes' })
  283. texteCorr += `${numAlpha(1)} ${quantite2}${sp()}g, c'est ${texteEnCouleur(quantite2 / quantite)} fois ${quantite}${sp()}g. ` +
  284. `${prenoms[1]} peut donc cuisiner pour ${texteEnCouleur(quantite2 / quantite)} fois plus de personnes.<br>` +
  285. `${nbPersonneInit}${sp()}g $\\times $ ${texteEnCouleur(quantite2 / quantite)} = ${nbPersonneInit * quantite2 / quantite}. <br>` +
  286. texteEnCouleurEtGras(`Conclusion : ${prenoms[1]} peut donc préparer sa recette pour ${nbPersonneInit * quantite2 / quantite} personnes.`, 'black')
  287. if (!context.isAmc) {
  288. setReponse(exo, i, quantiteReponse)
  289. setReponse(exo, i + 1, calcul(nbPersonneInit * quantite2 / quantite, 3))
  290. } else {
  291. exo.autoCorrection[i] = {
  292. enonce: '',
  293. enonceAvant: false,
  294. options: { multicols: true, barreseparation: true },
  295. propositions: [
  296. {
  297. type: 'AMCNum',
  298. propositions: [{
  299. texte: texteCorr,
  300. statut: '',
  301. reponse: {
  302. texte: enonceAMC1,
  303. valeur: [quantiteReponse],
  304. param: {
  305. digits: nombreDeChiffresDe(quantiteReponse),
  306. decimals: nombreDeChiffresDansLaPartieDecimale(quantiteReponse),
  307. signe: false,
  308. approx: 0
  309. }
  310. }
  311. }]
  312. },
  313. {
  314. type: 'AMCNum',
  315. propositions: [{
  316. texte: '',
  317. statut: '',
  318. reponse: {
  319. texte: enonceAMC2,
  320. valeur: [calcul(nbPersonneInit * quantite2 / quantite, 3)],
  321. param: {
  322. digits: nombreDeChiffresDansLaPartieEntiere(nbPersonneInit * quantite2 / quantite),
  323. decimals: 0,
  324. signe: false,
  325. approx: 0
  326. }
  327. }
  328. }]
  329. }
  330. ]
  331. }
  332. }
  333. return {
  334. qtexte: texte,
  335. qtexteCorr: texteCorr
  336. }
  337. }
  338. function questionDillution (exo, i) { // questions de mélange de volumes
  339. let uniteSolvantVolumeFinal
  340. const liste = [
  341. {
  342. solute: 'sirop',
  343. volumeUnitaire: [12, 15, 18, 20],
  344. unite_solute: 'cL',
  345. unite_solvant: ['L', 'L'] // liste pour [0] singulier [1] pluriel
  346. },
  347. {
  348. solute: 'nettoyant pour sol',
  349. volumeUnitaire: [5, 8, 10, 12],
  350. unite_solute: 'cL',
  351. unite_solvant: ['L', 'L']
  352. },
  353. {
  354. solute: 'médicament',
  355. volumeUnitaire: [3, 3.5, 4, 4.5, 5, 7.5],
  356. unite_solute: 'mL',
  357. unite_solvant: ['dL', 'dL']
  358. },
  359. {
  360. solute: 'produit pour piscine',
  361. volumeUnitaire: [1, 1.2, 0.8, 1.5],
  362. unite_solute: 'L',
  363. unite_solvant: ['dizaine de mètres cubes', 'dizaines de mètres cubes']
  364. }
  365. ]
  366. const alea1 = randint(0, 3) // pour le choix du soluté
  367. const alea2 = randint(0, liste[alea1].volumeUnitaire.length - 1) // pour le choix du volume pour une unité de solvant
  368. let volumeInitial, quantite
  369. if (versionSimplifiee) {
  370. volumeInitial = couplePremiersEntreEux[indexN][0]
  371. quantite = couplePremiersEntreEux[indexN][1]
  372. } else {
  373. volumeInitial = randint(1, 5) + (randint(1, 5)) * 0.1 * randint(-1, 1, [0]) // volume d'eau pour la préparation
  374. quantite = liste[alea1].volumeUnitaire[alea2] * volumeInitial
  375. }
  376. const volumeFinal = volumeInitial * randint(2, 5)
  377. if (volumeFinal < 2) {
  378. uniteSolvantVolumeFinal = liste[alea1].unite_solvant[0]
  379. } else {
  380. uniteSolvantVolumeFinal = liste[alea1].unite_solvant[1]
  381. }
  382. const volumeFinalAff = stringNombre(volumeFinal) // pour affichage avec bon séparateur.
  383. const volumeInitialAff = stringNombre(volumeInitial) // pour affichage avec bon séparateur.
  384. let enonceAMC = `Il est indiqué sur la bouteille de ${liste[alea1].solute} ${getVueFromUrl() === 'multi' ? '<br>' : ' '} qu'il faut ` +
  385. ` ${stringNombre(quantite)}${sp()}${liste[alea1].unite_solute} de ${liste[alea1].solute} pour $${volumeInitialAff}$ `
  386. enonceAMC += volumeInitialAff < 2 ? `${liste[alea1].unite_solvant[0]} d'eau.<br> ` : `${liste[alea1].unite_solvant[1]} d'eau.<br>`
  387. enonceAMC += `On veut utiliser $${volumeFinalAff}$ ${uniteSolvantVolumeFinal} d'eau. `
  388. let texte = enonceAMC
  389. enonceAMC += `Quel volume, en${sp()}${liste[alea1].unite_solute}, de ${liste[alea1].solute} doit-on prévoir${sp()}? `
  390. texte += `Quel volume de ${liste[alea1].solute} doit-on prévoir${sp()}? `
  391. texte += ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' ' + liste[alea1].unite_solute })
  392. const texteCorr = `Le volume de ${liste[alea1].solute} est proportionnel au volume d'eau. <br> ` +
  393. ` ${texteEnCouleur(volumeFinalAff)} ${uniteSolvantVolumeFinal} d'eau, c'est ${texteEnCouleur(stringNombre(volumeFinal / volumeInitial))} fois ${volumeInitialAff} ${liste[alea1].unite_solvant[0]} d'eau. <br> ` +
  394. `Il faut donc ${texteEnCouleur(stringNombre(volumeFinal / volumeInitial))} fois plus que ${texteEnCouleur(stringNombre(quantite), 'blue')}${sp()}${liste[alea1].unite_solute} de ${liste[alea1].solute}. <br>` +
  395. `${texteEnCouleur(stringNombre(quantite), 'blue')}${sp()}${liste[alea1].unite_solute} $\\times $ ${texteEnCouleur(stringNombre(volumeFinal / volumeInitial))} = ${stringNombre(quantite * volumeFinal / volumeInitial)}${sp()}${liste[alea1].unite_solute} <br>
  396. ${texteEnCouleurEtGras(`Conclusion : Il faut donc prévoir ${stringNombre(quantite * volumeFinal / volumeInitial)}${sp()}${liste[alea1].unite_solute} de ${liste[alea1].solute}.`, 'black')}`
  397. if (!context.isAmc) {
  398. setReponse(exo, i, calcul(quantite * volumeFinal / volumeInitial, 3))
  399. } else {
  400. exo.autoCorrection[i] = {
  401. enonce: '',
  402. enonceAvant: false,
  403. // options: { multicols: true, barreseparation: true },
  404. propositions: [
  405. {
  406. type: 'AMCNum',
  407. propositions: [{
  408. texte: texteCorr,
  409. statut: '',
  410. reponse: {
  411. texte: enonceAMC,
  412. valeur: [calcul(quantite * volumeFinal / volumeInitial, 3)],
  413. param: {
  414. digits: nombreDeChiffresDe(calcul(quantite * volumeFinal / volumeInitial)),
  415. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(quantite * volumeFinal / volumeInitial, 3)),
  416. signe: false,
  417. approx: 0
  418. }
  419. }
  420. }]
  421. }
  422. ]
  423. }
  424. }
  425. return {
  426. qtexte: texte,
  427. qtexteCorr: texteCorr
  428. }
  429. }
  430. function questionDistance (exo, i) { // questions de distance parcourue à une vitesse moyenne donnée
  431. let texte, texteCorr
  432. const liste = [ // liste des "moyens de locomotion" et vitesses associées
  433. {
  434. locomotion: 'piéton',
  435. vitesse: [3, 3.5, 4, 4.5]
  436. },
  437. {
  438. locomotion: 'cycliste',
  439. vitesse: [12, 15, 16, 17, 18, 20, 22]
  440. },
  441. {
  442. locomotion: 'camion',
  443. vitesse: [75, 77.5, 80, 82.5, 85]
  444. },
  445. {
  446. locomotion: 'train',
  447. vitesse: [125, 150, 175, 185, 195]
  448. }
  449. ]
  450. const alea1 = randint(0, 3) // pour le choix de locomotion
  451. const duree = [{
  452. temps: '15 minutes',
  453. rapport: 0.25
  454. },
  455. {
  456. temps: '30 minutes',
  457. rapport: 0.5
  458. },
  459. {
  460. temps: '45 minutes',
  461. rapport: 0.75
  462. },
  463. {
  464. temps: '1 heure et demie',
  465. rapport: 1.5
  466. },
  467. {
  468. temps: '2 heures',
  469. rapport: 2
  470. },
  471. {
  472. temps: '2 heures et demie',
  473. rapport: 2.5
  474. },
  475. {
  476. temps: '3 heures',
  477. rapport: 3
  478. }]
  479. if (versionSimplifiee) {
  480. const alea1 = randint(0, 3) // pour le choix de locomotion
  481. let dureeQ, distance
  482. if (alea1 === 0) { // Si piéton
  483. const indice = randint(0, 3)
  484. dureeQ = couplePremiersEntreEux[indice][0]
  485. distance = couplePremiersEntreEux[indice][1] * (couplePremiersEntreEux[indice][0] + 1)
  486. } else {
  487. dureeQ = couplePremiersEntreEux[indexN][0]
  488. distance = couplePremiersEntreEux[indexN][1] * 2 * alea1 * alea1 * (couplePremiersEntreEux[indexN][0] + 1)
  489. }
  490. const dureeR = dureeQ * randint(2, 5)
  491. let enonceAMC = `Un ${liste[alea1].locomotion} parcourt en moyenne ${stringNombre(distance)}${sp()}km en ${dureeQ} heures.`
  492. texte = enonceAMC
  493. enonceAMC += `<br> Quelle distance, en${sp()}km, va-t-il parcourir, à la même vitesse en ${dureeR} heures${sp()}?`
  494. texte += `<br> Quelle distance va-t-il parcourir, à la même vitesse en ${dureeR} heures${sp()}?` + ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' km' })
  495. texteCorr = `${texteEnCouleur(dureeR)} heures, c'est ${texteEnCouleur(dureeR / dureeQ)} fois ${dureeQ} heures.<br> ` +
  496. `Le ${liste[alea1].locomotion} parcourra donc ${texteEnCouleur(dureeR / dureeQ)} fois plus de distance qu'en ${dureeQ} heures.<br>` +
  497. `${stringNombre(distance)}${sp()}km $\\times $ ${texteEnCouleur(dureeR / dureeQ)} = ${stringNombre(distance * dureeR / dureeQ)}${sp()}km.<br>
  498. ${texteEnCouleurEtGras(`Conclusion : Le ${liste[alea1].locomotion} parcourra ${stringNombre(distance * dureeR / dureeQ)}${sp()}km à la même vitesse en ${dureeR} heures.`, 'black')}`
  499. if (!context.isAmc) {
  500. setReponse(exo, i, calcul(distance * dureeR / dureeQ, 3))
  501. } else {
  502. exo.autoCorrection[i] = {
  503. enonce: '',
  504. enonceAvant: false,
  505. propositions: [
  506. {
  507. type: 'AMCNum',
  508. propositions: [{
  509. texte: texteCorr,
  510. statut: '',
  511. reponse: {
  512. texte: texte,
  513. valeur: [calcul(distance * dureeR / dureeQ)],
  514. param: {
  515. digits: nombreDeChiffresDe(calcul(distance * dureeR / dureeQ, 3)),
  516. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(distance * dureeR / dureeQ, 3)),
  517. signe: false,
  518. approx: 0
  519. }
  520. }
  521. }]
  522. }
  523. ]
  524. }
  525. }
  526. } else {
  527. const alea2 = randint(0, liste[alea1].vitesse.length - 1) // pour le choix du temps passé
  528. const rapportQuestion2 = [0.25, 0.5, 0.75, 1.25, 1.5, 2]
  529. let alea3 = randint(0, rapportQuestion2.length - 1)
  530. while (duree[alea2].rapport === rapportQuestion2[alea3]) {
  531. alea3 = randint(0, rapportQuestion2.length - 1)
  532. }
  533. const reponseQ1 = calcul(duree[alea2].rapport * liste[alea1].vitesse[alea2], 3)
  534. const distance = stringNombre(calcul(rapportQuestion2[alea3] * liste[alea1].vitesse[alea2])) // pour question 2
  535. let enonceAMC1 = `${numAlpha(0)} Un ${liste[alea1].locomotion} parcourt en moyenne ${stringNombre(liste[alea1].vitesse[alea2])}${sp()}km en une heure.<br>`
  536. texte = enonceAMC1
  537. enonceAMC1 += `Quelle distance, en${sp()}km, va-t-il parcourir, à la même vitesse, en ${duree[alea2].temps}${sp()}? `
  538. texte += `Quelle distance va-t-il parcourir, à la même vitesse, en ${duree[alea2].temps}${sp()}? `
  539. texte += ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' km' })
  540. texteCorr = `${numAlpha(0)} ${duree[alea2].temps}, c'est ${texteEnCouleur(stringNombre(duree[alea2].rapport))} fois une heure.<br> ` +
  541. `En une heure, le ${liste[alea1].locomotion} parcourt ${texteEnCouleur(stringNombre(liste[alea1].vitesse[alea2], 'blue'))}${sp()}km donc en ${duree[alea2].temps}, il va parcourir ${texteEnCouleur(stringNombre(duree[alea2].rapport))} fois ${texteEnCouleur(stringNombre(liste[alea1].vitesse[alea2], 'blue'))}${sp()}km. <br>` +
  542. `${texteEnCouleur(stringNombre(duree[alea2].rapport))} $\\times$ ${texteEnCouleur(stringNombre(liste[alea1].vitesse[alea2], 'blue'))}${sp()}km = ${stringNombre(reponseQ1)}${sp()}km <br>` +
  543. texteEnCouleurEtGras(` Conclusion : Le ${liste[alea1].locomotion} va donc parcourir ${stringNombre(reponseQ1)}${sp()}km.`, 'black') + '<br>'
  544. const enonceAMC2 = `${numAlpha(1)} Combien de temps, en minutes, va-t-il mettre pour parcourir ${distance}${sp()}km à cette même vitesse${sp()}? `
  545. texte += `<br> ${numAlpha(1)} Combien de temps va-t-il mettre pour parcourir ${distance}${sp()}km à cette même vitesse${sp()}? ` + ajouteChampTexteMathLive(exo, i + 1, 'largeur25 inline', { texteApres: ' minutes' })
  546. texteCorr += `${numAlpha(1)} ${distance}${sp()}km, c'est ${texteEnCouleur(stringNombre(rapportQuestion2[alea3]))} fois ${stringNombre(liste[alea1].vitesse[alea2])}${sp()}km.
  547. Le ${liste[alea1].locomotion} parcourt ${stringNombre(liste[alea1].vitesse[alea2])}${sp()}km en une heure. <br>` +
  548. `Il va mettre donc ${texteEnCouleur(stringNombre(rapportQuestion2[alea3]))} fois une heure à parcourir ${distance}${sp()}km. <br>` +
  549. texteEnCouleurEtGras(`Conclusion : Le ${liste[alea1].locomotion} va donc mettre ${stringNombre(rapportQuestion2[alea3])} heure${rapportQuestion2[alea3] >= 2 ? 's' : ''} à parcourir ${distance}${sp()}km, ce qui fait ${calcul(rapportQuestion2[alea3] * 60, 0)} minutes (${stringNombre(rapportQuestion2[alea3])} $\\times$ 60 minutes).`, 'black')
  550. if (!context.isAmc) {
  551. setReponse(exo, i, reponseQ1)
  552. setReponse(exo, i + 1, calcul(rapportQuestion2[alea3] * 60, 2))
  553. } else {
  554. exo.autoCorrection[i] = {
  555. enonce: '',
  556. enonceAvant: false,
  557. options: { multicols: true, barreseparation: true },
  558. propositions: [
  559. {
  560. type: 'AMCNum',
  561. propositions: [{
  562. texte: texteCorr,
  563. statut: '',
  564. reponse: {
  565. texte: enonceAMC1,
  566. valeur: [reponseQ1],
  567. param: {
  568. digits: nombreDeChiffresDe(reponseQ1),
  569. decimals: nombreDeChiffresDansLaPartieDecimale(reponseQ1),
  570. signe: false,
  571. approx: 0
  572. }
  573. }
  574. }]
  575. },
  576. {
  577. type: 'AMCNum',
  578. propositions: [{
  579. texte: '',
  580. statut: '',
  581. reponse: {
  582. texte: enonceAMC2,
  583. valeur: [calcul(rapportQuestion2[alea3] * 60, 2)],
  584. param: {
  585. digits: nombreDeChiffresDe(calcul(rapportQuestion2[alea3] * 60, 2)),
  586. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(rapportQuestion2[alea3] * 60, 2)),
  587. signe: false,
  588. approx: 0
  589. }
  590. }
  591. }]
  592. }
  593. ]
  594. }
  595. }
  596. }
  597. return {
  598. qtexte: texte,
  599. qtexteCorr: texteCorr
  600. }
  601. }
  602. function questionEchelle (exo, i) { // X cm sur une carte correspond à x km dans la réalité...
  603. let texte, texteCorr
  604. const distanceCarte = couplePremiersEntreEux[indexN][0] // Choix d'un nombre de cm sur la carte
  605. const distanceReel = couplePremiersEntreEux[indexN][1] // Choix d'un nombre de km dans la réalité (on évite d'avoir 1cm pour 1km)
  606. const rapport = [0.25, 0.5, 0.75, 1.25, 1.5, 2, 3, 4, 5] // rapport entre la référence et la question (rapports simples car niveau 6eme)
  607. const alea1 = randint(0, rapport.length - 1)
  608. const alea2 = randint(0, rapport.length - 1, [alea1])
  609. if (versionSimplifiee) { rapport[alea1] = randint(2, 5); rapport[alea2] = randint(2, 5, [rapport[alea1]]) }
  610. const distanceCarte2 = stringNombre(calcul(rapport[alea1] * distanceCarte, 2))
  611. const distanceReelQ2 = stringNombre(calcul(rapport[alea2] * distanceReel, 2))
  612. const prenoms = [prenomF(), prenomM()]
  613. texte = `${numAlpha(0)} Sur une carte sur laquelle ${distanceCarte} cm représente ${distanceReel}${sp()}km dans la réalité,
  614. ${prenoms[0]} mesure son trajet et elle trouve une distance de ${distanceCarte2} cm. <br>`
  615. const enonceAMC1 = texte + `À quelle distance, en${sp()}km, cela correspond dans la réalité${sp()}?`
  616. texte += `À quelle distance cela correspond dans la réalité${sp()}? ` + ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' km' })
  617. texteCorr = `${numAlpha(0)} ${distanceCarte2} cm, c'est ${texteEnCouleur(stringNombre(rapport[alea1]))} fois ${distanceCarte} cm. <br>
  618. Dans la réalité, ${distanceCarte} cm correspond à ${texteEnCouleur(distanceReel, 'blue')}${sp()}km donc` +
  619. ` ${distanceCarte2} cm va correspondre à ${texteEnCouleur(stringNombre(rapport[alea1]))} fois ${texteEnCouleur(distanceReel, 'blue')}${sp()}km. <br>` +
  620. `${texteEnCouleur(stringNombre(rapport[alea1]))} $\\times$ ${texteEnCouleur(distanceReel, 'blue')}${sp()}km = ${stringNombre(calcul(rapport[alea1] * distanceReel, 2))}${sp()}km <br>` +
  621. texteEnCouleurEtGras(`Conclusion : Le trajet de ${prenoms[0]} est de ${stringNombre(calcul(rapport[alea1] * distanceReel, 2))}${sp()}km.`, 'black') + '<br>'
  622. let enonceAMC2 = `${numAlpha(1)} Deux villes sont distantes de ${distanceReelQ2}${sp()}km. `
  623. texte += '<br> ' + enonceAMC2
  624. enonceAMC2 += `Quelle distance, en cm, va-t-on mesurer sur la carte entre ces deux villes${sp()}?`
  625. texte += `Quelle distance va-t-on mesurer sur la carte entre ces deux villes${sp()}?` + ajouteChampTexteMathLive(exo, i + 1, 'largeur25 inline', { texteApres: ' cm' })
  626. texteCorr += `${numAlpha(1)} ${distanceReelQ2}${sp()}km, c'est ${texteEnCouleur(stringNombre(rapport[alea2]))} fois ${distanceReel}${sp()}km.
  627. Or ${distanceReel}${sp()}km est représenté par ${texteEnCouleur(distanceCarte, 'blue')} cm sur la carte. <br>` +
  628. `Donc ${distanceReelQ2}${sp()}km est représenté par ${texteEnCouleur(stringNombre(rapport[alea2]))} fois ${texteEnCouleur(distanceCarte, 'blue')} cm sur la carte. <br>` +
  629. `${texteEnCouleur(stringNombre(rapport[alea2]))} $\\times$ ${texteEnCouleur(distanceCarte, 'blue')} cm = ${stringNombre(calcul(rapport[alea2] * distanceCarte, 2))} cm <br>` +
  630. texteEnCouleurEtGras(`Conclusion : Les deux villes sont séparées de ${stringNombre(calcul(rapport[alea2] * distanceCarte, 2))} cm sur la carte.`, 'black')
  631. if (!context.isAmc) {
  632. setReponse(exo, i, calcul(rapport[alea1] * distanceReel, 2))
  633. setReponse(exo, i + 1, calcul(rapport[alea2] * distanceCarte, 2))
  634. } else {
  635. exo.autoCorrection[i] = {
  636. enonce: '',
  637. enonceAvant: false,
  638. options: { multicols: true, barreseparation: true },
  639. propositions: [
  640. {
  641. type: 'AMCNum',
  642. propositions: [{
  643. texte: texteCorr,
  644. statut: '',
  645. reponse: {
  646. texte: enonceAMC1,
  647. valeur: [calcul(rapport[alea1] * distanceReel, 2)],
  648. param: {
  649. digits: nombreDeChiffresDe(calcul(rapport[alea1] * distanceReel, 2)),
  650. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(rapport[alea1] * distanceReel, 2)),
  651. signe: false,
  652. approx: 0
  653. }
  654. }
  655. }]
  656. },
  657. {
  658. type: 'AMCNum',
  659. propositions: [{
  660. texte: '',
  661. statut: '',
  662. reponse: {
  663. texte: enonceAMC2,
  664. valeur: [calcul(rapport[alea2] * distanceCarte, 2)],
  665. param: {
  666. digits: nombreDeChiffresDe(calcul(rapport[alea2] * distanceCarte, 2)),
  667. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(rapport[alea2] * distanceCarte, 2)),
  668. signe: false,
  669. approx: 0
  670. }
  671. }
  672. }]
  673. }
  674. ]
  675. }
  676. }
  677. return {
  678. qtexte: texte,
  679. qtexteCorr: texteCorr
  680. }
  681. }
  682. function questionRecouvrirSurface (exo, i) { // peinture, gazon, carrelage pour une surface donnée.
  683. let texte, texteCorr
  684. const liste = [
  685. {
  686. matiere: 'de la peinture',
  687. unite: 'L',
  688. qtt_matiere_unitaire: [0.5, 1, 1.5, 2], // quantité au m²
  689. qtt_surface: [10, 25, 15] // nombre de m² indiqués sur l'emballage
  690. },
  691. {
  692. matiere: 'du gazon',
  693. unite: 'kg',
  694. qtt_matiere_unitaire: [2.5, 3, 5, 10],
  695. qtt_surface: [200, 175, 150]
  696. },
  697. {
  698. matiere: 'du carrelage',
  699. unite: 'carreaux',
  700. qtt_matiere_unitaire: [24, 40, 60, 100],
  701. qtt_surface: [10, 20, 5]
  702. }
  703. ]
  704. const prenoms = [prenomF(), prenomM()]
  705. if (versionSimplifiee) {
  706. const alea1 = 2 // Pour avoir un coef entier, qtt_matiere_unitaire doit être plus grand que qtt_surface, ce qui n'est possible qu'avec les carreaux
  707. const quantiteD = couplePremiersEntreEux[indexN][1]
  708. const surfaceD = couplePremiersEntreEux[indexN][0]
  709. const coef = randint(2, 5)
  710. const quantiteF = calcul(quantiteD * coef, 3)
  711. const surfaceF = calcul(surfaceD * coef, 3)
  712. const enonceAMC = `${prenoms[0]} doit acheter ${liste[alea1].matiere}. ` +
  713. `Sur la notice, il est indiqué de prévoir ${quantiteD}${sp()}${liste[alea1].unite} pour ${surfaceD}${sp()}m${texteExposant(2)}. <br> ` +
  714. `Combien de${sp()}${liste[alea1].unite} doit-elle en acheter pour une surface de ${surfaceF}${sp()}m${texteExposant(2)}${sp()}?`
  715. texte = enonceAMC + ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' ' + liste[alea1].unite })
  716. texteCorr = `${stringNombre(surfaceF)}${sp()}m${texteExposant(2)}, c'est ${texteEnCouleur(coef)} fois ${surfaceD}${sp()}m${texteExposant(2)} <br>` +
  717. `Il va donc falloir ${texteEnCouleur(coef)} fois ${texteEnCouleur(quantiteD, 'blue')}${sp()}${liste[alea1].unite} pour ${stringNombre(surfaceF)}${sp()}m${texteExposant(2)} <br>` +
  718. `${texteEnCouleur(coef)} $\\times$ ${texteEnCouleur(quantiteD, 'blue')}${sp()}${liste[alea1].unite} = ${stringNombre(quantiteF)}${sp()}${liste[alea1].unite}<br>` +
  719. texteEnCouleurEtGras(`Conclusion : ${prenoms[0]} doit en acheter ${quantiteF}${sp()}${liste[alea1].unite}.`, 'black') + '<br> '
  720. if (!context.isAmc) {
  721. setReponse(exo, i, quantiteF)
  722. } else {
  723. exo.autoCorrection[i] = {
  724. enonce: '',
  725. enonceAvant: false,
  726. propositions: [
  727. {
  728. type: 'AMCNum',
  729. propositions: [{
  730. texte: texteCorr,
  731. statut: '',
  732. reponse: {
  733. texte: enonceAMC,
  734. valeur: [quantiteF],
  735. param: {
  736. digits: nombreDeChiffresDe(quantiteF),
  737. decimals: nombreDeChiffresDansLaPartieDecimale(quantiteF),
  738. signe: false,
  739. approx: 0
  740. }
  741. }
  742. }]
  743. }
  744. ]
  745. }
  746. }
  747. } else {
  748. const alea1 = randint(0, liste.length - 1)
  749. const alea2 = randint(0, liste[alea1].qtt_matiere_unitaire.length - 1)
  750. const alea3 = randint(0, liste[alea1].qtt_surface.length - 1)
  751. const rapport = [0.25, 0.5, 0.75, 1.25, 1.5, 2, 3, 4, 5] // choix parmi des rapports simples (en 6eme cela paraît suffisant)
  752. const quantite = liste[alea1].qtt_matiere_unitaire[alea2]
  753. const alea4 = randint(0, rapport.length - 1)
  754. const surfaceFinale = calcul(rapport[alea4] * liste[alea1].qtt_surface[alea3], 3)
  755. const alea5 = randint(0, rapport.length - 1, [alea4])
  756. const quantite2 = calcul(rapport[alea5] * liste[alea1].qtt_matiere_unitaire[alea2], 3)
  757. const alea6 = randint(-2, 2, [0])
  758. const surfaceFinale2 = calcul(rapport[alea5] * liste[alea1].qtt_surface[alea3] + alea6, 3)
  759. const qttaffichage = stringNombre(quantite) // Pour affichage avec virgule en séparateur.
  760. const enonceAMC1 = `${numAlpha(0)} ${prenoms[0]} doit acheter ${liste[alea1].matiere}. ` +
  761. `Sur la notice, il est indiqué de prévoir ${qttaffichage}${sp()}${liste[alea1].unite} pour ${liste[alea1].qtt_surface[alea3]}${sp()}m${texteExposant(2)}. <br> ` +
  762. `Combien de${sp()}${liste[alea1].unite} doit-elle en acheter pour une surface de ${stringNombre(surfaceFinale)}${sp()}m${texteExposant(2)}${sp()}?`
  763. texte = enonceAMC1 + ajouteChampTexteMathLive(exo, i, 'largeur25 inline', { texteApres: ' ' + liste[alea1].unite })
  764. texteCorr = `${numAlpha(0)} ${stringNombre(surfaceFinale)}${sp()}m${texteExposant(2)}, c'est ${texteEnCouleur(stringNombre(rapport[alea4]))} fois ${liste[alea1].qtt_surface[alea3]}${sp()}m${texteExposant(2)}. <br>` +
  765. `Il va donc falloir ${texteEnCouleur(stringNombre(rapport[alea4]))} fois ${texteEnCouleur(qttaffichage, 'blue')}${sp()}${liste[alea1].unite} pour ${stringNombre(surfaceFinale)}${sp()}m${texteExposant(2)}. <br>` +
  766. `${texteEnCouleur(stringNombre(rapport[alea4]))} $\\times$ ${texteEnCouleur(qttaffichage, 'blue')}${sp()}${liste[alea1].unite} = ${stringNombre(calcul(rapport[alea4] * quantite, 3))}${sp()}${liste[alea1].unite}<br>` +
  767. texteEnCouleurEtGras(`Conclusion : ${prenoms[0]} doit acheter ${stringNombre(calcul(rapport[alea4] * quantite, 3))}${sp()}${liste[alea1].unite}.`, 'black') + '<br> '
  768. const enonceAMC2 = `${numAlpha(1)} ${prenoms[1]} a acheté ${liste[alea1].matiere}. Il lui en reste ${stringNombre(quantite2)}${sp()}${liste[alea1].unite}. Sur la notice, il est aussi indiqué de prévoir ${qttaffichage}${sp()}${liste[alea1].unite} pour ${stringNombre(liste[alea1].qtt_surface[alea3])}${sp()}m${texteExposant(2)}. <br>` +
  769. `En a-t-il suffisamment pour la surface de ${stringNombre(surfaceFinale2)}${sp()}m${texteExposant(2)} qu'il lui reste à faire${sp()}?<br>`
  770. texte += '<br>' + enonceAMC2 + ajouteChampTexteMathLive(exo, i + 1, 'largeur25 inline', { texteApres: ' (oui ou non)' })
  771. texteCorr += `${numAlpha(1)} ${stringNombre(quantite2)}${sp()}${liste[alea1].unite}, c'est ${texteEnCouleur(stringNombre(rapport[alea5]))} fois ${qttaffichage}${sp()}${liste[alea1].unite}. <br>` +
  772. `Avec ${stringNombre(quantite2)}${sp()}${liste[alea1].unite} on peut donc traiter une surface de ${texteEnCouleur(stringNombre(rapport[alea5]))}
  773. fois ${texteEnCouleur(stringNombre(liste[alea1].qtt_surface[alea3]), 'blue')}${sp()}m${texteExposant(2)}. <br>` +
  774. `${texteEnCouleur(stringNombre(rapport[alea5]))} $\\times$ ${texteEnCouleur(stringNombre(liste[alea1].qtt_surface[alea3]), 'blue')}${sp()}m${texteExposant(2)} = ${stringNombre(calcul(rapport[alea5] * liste[alea1].qtt_surface[alea3], 3))}${sp()}m${texteExposant(2)}<br>`
  775. texteCorr += rapport[alea5] * liste[alea1].qtt_surface[alea3] < surfaceFinale2
  776. ? texteEnCouleurEtGras(`Conclusion : ${stringNombre(calcul(rapport[alea5] * liste[alea1].qtt_surface[alea3], 3))}${sp()}m${texteExposant(2)} < ${stringNombre(surfaceFinale2)}${sp()}m${texteExposant(2)} donc ${prenoms[1]} en a suffisamment pour ${surfaceFinale2}${sp()}m${texteExposant(2)}.`, 'black') + ' <br>'
  777. : texteEnCouleurEtGras(`Conclusion : ${stringNombre(calcul(rapport[alea5] * liste[alea1].qtt_surface[alea3], 3))}${sp()}m${texteExposant(2)} > ${stringNombre(surfaceFinale2)}${sp()}m${texteExposant(2)} donc ${prenoms[1]} n'en a pas assez pour ${surfaceFinale2}${sp()}m${texteExposant(2)}.`, 'black') + ' <br>'
  778. if (!context.isAmc) {
  779. setReponse(exo, i, calcul(rapport[alea4] * quantite, 3))
  780. setReponse(exo, i + 1, calcul(rapport[alea5] * liste[alea1].qtt_surface[alea3], 3) > surfaceFinale2 ? 'oui' : 'non')
  781. } else {
  782. exo.autoCorrection[i] = {
  783. enonce: '',
  784. enonceAvant: false,
  785. propositions: [
  786. {
  787. type: 'AMCNum',
  788. propositions: [{
  789. texte: texteCorr,
  790. statut: '',
  791. reponse: {
  792. texte: enonceAMC1,
  793. valeur: [calcul(rapport[alea4] * quantite, 3)],
  794. param: {
  795. digits: nombreDeChiffresDe(calcul(rapport[alea4] * quantite, 3)),
  796. decimals: nombreDeChiffresDansLaPartieDecimale(calcul(rapport[alea4] * quantite, 3)),
  797. signe: false,
  798. approx: 0
  799. }
  800. }
  801. }]
  802. },
  803. {
  804. type: 'AMCOpen',
  805. propositions: [{
  806. enonce: enonceAMC2,
  807. statut: 2
  808. }]
  809. }
  810. ]
  811. }
  812. }
  813. }
  814. return {
  815. qtexte: texte,
  816. qtexteCorr: texteCorr
  817. }
  818. }
  819. // _______ Fin des fonctions correspondants aux situations problèmes _____
  820. export const uuid = 'f7a14'
  821. export const ref = '6P11'
  822. export default function ProportionnaliteParLinearite () {
  823. 'use strict'
  824. let question
  825. Exercice.call(this) // Héritage de la classe Exercice()
  826. context.isHtml ? (this.spacing = 2) : (this.spacing = 1)
  827. context.isHtml ? (this.spacingCorr = 2) : (this.spacingCorr = 1)
  828. this.nbQuestions = 6
  829. this.nbCols = 1
  830. this.nbColsCorr = 1
  831. this.besoinFormulaireCaseACocher = ['Version simplifiée ne comportant que des nombres entiers']
  832. this.sup = false
  833. this.besoinFormulaire2Texte = ['Type de questions', 'Nombres séparés par des tirets\n1 : Achat\n2 : Recette\n3 : Dilution\n4 : Distance\n5 : Echelle\n6 : Surface\n7 : Mélange']
  834. this.sup2 = 7
  835. this.nouvelleVersion = function () {
  836. if (this.interactif) {
  837. this.consigne = ''
  838. } else {
  839. this.consigne = this.nbQuestions === 1 ? 'Répondre à la question posée en justifiant.' : 'Répondre aux questions posées en justifiant.'
  840. }
  841. let indiceQuestion = 0
  842. this.listeQuestions = [] // Liste de questions
  843. this.listeCorrections = [] // Liste de questions corrigées
  844. this.autoCorrection = []
  845. let listeIndexSituationsDisponible = []
  846. if (!this.sup2) { // Si aucune liste n'est saisie
  847. listeIndexSituationsDisponible = rangeMinMax(1, 6)
  848. } else {
  849. if (typeof (this.sup2) === 'number') { // Si c'est un nombre, c'est que le nombre a été saisi dans la barre d'adresses
  850. listeIndexSituationsDisponible[0] = contraindreValeur(1, 7, this.sup2, 7)
  851. } else {
  852. listeIndexSituationsDisponible = this.sup2.split('-')// Sinon on créé un tableau à partir des valeurs séparées par des -
  853. for (let i = 0; i < listeIndexSituationsDisponible.length; i++) { // on a un tableau avec des strings : ['1', '5', '2','toto','45']
  854. listeIndexSituationsDisponible[i] = contraindreValeur(1, 7, parseInt(listeIndexSituationsDisponible[i]), 7) // parseInt en fait un tableau d'entiers
  855. }
  856. }
  857. }
  858. if (compteOccurences(listeIndexSituationsDisponible, 7) > 0) listeIndexSituationsDisponible = rangeMinMax(1, 6) // Teste si l'utilisateur a choisi tout
  859. const listeIndexSituations = combinaisonListes(listeIndexSituationsDisponible, this.nbQuestions) // permet de ne pas avoir 2 fois la même situation si - de questions que de situations
  860. // boucle pour le nombre de question.
  861. // A chaque question on vérifie qu'elle n'existe pas déjà pour en refaire une. Sécurité : on ajoute un compteur pour eviter trop d'essais...
  862. let cpt = 0
  863. for (let i = 0; i < this.nbQuestions && cpt < 50;) {
  864. indexN = randint(0, couplePremiersEntreEux.length - 1)
  865. if (this.sup) {
  866. versionSimplifiee = true
  867. } else {
  868. versionSimplifiee = false
  869. }
  870. switch (parseInt(listeIndexSituations[i])) {
  871. case 1:
  872. question = questionAchat(this, indiceQuestion)
  873. if (!context.isAmc) {
  874. indiceQuestion += 2
  875. } else {
  876. indiceQuestion++
  877. }
  878. break
  879. case 2:
  880. question = questionRecette(this, indiceQuestion)
  881. if (!context.isAmc) {
  882. indiceQuestion += 2
  883. } else {
  884. indiceQuestion++
  885. }
  886. break
  887. case 3:
  888. question = questionDillution(this, indiceQuestion)
  889. indiceQuestion++
  890. break
  891. case 4:
  892. question = questionDistance(this, indiceQuestion)
  893. if (versionSimplifiee) {
  894. indiceQuestion++
  895. } else {
  896. if (!context.isAmc) {
  897. indiceQuestion += 2
  898. } else {
  899. indiceQuestion++
  900. }
  901. }
  902. break
  903. case 5:
  904. question = questionEchelle(this, indiceQuestion)
  905. if (!context.isAmc) {
  906. indiceQuestion += 2
  907. } else {
  908. indiceQuestion++
  909. }
  910. break
  911. case 6:
  912. question = questionRecouvrirSurface(this, indiceQuestion)
  913. if (versionSimplifiee) {
  914. indiceQuestion++
  915. } else {
  916. if (!context.isAmc) {
  917. indiceQuestion += 2
  918. } else {
  919. indiceQuestion++
  920. }
  921. }
  922. break
  923. }
  924. if (this.listeQuestions.indexOf(question.qtexte) === -1) { // Si la question n'a jamais été posée, on la garde.
  925. this.listeQuestions.push(question.qtexte)
  926. this.listeCorrections.push(question.qtexteCorr)
  927. i++
  928. }
  929. cpt++
  930. }
  931. listeQuestionsToContenu(this) // Espacement de 2 em entre chaque questions.
  932. }
  933. }