21. Étonnant - 5e partie

Plus de complications

Considérons le monde suivant

Est-ce que le programme écrit précédemment fonctionne avec ? Essayez-le ?

Comme vous l'avez sûrement deviné, si vous ne l'avez pas essayé (vous devriez pourtant, vraiment !), il ne fonctionne pas. Pour cela, il faut remplacer le if que nous venions d'ajouter par un while. Essayez ! N'oubliez pas d'enregistrer.

Clarifions notre intention

Le programme que nous avons conçu semble fonctionner dans toutes les situations que nous risquons de recontrer. Ce programme, rappelons-le, doit permettre à Reeborg d'explorer son monde, en en faisant le tour une fois. Bien que le programme est plutôt court, et que sa structure devrait être claire jusque là, elle pourrait ne pas être évidente pour quelqu'un qui le voit pour la première fois. Ce serait sûrement une bonne idée d'y ajouter des commentaires et/ou de présenter des mots plus significatifs. Commençons par ajouter des commentaires, en plus grande quantité que ce dont nous pensons avoir besoin.

# nous définissons une instruction utile
def turn_right():
    repeat(turn_left, 3)

# nous marquons le point de départ en posant une sonnette
put_beeper()

# Nous trouvons alors le chemin dégagé et commençons à avancer.
while not front_is_clear():
    turn_left()
move()

# Nous savons que nous avons fait le tour du monde
# quand nous retournons à la sonnette que nous avions posée.

while not on_beeper():
    if right_is_clear(): # continuer à droite
        turn_right()
        move()
    elif front_is_clear(): # avancer en suivant le mur à droite
        move()
    else: # suivre le mur en tournant à gauche
        turn_left()

turn_off()

Bien que cela clarifie en quelque sorte notre intention pour chaque instruction, cela ne nous aide pas vraiment à résumer la méthode (aussi appelée algorithme) utilisée pour résoudre le problème. Ces commentaires ne sont donc pas aussi utile aux autres lecteurs que nous l'aurions aimé. En relisant les commentaires, nous remarquons que le programme est divisé en deux parties :
1) marquer le point de départ ;
2) suivre le mur de droite jusqu'à ce que nous revenions au départ.
Réécrivons le programme pour que ces deux parties deviennent plus claires, et écrivons les commentaires différemment.

# Ce programme demande à Reeborg de faire le tour de son monde
# dans le sens inverse des aiguilles d'une montre, s'arrêtant quand il retourne 
# à son point de départ.

def turn_right():
    repeat(turn_left, 3)

def marquer_point_depart_et_avancer():
    put_beeper()
    while not front_is_clear():
        turn_left()
    move()

def suivre_mur_de_droite():
    if right_is_clear(): 
        turn_right()
        move()
    elif front_is_clear(): 
        move()
    else: 
        turn_left()

trouve_point_depart = on_beeper   # la sonnette marque le point de départ.

#=== Fin des définitions ; début de la solution

marquer_point_depart_et_avancer()
            
while not trouve_point_depart(): 
    suivre_mur_de_droite()
      
turn_off()

N'est-ce pas plus clair ? Maintenant, supposons qu'il y ait une sonnette à chaque coin au commencement. Nous pourrions alors choisir de marquer le point de départ en enlevant une sonnette. Nous aurions besoin de faire quelques petits changements dans les définitions, mais la solution en tant que telle n'aurait pas besoin d'être changée.

Première surprise

Modifiez le programme que vous venez d'écrire pour enlever l'instruction put_beeper(). Après l'avoir enregistré, essayez ce programme légèrement modifié avec la course de haies suivante (fichier : hurdles3.wld) :

Surprise ! Au lieu de terminer face à une direction inhabituelle (en s'inclinant face au public après avoir gagné par exemple), le programme que nous venons d'écrire peut résoudre le problème des haies. Il fonctionne aussi avec celui des haies inégales (fichier : hurdles4.wld) de l'image ci-dessous - que le programme écrit auparavant pour sauter les haies ne pouvait pas  résoudre !

Surprise étonnante

Essayez le même programme modifié encore une fois avec le problème du labyrinthe que nous avons présenté dans l'une des premières leçons (fichier : maze1.wld) et illustraté ci-dessous :

Comme vous le verrez, notre programme simple peut trouver la sortie de ce labyrinthe ! Étonnant !

Conclusion

Nous avons commencé avec un problème simple à résoudre (faire le tour d'un monde rectangulaire) et, en améliorant petit à petit (c'est ce qui s'appelle le perfectionnement par étapes), nous avons réussi à écrire un programme qui a pu être utilisé pour résoudre plusieurs autres problèmes en apparence complètement différents. À chaque étape, nous n'avons fait que des petites modifications, en s'assurant que la solution fonctionnait, avant de passer à des problèmes plus complexes. Nous avons aussi utilisé des noms plus descriptifs pour des parties de l'algorithme qui ont rendu le programme plus facile à lire et, espérons-le, à comprendre. C'est une stratégie que vous devriez utiliser quand vous écrirez vos propres programmes :

Règle N° 5

Étapes à suivre en écrivant un programme :

• commencer simplement ;
• introduire de petits changements, un à la fois ;
• s'assurer que chacune des modifications que vous avez introduites n'invalide pas le travail que vous aviez fait avant ;
• ajouter des commentaires appropriés qui ne font pas que répéter ce que fait chaque instruction ; et
• choisir des noms descriptifs.

Étonnant - 4e partie - - Il pleut !