Bouton Run (et pas Play)

cfea5ed0 · Aurelie Lagoutte · c5c3f0a1 · cfea5ed0 · cfea5ed0
Commit cfea5ed0 authored Jan 9, 2020 by Aurelie Lagoutte
--- a/Corriges_detailles/.ipynb_checkpoints/zigzag-checkpoint.ipynb
+++ b/Corriges_detailles/.ipynb_checkpoints/zigzag-checkpoint.ipynb
@@ -47,7 +47,7 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "# Pour executer la cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Play\n",
+    "# Pour executer une cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Run\n",
    "debut=int(input(\"Numero de début: \"))\n",
    "fin=int(input(\"Numero de fin:\"))\n",
    "nb_z=int(input(\"Nombre de z:\"))"

 %% Cell type:markdown id: tags:

 # Correction détaillé de l'exercice Zigzag

 %% Cell type:markdown id: tags:

 Le but de cette page est de vous présenter un raisonnement menant à la solution de l'exercice du zigzag. En particulier, je vais insister sur le fait qu'un algorithme ou un programme s'écrit très rarement de la première à la dernière ligne. La conception d'un algorithme ou d'un programme commence généralement par l'analyse du problème et la préparation d'un "squelette", une sorte d'algorithme (ou programme) à trou. Plus on raffine l'analyse ensuite, plus on est en mesure de remplir les trous.
 Une fois que tous les trous sont remplis, il faut executer l'algorithme ou le programme sur des exemples, pour vérifier que l'algorithme (ou le programme) semble correct dans tous les cas.

 %% Cell type:markdown id: tags:

 ## Etape 1: découper en plusieurs sous-problèmes

 Ici, on identifie facilement deux portions, qui vont se dérouler l'une à la suite de l'autre:
 - phase 1: les saisies clavier, puis
 - phase 2: l'affichage du zigzag.

 %% Cell type:markdown id: tags:

 ### Phase 1 : les saisies clavier

 %% Cell type:markdown id: tags:

 Pour la phase 1, on doit récupérer 3 entiers par saisie clavier, donc on utlise à chaque fois la fonction input, et on n'oublie pas de convertir cette saisie (qui est de type str par défaut, chaîne de caractères) en int.
 On essaye de choisir des noms de variables explicites (= qui indiquent à quoi va servir la valeur).

 %% Cell type:code id: tags:

 ``` python
-# Pour executer la cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Play
+# Pour executer une cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Run
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))
 ```

 %% Cell type:markdown id: tags:

 ### Phase 2 : l'affichage du zigzag

 %% Cell type:markdown id: tags:

 L'intérêt pédagogique de cet exercice se situe dans la phase 2: l'affichage du zigzag.
 On voit qu'il s'agit d'une répétition d'actions (ici, d'affichage), donc on va utiliser une boucle. Comme nous n'avons pas encore vu la syntaxe de la boucle Pour en Python (qui, pourtant, se prêterai bien à cet exercice), nous allons utiliser une boucle while.

 %% Cell type:markdown id: tags:

 #### La boucle

 %% Cell type:markdown id: tags:

 Pour contrôle le nombre de passage dans la boucle while, il nous faut une variable compteur, que l'on appellera par exemple i. Selon l'énoncé, il paraît assez logique que la valeur de i soit, dans la première itération, la valeur de début saisie au clavier; et à la dernière itération, la valeur de fin saisie au clavier.
 On peut donc écrire un premier squelette:

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    # a completer pour avoir l'affichage de la ligne voulue
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:5
    Nombre de z:4

 %% Cell type:markdown id: tags:

 #### Affichage de la valeur du compteur en début ou fin de ligne

 %% Cell type:markdown id: tags:

 Complétons notre squelette : à chaque itération, on veut afficher:
 - si le compteur est pair à cette itération: la valeur du compteur, puis le zzzigzag (avec le bon nombre de z)
 - si le compteur est impair à cette itération: le zzzigzag (avec le bon nombre de z), puis la valeur du compteur.

 On va donc naturellement insérer un if à l'intérieur de notre boucle while. De plus, pour l'instant, simplifions en supposant qu'on écrit zigzag toujours avec un seul z.

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i)
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
    else: # sinon, i est forcément impair
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
        print(i)
    # a completer pour avoir l'affichage de zzzigzag avec le bon nombre de z
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:1
    zigzag
    3
    4
    zigzag
    zigzag
    5
    6
    zigzag
    zigzag
    7
    8
    zigzag
    zigzag
    9
    10
    zigzag

 %% Cell type:markdown id: tags:

 En executant l'exemple ci-dessus (choisissez les valeurs que vous voulez pour début et fin), on observe un premier problème: il y a un retour à la ligne entre le mot zizag et la valeur du compteur. En effet, la fonction print ajoute par défaut un retour à la ligne après l'affichage. On a vu que l'on pouvait modifier ce comportement en régalnt à la main ce que print doit faire à la fin de chaque appel: en rajoutant end="ce qu'on veut", en l'occurence ici: on souhaite seulement un espace lorsque notre ligne ne doit pas être terminée.

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
    else: # sinon, i est forcément impair
        print("zigzag", end=" ") # a remplacer plus tard pour ajuster le nombre de z
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zigzag 3
    4 zigzag
    zigzag 5
    6 zigzag
    zigzag 7
    8 zigzag
    zigzag 9
    10 zigzag

 %% Cell type:markdown id: tags:

 C'est mieux! On se rapproche!

 %% Cell type:markdown id: tags:

 #### Ajuster le nombre de z

 %% Cell type:markdown id: tags:

 Réglons le problème du nombre de z à zigzag : il s'agit de répéter le z le nombre de fois donné par nb_z.
 Il y a ici deux approches:

 ##### Approche 1: utiliser une spécificité de Python: multiplier une chaîne de caractère par un entier

 Dans les slides du thème 3, on a vu que "ta"* 3 valait "tatata", et qu'on pouvait même concaténer (mettre bout à bout) deux chaînes de caractères avec l'opérateur +.
 Donc:

 %% Cell type:code id: tags:

 ``` python
 nb_z=4 # par exemple
 print("z"*nb_z) # affiche "zzzz"
 print("z"*nb_z+"zigzag") # ce qu'on veut
 ```

 %% Output

    zzzz
    zzzzzigzag

 %% Cell type:markdown id: tags:

 ##### Approche 2: utiliser une boucle avec un compteur pour afficher plusieurs z successivement

 L'avantage de cette approche est qu'elle pourra être reproduite dans la plupart des autres langages de programmation, mais la solution est un peu plus longue que l'approche 1.

 %% Cell type:code id: tags:

 ``` python
 nb_z=4 # par exemple
 compteur_z=0 # initialisation du compteur
 while compteur_z<nb_z:
    print("z", end="") # affiche z, sans retour à la ligne
    compteur_z=compteur_z+1
 ```

 %% Output

    zzzz

 %% Cell type:markdown id: tags:

 On complète donc notre squelette, avec l'approche 1 ou 2, peu importe.

 %% Cell type:code id: tags:

 ``` python
 # Avec l'approche 1
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        print("z"*nb_z + "zigzag")
    else: # sinon, i est forcément impair
        print("z"*nb_z +"zigzag", end=" ")
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:3
    zzzzigzag 3
    4 zzzzigzag
    zzzzigzag 5
    6 zzzzigzag
    zzzzigzag 7
    8 zzzzigzag
    zzzzigzag 9
    10 zzzzigzag

 %% Cell type:code id: tags:

 ``` python
 #Avec l'approche 2:
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        compteur_z=0 # initialisation du compteur
        while compteur_z<nb_z:
            print("z", end="") # affiche z, sans retour à la ligne
            compteur_z=compteur_z+1
        print("zigzag")
    else: # sinon, i est forcément impair
        compteur_z=0 # initialisation du compteur
        while compteur_z<nb_z:
            print("z", end="") # affiche z, sans retour à la ligne
            compteur_z=compteur_z+1
        print("zigzag", end=" ")
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zzzzzigzag 3
    4 zzzzzigzag
    zzzzzigzag 5
    6 zzzzzigzag
    zzzzzigzag 7
    8 zzzzzigzag
    zzzzzigzag 9
    10 zzzzzigzag

 %% Cell type:markdown id: tags:

 En le testant sur plusieurs exemples (notamment les exemples 1 et 2 donnés dans l'énoncé), notre solution semble fonctionner!

 %% Cell type:markdown id: tags:

 #### Amélioration du code (ici, factorisation du code)

 %% Cell type:markdown id: tags:

 Néanmoins, on peut l'améliorer, ici en "factorisant" du code: en effet, on distingue dès le début de l'itération si la valeur du compteur est paire ou non, mais on répète une partie des instructions dans les deux cas (donc, si on change d'avis plus tard sur le mot zigzag par exemple, il faudra modifier notre programme à deux fois différents pour la même chose).

 Pour cela, il faut donc repenser l'affichage de notre ligne différemment:
 - si le compteur est pair, je l'affiche tout de suite (sans retour à la ligne)
 - puis, dans tous les cas, j'affiche le zigzag avec le bon nombre de lettres (sans retour à la ligne)
 - si le compteur est impair, je l'affiche maintenant
 - dans tous les cas, je fais un retour à la ligne car ma ligne est terminée.

 On obtient alors:

 %% Cell type:code id: tags:

 ``` python
 # Avec l'approche 1
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
    print("z"*nb_z + "zigzag", end=" ")
    if i%2==1: # si i est  impair
        print(i, end=" ")
    print() # retour à la ligne dans l'affichage
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:3
    zzzzigzag 3
    4 zzzzigzag
    zzzzigzag 5
    6 zzzzigzag
    zzzzigzag 7
    8 zzzzigzag
    zzzzigzag 9
    10 zzzzigzag

 %% Cell type:code id: tags:

 ``` python
 #Avec l'approche 2:
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
    compteur_z=0 # initialisation du compteur
    while compteur_z<nb_z:
        print("z", end="") # affiche z, sans retour à la ligne
        compteur_z=compteur_z+1
    print("zigzag", end=" ")
    if i%2==1:
        print(i, end=" ")
    print() # retour à la ligne dans l'affichage
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zzzzzigzag 3
    4 zzzzzigzag
    zzzzzigzag 5
    6 zzzzzigzag
    zzzzzigzag 7
    8 zzzzzigzag
    zzzzzigzag 9
    10 zzzzzigzag

 %% Cell type:markdown id: tags:

 #### Vérification des cas particuliers

 %% Cell type:markdown id: tags:

 On vérifie maintenant le cas un peu particulier où le numéro de début entré sera plus grand que le numéro de fin, comme dans l'exemple 3 de l'énoncé:

 Numero de début:* l'utilisateur tape 5 *
 Numero de fin:* l'utilisateur tape 0 *
 Nombre de z:  * l'utilisateur tape 10 *
 (Rien ne s'affiche car 5>0)

 %% Cell type:markdown id: tags:

 Que fait notre programme dans l'état actuel, lorsque debut=5 et fin=0 ?

 %% Cell type:code id: tags:

 ``` python
 debut=5
 fin=0
 nb_z=10

 i=debut # initialisation du compteur i à 5
 while i<=fin: # premier test: 5<=0 # c'est déjà faux au début! Donc on ne rentre pas dans la boucle du tout
    # (des instructions ici)

 ```

 %% Cell type:markdown id: tags:

 Excellent! Notre programme fait déjà ce qu'il faut.

--- a/Corriges_detailles/zigzag.ipynb
+++ b/Corriges_detailles/zigzag.ipynb
@@ -47,7 +47,7 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "# Pour executer la cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Play\n",
+    "# Pour executer une cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Run\n",
    "debut=int(input(\"Numero de début: \"))\n",
    "fin=int(input(\"Numero de fin:\"))\n",
    "nb_z=int(input(\"Nombre de z:\"))"

 %% Cell type:markdown id: tags:

 # Correction détaillé de l'exercice Zigzag

 %% Cell type:markdown id: tags:

 Le but de cette page est de vous présenter un raisonnement menant à la solution de l'exercice du zigzag. En particulier, je vais insister sur le fait qu'un algorithme ou un programme s'écrit très rarement de la première à la dernière ligne. La conception d'un algorithme ou d'un programme commence généralement par l'analyse du problème et la préparation d'un "squelette", une sorte d'algorithme (ou programme) à trou. Plus on raffine l'analyse ensuite, plus on est en mesure de remplir les trous.
 Une fois que tous les trous sont remplis, il faut executer l'algorithme ou le programme sur des exemples, pour vérifier que l'algorithme (ou le programme) semble correct dans tous les cas.

 %% Cell type:markdown id: tags:

 ## Etape 1: découper en plusieurs sous-problèmes

 Ici, on identifie facilement deux portions, qui vont se dérouler l'une à la suite de l'autre:
 - phase 1: les saisies clavier, puis
 - phase 2: l'affichage du zigzag.

 %% Cell type:markdown id: tags:

 ### Phase 1 : les saisies clavier

 %% Cell type:markdown id: tags:

 Pour la phase 1, on doit récupérer 3 entiers par saisie clavier, donc on utlise à chaque fois la fonction input, et on n'oublie pas de convertir cette saisie (qui est de type str par défaut, chaîne de caractères) en int.
 On essaye de choisir des noms de variables explicites (= qui indiquent à quoi va servir la valeur).

 %% Cell type:code id: tags:

 ``` python
-# Pour executer la cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Play
+# Pour executer une cellule: cliquer sur la cellule puis lancer l'execution avec le bouton Run
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))
 ```

 %% Cell type:markdown id: tags:

 ### Phase 2 : l'affichage du zigzag

 %% Cell type:markdown id: tags:

 L'intérêt pédagogique de cet exercice se situe dans la phase 2: l'affichage du zigzag.
 On voit qu'il s'agit d'une répétition d'actions (ici, d'affichage), donc on va utiliser une boucle. Comme nous n'avons pas encore vu la syntaxe de la boucle Pour en Python (qui, pourtant, se prêterai bien à cet exercice), nous allons utiliser une boucle while.

 %% Cell type:markdown id: tags:

 #### La boucle

 %% Cell type:markdown id: tags:

 Pour contrôle le nombre de passage dans la boucle while, il nous faut une variable compteur, que l'on appellera par exemple i. Selon l'énoncé, il paraît assez logique que la valeur de i soit, dans la première itération, la valeur de début saisie au clavier; et à la dernière itération, la valeur de fin saisie au clavier.
 On peut donc écrire un premier squelette:

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    # a completer pour avoir l'affichage de la ligne voulue
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:5
    Nombre de z:4

 %% Cell type:markdown id: tags:

 #### Affichage de la valeur du compteur en début ou fin de ligne

 %% Cell type:markdown id: tags:

 Complétons notre squelette : à chaque itération, on veut afficher:
 - si le compteur est pair à cette itération: la valeur du compteur, puis le zzzigzag (avec le bon nombre de z)
 - si le compteur est impair à cette itération: le zzzigzag (avec le bon nombre de z), puis la valeur du compteur.

 On va donc naturellement insérer un if à l'intérieur de notre boucle while. De plus, pour l'instant, simplifions en supposant qu'on écrit zigzag toujours avec un seul z.

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i)
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
    else: # sinon, i est forcément impair
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
        print(i)
    # a completer pour avoir l'affichage de zzzigzag avec le bon nombre de z
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:1
    zigzag
    3
    4
    zigzag
    zigzag
    5
    6
    zigzag
    zigzag
    7
    8
    zigzag
    zigzag
    9
    10
    zigzag

 %% Cell type:markdown id: tags:

 En executant l'exemple ci-dessus (choisissez les valeurs que vous voulez pour début et fin), on observe un premier problème: il y a un retour à la ligne entre le mot zizag et la valeur du compteur. En effet, la fonction print ajoute par défaut un retour à la ligne après l'affichage. On a vu que l'on pouvait modifier ce comportement en régalnt à la main ce que print doit faire à la fin de chaque appel: en rajoutant end="ce qu'on veut", en l'occurence ici: on souhaite seulement un espace lorsque notre ligne ne doit pas être terminée.

 %% Cell type:code id: tags:

 ``` python
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        print("zigzag") # a remplacer plus tard pour ajuster le nombre de z
    else: # sinon, i est forcément impair
        print("zigzag", end=" ") # a remplacer plus tard pour ajuster le nombre de z
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zigzag 3
    4 zigzag
    zigzag 5
    6 zigzag
    zigzag 7
    8 zigzag
    zigzag 9
    10 zigzag

 %% Cell type:markdown id: tags:

 C'est mieux! On se rapproche!

 %% Cell type:markdown id: tags:

 #### Ajuster le nombre de z

 %% Cell type:markdown id: tags:

 Réglons le problème du nombre de z à zigzag : il s'agit de répéter le z le nombre de fois donné par nb_z.
 Il y a ici deux approches:

 ##### Approche 1: utiliser une spécificité de Python: multiplier une chaîne de caractère par un entier

 Dans les slides du thème 3, on a vu que "ta"* 3 valait "tatata", et qu'on pouvait même concaténer (mettre bout à bout) deux chaînes de caractères avec l'opérateur +.
 Donc:

 %% Cell type:code id: tags:

 ``` python
 nb_z=4 # par exemple
 print("z"*nb_z) # affiche "zzzz"
 print("z"*nb_z+"zigzag") # ce qu'on veut
 ```

 %% Output

    zzzz
    zzzzzigzag

 %% Cell type:markdown id: tags:

 ##### Approche 2: utiliser une boucle avec un compteur pour afficher plusieurs z successivement

 L'avantage de cette approche est qu'elle pourra être reproduite dans la plupart des autres langages de programmation, mais la solution est un peu plus longue que l'approche 1.

 %% Cell type:code id: tags:

 ``` python
 nb_z=4 # par exemple
 compteur_z=0 # initialisation du compteur
 while compteur_z<nb_z:
    print("z", end="") # affiche z, sans retour à la ligne
    compteur_z=compteur_z+1
 ```

 %% Output

    zzzz

 %% Cell type:markdown id: tags:

 On complète donc notre squelette, avec l'approche 1 ou 2, peu importe.

 %% Cell type:code id: tags:

 ``` python
 # Avec l'approche 1
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        print("z"*nb_z + "zigzag")
    else: # sinon, i est forcément impair
        print("z"*nb_z +"zigzag", end=" ")
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:3
    zzzzigzag 3
    4 zzzzigzag
    zzzzigzag 5
    6 zzzzigzag
    zzzzigzag 7
    8 zzzzigzag
    zzzzigzag 9
    10 zzzzigzag

 %% Cell type:code id: tags:

 ``` python
 #Avec l'approche 2:
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
        compteur_z=0 # initialisation du compteur
        while compteur_z<nb_z:
            print("z", end="") # affiche z, sans retour à la ligne
            compteur_z=compteur_z+1
        print("zigzag")
    else: # sinon, i est forcément impair
        compteur_z=0 # initialisation du compteur
        while compteur_z<nb_z:
            print("z", end="") # affiche z, sans retour à la ligne
            compteur_z=compteur_z+1
        print("zigzag", end=" ")
        print(i)
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zzzzzigzag 3
    4 zzzzzigzag
    zzzzzigzag 5
    6 zzzzzigzag
    zzzzzigzag 7
    8 zzzzzigzag
    zzzzzigzag 9
    10 zzzzzigzag

 %% Cell type:markdown id: tags:

 En le testant sur plusieurs exemples (notamment les exemples 1 et 2 donnés dans l'énoncé), notre solution semble fonctionner!

 %% Cell type:markdown id: tags:

 #### Amélioration du code (ici, factorisation du code)

 %% Cell type:markdown id: tags:

 Néanmoins, on peut l'améliorer, ici en "factorisant" du code: en effet, on distingue dès le début de l'itération si la valeur du compteur est paire ou non, mais on répète une partie des instructions dans les deux cas (donc, si on change d'avis plus tard sur le mot zigzag par exemple, il faudra modifier notre programme à deux fois différents pour la même chose).

 Pour cela, il faut donc repenser l'affichage de notre ligne différemment:
 - si le compteur est pair, je l'affiche tout de suite (sans retour à la ligne)
 - puis, dans tous les cas, j'affiche le zigzag avec le bon nombre de lettres (sans retour à la ligne)
 - si le compteur est impair, je l'affiche maintenant
 - dans tous les cas, je fais un retour à la ligne car ma ligne est terminée.

 On obtient alors:

 %% Cell type:code id: tags:

 ``` python
 # Avec l'approche 1
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
    print("z"*nb_z + "zigzag", end=" ")
    if i%2==1: # si i est  impair
        print(i, end=" ")
    print() # retour à la ligne dans l'affichage
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:3
    zzzzigzag 3
    4 zzzzigzag
    zzzzigzag 5
    6 zzzzigzag
    zzzzigzag 7
    8 zzzzigzag
    zzzzigzag 9
    10 zzzzigzag

 %% Cell type:code id: tags:

 ``` python
 #Avec l'approche 2:
 debut=int(input("Numero de début: "))
 fin=int(input("Numero de fin:"))
 nb_z=int(input("Nombre de z:"))

 i=debut # initialisation du compteur
 while i<=fin:
    if i%2==0: # si i est divisible par deux
        print(i, end=" ")
    compteur_z=0 # initialisation du compteur
    while compteur_z<nb_z:
        print("z", end="") # affiche z, sans retour à la ligne
        compteur_z=compteur_z+1
    print("zigzag", end=" ")
    if i%2==1:
        print(i, end=" ")
    print() # retour à la ligne dans l'affichage
    i=i+1 # on n'oublie pas d'incrémenter le compteur, ici de 1.
 ```

 %% Output

    Numero de début: 3
    Numero de fin:10
    Nombre de z:4
    zzzzzigzag 3
    4 zzzzzigzag
    zzzzzigzag 5
    6 zzzzzigzag
    zzzzzigzag 7
    8 zzzzzigzag
    zzzzzigzag 9
    10 zzzzzigzag

 %% Cell type:markdown id: tags:

 #### Vérification des cas particuliers

 %% Cell type:markdown id: tags:

 On vérifie maintenant le cas un peu particulier où le numéro de début entré sera plus grand que le numéro de fin, comme dans l'exemple 3 de l'énoncé:

 Numero de début:* l'utilisateur tape 5 *
 Numero de fin:* l'utilisateur tape 0 *
 Nombre de z:  * l'utilisateur tape 10 *
 (Rien ne s'affiche car 5>0)

 %% Cell type:markdown id: tags:

 Que fait notre programme dans l'état actuel, lorsque debut=5 et fin=0 ?

 %% Cell type:code id: tags:

 ``` python
 debut=5
 fin=0
 nb_z=10

 i=debut # initialisation du compteur i à 5
 while i<=fin: # premier test: 5<=0 # c'est déjà faux au début! Donc on ne rentre pas dans la boucle du tout
    # (des instructions ici)

 ```

 %% Cell type:markdown id: tags:

 Excellent! Notre programme fait déjà ce qu'il faut.