Dans un fichier texte on vous fournit une carte comme celle-ci

...#........
...........#
............
..........#.
..#O........
..........#.

Le O représente le point de départ d'un robot. Les # représentent des obstacles. Un bord est considéré comme un obstacle.

Initialement le robot se dirige vers le haut. Chaque fois qu'il rencontre un obstacle, il tourne sur sa droite. Il s'arrête quand il a rencontré n obstacles.

Notre but est de déterminer, pour n et une carte donnés, la position du robot quand il s'arrête. La réponse est donnée par le fichier texte donnant la même carte mais avec le robot dans sa position finale.

Par exemple, avec la carte précédente et n = 4, on obtiendra

...#........
...........#
O...........
..........#.
..#.........
..........#.

Écrire une fonction parcours(source:str, dest:str, n:int) qui reçoit les arguments

• source, le nom du fichier contenant la carte,
• dest, le nom du fichier qui contiendra la réponse,
• n, le nombre d'obstacle avant l'arrêt.

La fonction ouvre le fichier source, détermine le parcours du robot, déduit la position finale du robot, écrit la réponse dans le fichier dest.

f = open(filename, 'r', encoding='utf8')
content = f.read()
f.close()
lines = content.split('\n')

Suite à ce code, lines contient un tableau où chaque item est une ligne du fichier.

['...#........', '...........#', 'O...........', '..........#.', '..#.........', '..........#.', '']

Vous remarquez que la dernière ligne est vide. Cela peut arriver mais n'est pas certain. Cela dépend de comment à été écrit le fichier. On peut s'assurer que la dernière ligne n'est pas vide en supprimant toute dernière ligne qui serait vide :

while lines[-1] == '':
    lines.pop()

La fonction `pop`a pour effet d'enlever le dernier élément.

Maintenant que nous disposons de lines, nous pouvons facilement consulter le contenu du fichier.

>>> lines[2][0]
'-'

En effet, lines[2] correspond au contenu de la ligne d'indice 2, c'est à dire 'O...........'. Donc lines[2][1] est le caractère de rang 0 dans cette ligne : 'O'.

Il sera plus simple de raisonner en points cardinaux. Le robot peut aller au Nord, au Sud, à l'Est, à l'Ouest. La position du robot est donnée par une paire de coordonnées (line, col) qui donne sa ligne et sa colonne.

Aller vers le Nord, c'est diminuer le numéro de ligne de 1. La colonne ne change pas. On peut raisonner de la même façon pour les autres de sorte que l'on pourra définir :

NORD = (-1,0)
SUD = (1,0)
EST = (...) # je vous laisse deviner
OUEST = (...) # idem

Ensuite, on dit que dans certains cas, le robot tourne à droite. Tourner à droite quand on va au Nord, cela fait aller à l'Est. Si on va au Sud, tourner à droite fait aller à l'Ouest.

C'est bien de placer tout ça dans une fonction :

def droite(dir_actuelle):
    if dir_actuelle == NORD:
        return EST
    elif dir_actuelle == SUD:
        return ...
    ...  # je vous laisse compléter

Je souhaite savoir si une certaines position (line, col) correspond à un mur. Cela arrive si le caractère à cet endroit est '#', ou bien si (line, col) correspond à une position hors du tableau.

C'est bien de prévoir une fonction pour cela :

def is_wall(lines, line, col):
    """
    lines: lignes du fichier
    line, col: position demandée
    renvoie True si la position correspond à un mur
    """
    hauteur = ... # nombre de lignes
    largeur = ... # nombre de colonnes
    if not 0 <= line < hauteur or not 0 <= col < largeur:
        # en dehors du cadre donc
        return ...
    car = lines[line][col]
    # en fonction de la valeur de car, on sait si c'est un mur
    ...

On connaît le contenu du fichier d'origine avec lines. On connait la position initiale du robot. On connait la position finale du robot.

Il faut remplacer le caractère 'O' par '.' à la position initiale et remplacer '.' par 'O' à la position finale.

On pourra utiliser la fonction suivante qui remplace le caractère à un certain indice :

def replace_car_at(chaine, new_car, index):
    """
    chaine: chaine de caractère originale
    new_car: nouveau caractère
    index: position du remplacement
    renvoie une copie de chaine où le caractère à la position
    index est remplacé par new_car. Si index trop grand, aucun changement
    """
    if index >= len(chaine):
        return chaine
    return chaine[:index] + new_car + chaine[index+1:]

Une fois lines modifié, on peut faire l'opération inverse de l'ouverture :

content = '\n'.join(lines) # recolle les lignes
f = open(filename, 'w', encoding='utf8')
f.write(content)
f.close()