r = lambda x, a: (x, -1j * a )
l = lambda x, a: (x,  1j *  a )

And the interpreter line of :- for i in instrns: pos = locals ( ) [ i ]( * pos )

which keeps getting eaten by the blog softtware,..

That and making dirs a dict gives the following:-

dirs =  { 'N':1j, 'E':1, 'S':-1j, 'W':-1j }
rdirs=dict(reversed(d) for d in dirs.items())
r = lambda x, a: (x, -1j * a )
l = lambda x, a: (x,  1j *  a )
m = lambda x, a: (x + a, a )
raw_input()                     # Ignore the grid size
while 1:
    # parse initial position triplet
    x, y, dir = raw_input().split() 
    pos = (int(x) + 1j * int(y),dirs[dir] )
    # parse instructions
    instrns = raw_input().lower() 
    # Invoke the corresponding functions passing prev position
    for i in instrns: pos = locals ( ) [ i ]( * pos )
    print int(pos[0].real), int(pos[0].imag), rdirs[pos[1]]

The complex arithmetic bit was really clever :)

1) I remove your eval (because eval is evil) and replace it by a look in locals() 2) I remove your 2d vector arithmetic and replace it by complex arithmetic. Lot of people always forget about python builtin complex number support which is quite nice for 2d point operations ;)

dirs = "NESW"                   # Notations for directions
shifts = [1j,1,-1j,-1] # delta vector for each direction

One letter function names corresponding to each robot instruction

r = lambda x, a: (x, (a + 1) % 4)
l = lambda x, a: (x, (a - 1) % 4)
m = lambda x, a: (x + shifts[a], a)
raw_input()                     # Ignore the grid size
while 1:
    # parse initial position triplet
    x, y, dir = raw_input().split() 
    pos = (int(x) + 1j * int(y),dirs.find(dir))
    # parse instructions
    instrns = raw_input().lower() 
    # Invoke the corresponding functions passing prev position
    for i in instrns: pos = locals()i
    print int(pos[0].real), int(pos[0].imag), dirs[pos[1]]

May I also suggest replacing raw_input() / while 1 stuff by a more concise generator stuff:

import sys
dirs = "NESW"                   # Notations for directions
shifts = [1j,1,-1j,-1] # delta vector for each direction

One letter function names corresponding to each robot instruction

r = lambda x, a: (x, (a + 1) % 4)
l = lambda x, a: (x, (a - 1) % 4)
m = lambda x, a: (x + shifts[a], a)
def two_by_two(lines):
    while True: yield next(lines).split(), next(lines).strip()
next(sys.stdin) # ignore the grid size
for (x, y, dir), actions in two_by_two(sys.stdin):
    pos = (int(x) + 1j * int(y),dirs.find(dir))
    # parse instructions
    instrns = actions.lower()
    # Invoke the corresponding functions passing prev position
    for i in instrns: pos = locals()i
    print int(pos[0].real), int(pos[0].imag), dirs[pos[1]]

This remove the EOFError ;)

I like that kind of little snippets of code, there is always something fun to enhance (in good or bad…)

I suppose you saw this post at some aggregation site. The code snippets were embedded in the original post. The Python code and Haskell code were provided