Codingame 'A child's play' process times out - python-3.x

Question

I'm trying to solve the coding challenge A child's play on Codingame using python.
With my program I can pass the first two test cases but when the test requires a lot of loops my program goes in timeout. What could I improve?
To fully understand the problem the details of the challenge are needed but I don't want to copy and paste them here because I'm not sure it's allowed.
I try to explain the problem with my words. Given this input:
12 6
987
...#........
...........#
............
............
..#O........
..........#.
O is the character starting point.
# are the walls you can not step on
. is where the character can step
In this example w=12 (width of the matrix) and h=6 (height of the matrix).
n = 987 is the number of steps the character has to take.
Required Output:
In this case 7 1 the position of the character after the number of moves given
Rules:
The character starts always by moving upwards
When a wall is encountered the character turns clockwise and keeps moving
The walls are placed so that the caracter can not get stuck and can not exit the matrix.
When I run the program with that test case I get the right result.
With the following test case instead:
14 10
123456789
..#...........
....#..#......
.#O.....#.....
..............
..............
.......##...#.
............#.
.#........###.
.#.#..........
..............
I get:
Failure
Process has timed out. This may mean that your solution is not optimized enough to handle some cases.
This is the code I managed to write:
import math
import sys
def find_initial_position(maze, w, h):
for i in range(0, h):
for j in range(0,w):
if maze[i][j] == "O":
return [i, j]
return -1
def can_move(maze, direction, x, y):
if direction == "U":
if maze[ x -1 ][ y ] == "#":
return False
elif direction == "R":
if maze[ x ][ y + 1 ] == "#":
return False
elif direction == "D":
if maze[ x +1 ][ y ] == "#":
return False
elif direction == "L":
if maze[ x ][ y-1 ] == "#":
return False
return True
def turn_clockwise(direction):
directions = ["U", "R", "D", "L"]
return directions[ (directions.index(direction) + 1) % 4 ]
def move(direction, coordinates):
if direction == "U":
coordinates[0] -=1
elif direction == "R":
coordinates[1] +=1
elif direction == "D":
coordinates[0] +=1
elif direction == "L":
coordinates[1] -=1
def main():
w, h = [int(i) for i in input().split()]
n = int(input())
maze = []
direction = "U"
position = [0, 0]
for i in range(h):
line = input()
maze.append(line)
position = find_initial_position(maze, w, h)
for i in range(0, n):
while not can_move(maze, direction, position[0], position[1]):
direction = turn_clockwise(direction)
move(direction, position)
print( "%(x)d %(y)d" %{"x": position[1], "y": position[0]} )
main()

Answer 1

I streamlined your code a little bit and made it somewhat more readable, by:
making use of matrix multiplication with numpy to do the 90° clockwise turns;
using the built-in str.index() to find the initial position.
Result below...
But really, this is missing the point.
If you look at the "mazes" in all the test cases, what's happening is that the "robot" is bouncing cyclically between four # obstacles in a rectangular pattern (could also be a more complex pattern). So with your approach, you're computing and re-computing the same short sequence of moves, millions and billions of times; even though the longest possible cycle cannot possibly have more moves than the number of squares in your small maze (order of magnitude).
What you should try to do is keep a continuous log of all the moves done so far (position, direction). And if – or rather, when – you end up in a (position, direction) where you've already been before, then you've covered one full cycle. No need to compute any more moves. Say your cyclic sequence is of length L and the total number of moves prescribed is n, then the final position will be sequence element number L mod n (or something like that, off-by-one errors notwithstanding).
import sys
import numpy as np
def is_obstacle(maze, position):
return maze[position[0]][position[1]] == '#'
def main():
w, h = [int(i) for i in input().split()]
n = int(input())
# Load maze
maze = []
for i in range(h):
line = input()
maze.append(line)
if 'O' in line:
# Found initial position
position = np.array([i, line.index('O')])
# Initial direction
direction = np.array([-1,0])
# Define actions
turn_clockwise = np.array([[0,-1],[1,0]])
# Walk maze
for i in range(n):
while is_obstacle(maze, position + direction):
direction = direction # turn_clockwise
position = position + direction
print( "%(x)d %(y)d" %{"x": position[1], "y": position[0]} )
main()