Je fais du groklearning sur python et j'essaie de résoudre un problème comme ci-dessous:

Vous connaissez l'histoire de Hansel et de Gretel, donc lorsque vous décidez d'aller explorer, assurez-vous de garder une trace d'où vous venez. Comme vous savez à quel point il est peu fiable de quitter une trace de chapelure, vous décidez d'écrire un programme pour vous aider à tracer votre trace.

Votre programme doit d'abord lire la taille de la grille que vous allez explorer, puis lire dans les directions: gauche, droite, haut ou bas. Vous commencez toujours à explorer en haut à gauche de votre carte. Après chaque étape, vous devez imprimer la trace, en lisant les instructions jusqu'à ce qu'une ligne vierge soit entrée. Votre programme devrait fonctionner comme ceci:

La sortie devrait ressembler à ceci:

Grid size: 3
x..
...
...
Direction: right
xx.
...
...
Direction: down
xx.
.x.
...
Direction: right
xx.
.xx
...
Direction: 

Mon code est comme ci-dessous et je suis coincé ici. Je ne sais pas trop comment trouver «x» et comment changer un voisin spécifique de «x».

size = int(input('Grid size: '))
table = []
for i in range(size):
  row=[]
  for j in range(size):
    row.append('.')
  table.append(row)
table[0][0] = 'x'
for row in table:
  print(*row,sep='')

Direction = input('Direction: ')
while Direction:
  if Direction == 'right':
    for i in range(size):
      for j in range(size-1):
        if table[i][j] == 'x':
          table[i][j+1] = 'x'
          table[i-1][j+1] = '.'
        break
  elif Direction == 'down':
    for i in range(size):
      for j in range(size-1):
        if table[j][i] == 'x':
          table[j+1][i] = 'x'
          table[j+1][i-1] = '.'
        break
  Direction = input('Direction: ')
1
Yikai 11 avril 2018 à 12:14

3 réponses

Meilleure réponse

Essentiellement, vous voulez transporter un état, c'est-à-dire la position que vous habitez actuellement, et l'état de la carte, et vous souhaitez effectuer des actions sur cet état encapsulé. C'est un cas d'utilisation parfait pour une classe. Voici une implémentation rapide et sale.

class Grid:
    def __init__(self, size):
        self.data = [['.']*size for _ in range(size)]
        self.size = size
        self.x = 0
        self.y = 0
        self.data[0][0] = 'x'
    def right(self):
        self.x = min(self.x + 1, self.size - 1)
        self.mark_position()
    def left(self):
        self.x = max(self.x - 1, 0)
        self.mark_position()
    def up(self):
        self.y = max(self.y - 1, 0)
        self.mark_position()
    def down(self):
        self.y = min(self.y + 1, self.size - 1)
        self.mark_position()
    def mark_position(self):
        self.data[self.y][self.x] = 'x'
    def __str__(self):
        return '\n'.join([''.join(sub) for sub in self.data])

Notez que notre origine (0,0) est en en haut à gauche . Une pierre d'achoppement: la liste des listes est un moyen naturel de stocker ces données, mais la première "dimension" de la liste sélectionne la "ligne", et la deuxième dimension sélectionne la "colonne", donc "x" et "y "sont inversés dans le sens où data[0][1] est la première ligne, deuxième colonne , c'est-à-dire 0 dans le y, 1 dans le x. Notez également que j'ai implémenté une logique pour ne pas vous permettre de dépasser la limite de la grille (avec min et max tronqué pour vous), mais vous d'autres possibilités seraient de faire de ce lancer une erreur, ou vous pourriez faire enrouler le monde. Essayez de l'implémenter vous-même une fois que vous aurez adopté cette approche.

Pour le tester:

In [2]: grid = Grid(3)

In [3]: print(grid)
x..
...
...

In [4]: grid.right()

In [5]: print(grid)
xx.
...
...

In [6]: grid.down()

In [7]: print(grid)
xx.
.x.
...

In [8]: grid.right()

In [9]: print(grid)
xx.
.xx
...

Remarque, vous n'avez pas besoin d'utiliser une classe, mais vous devrez peut-être faire beaucoup de passages d'arguments répétitifs, c'est-à-dire passer l'état comme arguments. Ici, j'ai fait une traduction très littérale d'une approche plus procédurale pour mettre en évidence la relation entre les deux. Remarque, je fais des copies de data juste pour être sûr, car il y a un état partout et la mutation de l'état global est un bon moyen d'introduire des bogues dans votre programme. Sinon, c'est une traduction peut-être trop littérale de la classe.

def initialize_game_state(size):
    data = [['.']*size for _ in range(size)]
    x = 0
    y = 0
    data[0][0] = 'x'
    return data, x, y

def right(data, x, y):
    new_x = min(x + 1, len(data) - 1)
    new_data = mark_position(data, new_x, y)
    return new_data, new_x, y

def left(data, x, y):
    new_x = max(x - 1, 0)
    new_data = mark_position(data, new_x, y)
    return new_data, new_x, y

def up(data, x, y):
    new_y = max(y - 1, 0)
    new_data = mark_position(data, x, new_y)
    return new_data, x, new_y

def down(data, x, y):
    new_y = min(y + 1, len(data) - 1)
    new_data = mark_position(data, x, new_y)
    return new_data, x, new_y

def mark_position(data, x, y):
    data_copy = [sub.copy() for sub in data]
    data_copy[y][x] = 'x'
    return data_copy

def grid_to_string(data):
    return '\n'.join([''.join(sub) for sub in data])
4
juanpa.arrivillaga 11 avril 2018 à 10:17
size = int(input('Grid size: '))
table = []
position = [0,0]


def print_map(table):
    for row in table:
        print(*row, sep="")


# Initialize table
for i in range(size):
    row = []
    for j in range(size):
        row.append('.')
    table.append(row)
table[position[0]][position[1]] = 'x'
print_map(table)

Direction = input('Direction: ')
while Direction:
    if Direction == 'right':
        position[1] += 1
        table[position[0]][position[1]] = "x"

    elif Direction == 'down':
        position[0] += 1
        table[position[0]][position[1]] = "x"

    print_map(table)
    Direction = input('Direction: ')

Vous avez juste besoin d'ajouter une variable pour garder une trace de la position actuelle et la mettre à jour en fonction des directions données. Vous pouvez ensuite utiliser cette variable pour mettre à jour la table.

0
Chris Mailer 11 avril 2018 à 10:09

Je pense que ce code devrait fonctionner correctement:

size = int(input('Grid size: '))
table = []
position = [0,0]

def print_map(table):
    for row in table:
        print(*row, sep="")

for i in range(size):
    row = []
    for j in range(size):
        row.append('.')
    table.append(row)
table[position[0]][position[1]] = 'x'
print_map(table)

Direction = input('Direction: ')
while Direction:
    if Direction == 'right':
        position[1] += 1
        table[position[0]][position[1]] = "x"

    elif Direction == 'left':
        position[1] -= 1
        table[position[0]][position[1]] = "x"

    elif Direction == 'up':
        position[0] -= 1
        table[position[0]][position[1]] = "x"

    elif Direction == 'down':
        position[0] += 1
        table[position[0]][position[1]] = "x"

    print_map(table)
    Direction = input('Direction: ')
1
dumb_guy 23 avril 2018 à 14:12