bkkhack tournament

maze.py

maze = """XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXX.XXXXX                XXXXX            XXXXXXXXXXX
XXX XXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXX XXXXXXXXXXX
XXX XX                XXXXXXXX XXX   XXXX XXXXX  XXXX
XXX XX XXXXXXXXXXXXXX XXXXXXXX XXX   XXXX XXXXX  XXXX
XXX XX XXXXXXXXXXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX     XXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX XXX XXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX XXX XXXXXX XX X XXX XXXXXXXXXX XXXXX  XXXX
XXX XX     XXX XXXXXX XX X XXX      XXXXX XXXXX  XXXX
XXX XXXXXXXXXX XXXXXX XX X XXXXXXXX XXXXX XXXXX  XXXX
XXX XXX        XXXXXX XXXXXXXX  XXX XXXXX XXXXX  XXXX
XXX XXX XXXXXXXXXXXXX      XXX  XXX XXXXX XXXXX  XXXX
XXX XXX XX         XXXXXXX XXX  XXX XXXXX XXXXXXXXXXX
XXX     XXX            XXX XXXXXXXX XXXXX            .
XXXXXXXXXXX            XXX          XXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
"""


class MazeSolver:
    def __init__(self, maze, x, y):
        self.__maze = maze.split('\n')
        self.__previous_x = None
        self.__previous_y = None
        self.__x = x
        self.__y = y
        self.__steps = None

    def steps(self):
        if self.__steps is None:
            self.__solve()
        return self.__steps

    def __solve(self):
        self.__steps = 0
        while True:
            self.__down() or self.__right() or self.__left() or self.__up()
            self.__steps += 1
            if self.__maze[self.__y][self.__x] == '.':
                break

    def __down(self):
        return self.__move(self.__x, self.__y + 1)

    def __right(self):
        return self.__move(self.__x + 1, self.__y)

    def __left(self):
        return self.__move(self.__x - 1, self.__y)

    def __up(self):
        return self.__move(self.__x, self.__y - 1)


    def __move(self, next_x, next_y):
        # Wrong coordinates
        if (next_x < 0 or next_y < 0 or next_y >= len(self.__maze) or
            next_x >= len(self.__maze[next_y])):
            return False

        # Previous position
        if next_x == self.__previous_x and next_y == self.__previous_y:
            return False

        # Cannot move to an X
        if self.__maze[next_y][next_x] == 'X':
            return False
        # We have an space or a dot, so we can move
        self.__previous_x = self.__x
        self.__previous_y = self.__y
        self.__x = next_x
        self.__y = next_y
        return True


if __name__ == "__main__":
    print MazeSolver(maze, 3, 1).steps()

Let's use only functions and closures.

maze = """XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXX.XXXXX                XXXXX            XXXXXXXXXXX
XXX XXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXX XXXXXXXXXXX
XXX XX                XXXXXXXX XXX   XXXX XXXXX  XXXX
XXX XX XXXXXXXXXXXXXX XXXXXXXX XXX   XXXX XXXXX  XXXX
XXX XX XXXXXXXXXXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX     XXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX XXX XXXXXX XX X XXX XXX   XXXX XXXXX  XXXX
XXX XX XXX XXX XXXXXX XX X XXX XXXXXXXXXX XXXXX  XXXX
XXX XX     XXX XXXXXX XX X XXX      XXXXX XXXXX  XXXX
XXX XXXXXXXXXX XXXXXX XX X XXXXXXXX XXXXX XXXXX  XXXX
XXX XXX        XXXXXX XXXXXXXX  XXX XXXXX XXXXX  XXXX
XXX XXX XXXXXXXXXXXXX      XXX  XXX XXXXX XXXXX  XXXX
XXX XXX XX         XXXXXXX XXX  XXX XXXXX XXXXXXXXXXX
XXX     XXX            XXX XXXXXXXX XXXXX            .
XXXXXXXXXXX            XXX          XXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
"""


def maze_steps(maze, start_x, start_y):
    previous = [-1, -1]
    current =[start_x, start_y]
    steps = 0
    maze = maze.split('\n')

    x = lambda: current[0]
    y = lambda: current[1]
    down = lambda: move(x(), y() + 1)
    right = lambda: move(x() + 1, y())
    left = lambda: move(x() - 1, y())
    up = lambda: move(x(), y() - 1)

    def move(next_x, next_y):
        # No need to check for wrong coordinates
        # Previous position
        if next_x == previous[0] and next_y == previous[1]:
            return False

        # Cannot move to an X
        if maze[next_y][next_x] == 'X':
            return False
        # We have an space or a dot, so we can move
        previous[0], previous[1] = current[0], current[1]
        current[0], current[1] = next_x, next_y
        return True

    while True:
        down() or right() or left() or up()
        steps += 1
        if maze[y()][x()] == '.':
            break

    return steps


if __name__ == "__main__":
    print(maze_steps(maze, 3, 1))