Commit 4a9ec7ab authored by Alexandre.DeMasi's avatar Alexandre.DeMasi
Browse files

module 4

parent 79706e17
## Les boucles sont là
Vous allez devoir répondre à un quiz comprenant des questions sur les boucles.
Seuil de réussite: 80%
Fonction du quiz: Formative
Q1 : Quels sont les trois type de boucles ?
Type de question:
- Réponse correcte unique
Réponses :
- while, do while, if Incorrect -> Mauvaise réponse, if est structure conditionnelle.
- while, do while, for Correct -> Bonne réponse.
- else, while, do while Incorrect -> Mauvaise réponse, else est structure conditionnelle.
Q2 : Quelle est la définition d'une boucle en programmation ?
Type de question:
- Réponse correcte unique
Réponses :
- C'est une structure de contrôle permettant d'exécuter un ensemble d'instructions sur la base d'une condition. Incorrect -> Mauvaise réponse, l'ensemble d'instruction n'est pas exécuté qu'une seule fois.
- C'est une structure de contrôle permettant d'exécuter un ensemble d'instructions de façon répétée sur la base d'une condition. Correct -> Bonne réponse.
- C'est une structure de contrôle permettant de tester un ensemble d'instructions de façon répétée sur la base d'une condition. Incorrect -> Mauvaise réponse, la structure de contrôle ne permet pas de tester.
Q3 : Comment s'appel une boucle lorsqu'elle n'a pas de condition valide de sortie ?
Type de question:
- Réponse correcte unique
Réponses :
- Une boucle infinie Correct -> Bonne réponse.
- Une boucle interminable Incorrect -> Mauvaise réponse, le sens est correcte mais ce n'est pas le bon mot.
- Une boucle invalide Incorrect -> Mauvaise réponse, c'est une boucle qui n'est pas finie.
\ No newline at end of file
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Instructions itératives \n",
"Les instructions itératives permettent de modifier l’exécution\n",
"séquentielle des instructions en permettant d’exécuter plusieurs\n",
"fois les mêmes instructions\n",
"\n",
"Ces instructions sont appelées des boucles (loops). Il existe 3 instructions itératives :\n",
"- La première, la plus générale: __while__ (tant que)\n",
"- La seconde, une variante: __do while__ (faire tant que)\n",
"- La troisième: __for__ (pour)\n",
"\n",
"\n",
"### Fonctionnement et utilisation de tant que (while)\n",
"\n",
"Le schéma général est le suivant:\n",
"\n",
"Tant que (condition est vraie)\n",
" exécuter [bloc d’instructions]\n",
" \n",
"Dès que la condition devient fausse, la boucle\n",
"s’arrête. La forme générale est la suivante:\n",
"\n",
"__while (condition) expression__\n",
"\n",
"Expression peuvent être une instruction ou\n",
"un bloc d’instruction. Dans le cas d’un bloc d’instructions, \n",
"le bloc doit être délimité par __{ }__\n",
"Condition est une expression booléenne qui suit\n",
"les mêmes règles que celle du if else.\n",
"\n",
"![while](while.png)\n",
"\n",
"\n",
"Dans le contexte suivant: \n",
"\n",
"expression1\n",
"while (condition) expression\n",
"expression2\n",
"\n",
"\n",
"Expression1 est exécuté, puis condition est évaluée.\n",
"Si condition est true, expression est exécutée\n",
"Si condition est false à cette étape, la boucle, c’est à dire.\n",
"expression ne sera jamais exécutée.\n",
"Puis condition est à nouveau évaluée.\n",
"Si condition est true, expression est à nouveau exécutée.\n",
"Si condition est false, la boucle s’arrête et expression 2 est exécutée.\n",
"Si condition ne devient jamais false, la boucle ne s’arrêtera jamais: on a une \n",
"boucle infinie.\n",
"\n",
"#### Exemple: Entrée utilisateur\n",
"Lorsque l’utilisateur tape son âge au clavier, il peut faire\n",
"une erreur de saisie. Il est donc nécessaire de contrôler que la\n",
"valeur saisie est valable et obliger l’utilisateur à saisir son âge\n",
"jusqu’à ce que la valeur soit valable."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"quel âge avez-vous? > "
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 10\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Vous avez 10 ans.\n"
]
},
{
"data": {
"text/html": [
"<div class=\"jp-RenderedText\">\n",
"<pre><code><span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">import </span></span><span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">scala.io.StdIn.readLine\n",
"\n",
"</span></span>\n",
"<span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">age</span></span>: <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">Int</span></span> = <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">10</span></span></code></pre>\n",
"</div>"
],
"text/plain": [
"\u001b[32mimport \u001b[39m\u001b[36mscala.io.StdIn.readLine\n",
"\n",
"\u001b[39m\n",
"\u001b[36mage\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m10\u001b[39m"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import scala.io.StdIn.readLine\n",
"\n",
"var age = 0\n",
"while (age<= 0){\n",
" age = readLine(\"quel âge avez-vous? > \").toInt\n",
" if (age <= 0) println(\"Votre âge ne peut pas être négatif\")\n",
"}\n",
"\n",
"println(\"Vous avez \"+ age + \" ans.\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"quel âge avez-vous? > "
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" -1\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Votre âge ne peut pas être négatif\n",
"quel âge avez-vous? > "
]
}
],
"source": [
"import scala.io.StdIn.readLine\n",
"\n",
"var age = 0\n",
"while (age<= 0){\n",
" age = readLine(\"quel âge avez-vous? > \").toInt\n",
" if (age <= 0) println(\"Votre âge ne peut pas être négatif\")\n",
"}\n",
"\n",
"println(\"Vous avez \"+ age + \"ans.\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Scala",
"language": "scala",
"name": "scala"
},
"language_info": {
"codemirror_mode": "text/x-scala",
"file_extension": ".scala",
"mimetype": "text/x-scala",
"name": "scala",
"nbconvert_exporter": "script",
"version": "2.12.8"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:markdown id: tags:
# Instructions itératives
Les instructions itératives permettent de modifier l’exécution
séquentielle des instructions en permettant d’exécuter plusieurs
fois les mêmes instructions
Ces instructions sont appelées des boucles (loops). Il existe 3 instructions itératives :
- La première, la plus générale: __while__ (tant que)
- La seconde, une variante: __do while__ (faire tant que)
- La troisième: __for__ (pour)
### Fonctionnement et utilisation de tant que (while)
Le schéma général est le suivant:
Tant que (condition est vraie)
exécuter [bloc d’instructions]
Dès que la condition devient fausse, la boucle
s’arrête. La forme générale est la suivante:
__while (condition) expression__
Expression peuvent être une instruction ou
un bloc d’instruction. Dans le cas d’un bloc d’instructions,
le bloc doit être délimité par __{ }__
Condition est une expression booléenne qui suit
les mêmes règles que celle du if else.
![while](while.png)
Dans le contexte suivant:
expression1
while (condition) expression
expression2
Expression1 est exécuté, puis condition est évaluée.
Si condition est true, expression est exécutée
Si condition est false à cette étape, la boucle, c’est à dire.
expression ne sera jamais exécutée.
Puis condition est à nouveau évaluée.
Si condition est true, expression est à nouveau exécutée.
Si condition est false, la boucle s’arrête et expression 2 est exécutée.
Si condition ne devient jamais false, la boucle ne s’arrêtera jamais: on a une
boucle infinie.
#### Exemple: Entrée utilisateur
Lorsque l’utilisateur tape son âge au clavier, il peut faire
une erreur de saisie. Il est donc nécessaire de contrôler que la
valeur saisie est valable et obliger l’utilisateur à saisir son âge
jusqu’à ce que la valeur soit valable.
%% Cell type:code id: tags:
``` scala
import scala.io.StdIn.readLine
var age = 0
while (age<= 0){
age = readLine("quel âge avez-vous? > ").toInt
if (age <= 0) println("Votre âge ne peut pas être négatif")
}
println("Vous avez "+ age + " ans.")
```
%%%% Output: stream
quel âge avez-vous? >
%%%% Output: stream
10
%%%% Output: stream
Vous avez 10 ans.
%%%% Output: display_data
%% Cell type:code id: tags:
``` scala
import scala.io.StdIn.readLine
var age = 0
while (age<= 0){
age = readLine("quel âge avez-vous? > ").toInt
if (age <= 0) println("Votre âge ne peut pas être négatif")
}
println("Vous avez "+ age + "ans.")
```
%%%% Output: stream
quel âge avez-vous? >
%%%% Output: stream
-1
%%%% Output: stream
Votre âge ne peut pas être négatif
quel âge avez-vous? >
## While
Vous allez devoir répondre à un quiz sur le while.
Seuil de réussite: 80%
Fonction du quiz: Formative
Q1 : Quel est la forme générale du while ?
Type de question:
- Réponse correcte unique
Réponses :
- while (condition) expression Correct -> Bonne réponse.
- while (expression) condition Incorrect -> Mauvaise réponse, la condiction vient avant l'expression.
- expression (condition) while Incorrect -> Mauvaise réponse, l'expression vient après la condition.
Q2 : Laquelle de ces boucles ci-dessous sera infinie ?
Type de question:
- Réponse correcte unique
Réponses :
``` scala
var temps = 10
while (temps> 0){
temps -= 1
prinln(temps)
}
```
Incorrect -> Mauvaise réponse, la condition de sortie est valide.
``` scala
var temps = 0
while (temps< 100){
temps += 1
prinln(temps)
}
```
Incorrect -> Mauvaise réponse, la condition de sortie est valide.
``` scala
var temps = 0
while (temps< 100){
println(temps)
}
```
Correct -> Bonne réponse, en effet la valeur de la variable temps de change pas, la condition ne peut donc être jamais vrai, la boucle est infinie.
\ No newline at end of file
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Divination\n",
"\n",
"Vous allez devoir écrire un programme qui choisis au hasard un nombre et propose à l'utilisateur de le deviner.\n",
"\n",
"### Solution"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Essai n° 1\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 1\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Le nombre à trouver est plus grand\n",
"Essai n° 2\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 9\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Le nombre à trouver est plus petit\n",
"Essai n° 3\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 4\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Le nombre à trouver est plus grand\n",
"Essai n° 4\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 6\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Le nombre à trouver est plus grand\n",
"Essai n° 5\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 8\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Le nombre à trouver est plus petit\n",
"Essai n° 6\n",
"Donnez un nombre entre 0 et 20 >"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
" 7\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Bravo, vous avez gagné en 6 essais\n"
]
},
{
"data": {
"text/html": [
"<div class=\"jp-RenderedText\">\n",
"<pre><code><span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">import </span></span><span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">scala.io.StdIn.readLine\n",
"\n",
"</span></span>\n",
"<span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">aTrouver</span></span>: <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">Int</span></span> = <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">7</span></span>\n",
"<span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">gagne</span></span>: <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">Boolean</span></span> = true\n",
"<span style=\"color: rgb(0, 187, 187)\"><span class=\"ansi-cyan-fg\">NbEssai</span></span>: <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">Int</span></span> = <span style=\"color: rgb(0, 187, 0)\"><span class=\"ansi-green-fg\">6</span></span></code></pre>\n",
"</div>"
],
"text/plain": [
"\u001b[32mimport \u001b[39m\u001b[36mscala.io.StdIn.readLine\n",
"\n",
"\u001b[39m\n",
"\u001b[36maTrouver\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m7\u001b[39m\n",
"\u001b[36mgagne\u001b[39m: \u001b[32mBoolean\u001b[39m = true\n",
"\u001b[36mNbEssai\u001b[39m: \u001b[32mInt\u001b[39m = \u001b[32m6\u001b[39m"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import scala.io.StdIn.readLine\n",
"\n",
"val aTrouver = math.ceil((math.random *20)).toInt\n",
"var gagne = false\n",
"var NbEssai = 0\n",
"\n",
"while ((NbEssai < 6) && (gagne == false)) {\n",
" println(\"Essai n° \" +(NbEssai+1))\n",
" val proposition = readLine(\"Donnez un nombre entre 0 et 20 >\").toInt\n",
" // le joueur a-t-il gagné?\n",
" if (proposition == aTrouver) gagne = true\n",
" // sinon, on teste sa proposition\n",
" else if (proposition < aTrouver) println(\"Le nombre à trouver est plus grand\")\n",
" else println(\"Le nombre à trouver est plus petit\")\n",
" // Essai suivant\n",
" NbEssai = NbEssai + 1\n",
"}\n",
"\n",
"if (gagne == true) println(\"Bravo, vous avez gagné en \" +NbEssai +\" essais\")\n",
"else println(\"Vous avez perdu, la valeur à trouver est \" +aTrouver)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Scala",
"language": "scala",
"name": "scala"
},
"language_info": {
"codemirror_mode": "text/x-scala",
"file_extension": ".scala",
"mimetype": "text/x-scala",
"name": "scala",
"nbconvert_exporter": "script",
"version": "2.12.8"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}
%% Cell type:markdown id: tags:
## Divination
Vous allez devoir écrire un programme qui choisis au hasard un nombre et propose à l'utilisateur de le deviner.
### Solution
%% Cell type:code id: tags:
``` scala
import scala.io.StdIn.readLine
val aTrouver = math.ceil((math.random *20)).toInt
var gagne = false
var NbEssai = 0
while ((NbEssai < 6) && (gagne == false)) {
println("Essai n° " +(NbEssai+1))
val proposition = readLine("Donnez un nombre entre 0 et 20 >").toInt
// le joueur a-t-il gagné?
if (proposition == aTrouver) gagne = true
// sinon, on teste sa proposition
else if (proposition < aTrouver) println("Le nombre à trouver est plus grand")
else println("Le nombre à trouver est plus petit")
// Essai suivant
NbEssai = NbEssai + 1
}
if (gagne == true) println("Bravo, vous avez gagné en " +NbEssai +" essais")
else println("Vous avez perdu, la valeur à trouver est " +aTrouver)
```
%%%% Output: stream
Essai n° 1
Donnez un nombre entre 0 et 20 >
%%%% Output: stream
1